Warning, cross-references for /kernel/drivers/acpica/utdelete.c need to be fixed.
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114
0115
0116 #define __UTDELETE_C__
0117
0118 #include "acpi.h"
0119 #include "accommon.h"
0120 #include "acinterp.h"
0121 #include "acnamesp.h"
0122 #include "acevents.h"
0123
0124
0125 #define _COMPONENT ACPI_UTILITIES
0126 ACPI_MODULE_NAME ("utdelete")
0127
0128
0129
0130 static void
0131 AcpiUtDeleteInternalObj (
0132 ACPI_OPERAND_OBJECT *Object);
0133
0134 static void
0135 AcpiUtUpdateRefCount (
0136 ACPI_OPERAND_OBJECT *Object,
0137 UINT32 Action);
0138
0139
0140
0141
0142
0143
0144
0145
0146
0147
0148
0149
0150
0151
0152
0153 static void
0154 AcpiUtDeleteInternalObj (
0155 ACPI_OPERAND_OBJECT *Object)
0156 {
0157 void *ObjPointer = NULL;
0158 ACPI_OPERAND_OBJECT *HandlerDesc;
0159 ACPI_OPERAND_OBJECT *SecondDesc;
0160 ACPI_OPERAND_OBJECT *NextDesc;
0161 ACPI_OPERAND_OBJECT **LastObjPtr;
0162
0163
0164 ACPI_FUNCTION_TRACE_PTR (UtDeleteInternalObj, Object);
0165
0166
0167 if (!Object)
0168 {
0169 return_VOID;
0170 }
0171
0172
0173
0174
0175
0176 switch (Object->Common.Type)
0177 {
0178 case ACPI_TYPE_STRING:
0179
0180 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** String %p, ptr %p\n",
0181 Object, Object->String.Pointer));
0182
0183
0184
0185 if (!(Object->Common.Flags & AOPOBJ_STATIC_POINTER))
0186 {
0187
0188
0189 ObjPointer = Object->String.Pointer;
0190 }
0191 break;
0192
0193
0194 case ACPI_TYPE_BUFFER:
0195
0196 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** Buffer %p, ptr %p\n",
0197 Object, Object->Buffer.Pointer));
0198
0199
0200
0201 if (!(Object->Common.Flags & AOPOBJ_STATIC_POINTER))
0202 {
0203
0204
0205 ObjPointer = Object->Buffer.Pointer;
0206 }
0207 break;
0208
0209
0210 case ACPI_TYPE_PACKAGE:
0211
0212 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, " **** Package of count %X\n",
0213 Object->Package.Count));
0214
0215
0216
0217
0218
0219
0220
0221
0222 ObjPointer = Object->Package.Elements;
0223 break;
0224
0225
0226
0227
0228
0229
0230 case ACPI_TYPE_DEVICE:
0231
0232 if (Object->Device.GpeBlock)
0233 {
0234 (void) AcpiEvDeleteGpeBlock (Object->Device.GpeBlock);
0235 }
0236
0237
0238
0239 case ACPI_TYPE_PROCESSOR:
0240 case ACPI_TYPE_THERMAL:
0241
0242
0243
0244 HandlerDesc = Object->CommonNotify.Handler;
0245 while (HandlerDesc)
0246 {
0247 NextDesc = HandlerDesc->AddressSpace.Next;
0248 AcpiUtRemoveReference (HandlerDesc);
0249 HandlerDesc = NextDesc;
0250 }
0251 break;
0252
0253
0254 case ACPI_TYPE_MUTEX:
0255
0256 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0257 "***** Mutex %p, OS Mutex %p\n",
0258 Object, Object->Mutex.OsMutex));
0259
0260 if (Object == AcpiGbl_GlobalLockMutex)
0261 {
0262
0263
0264 (void) AcpiOsDeleteSemaphore (AcpiGbl_GlobalLockSemaphore);
0265 AcpiGbl_GlobalLockSemaphore = NULL;
0266
0267 AcpiOsDeleteMutex (Object->Mutex.OsMutex);
0268 AcpiGbl_GlobalLockMutex = NULL;
0269 }
0270 else
0271 {
0272 AcpiExUnlinkMutex (Object);
0273 AcpiOsDeleteMutex (Object->Mutex.OsMutex);
0274 }
0275 break;
0276
0277
0278 case ACPI_TYPE_EVENT:
0279
0280 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0281 "***** Event %p, OS Semaphore %p\n",
0282 Object, Object->Event.OsSemaphore));
0283
0284 (void) AcpiOsDeleteSemaphore (Object->Event.OsSemaphore);
0285 Object->Event.OsSemaphore = NULL;
0286 break;
0287
0288
0289 case ACPI_TYPE_METHOD:
0290
0291 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0292 "***** Method %p\n", Object));
0293
0294
0295
0296 if (Object->Method.Mutex)
0297 {
0298 AcpiOsDeleteMutex (Object->Method.Mutex->Mutex.OsMutex);
0299 AcpiUtDeleteObjectDesc (Object->Method.Mutex);
0300 Object->Method.Mutex = NULL;
0301 }
0302 break;
0303
0304
0305 case ACPI_TYPE_REGION:
0306
0307 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0308 "***** Region %p\n", Object));
0309
0310 SecondDesc = AcpiNsGetSecondaryObject (Object);
0311 if (SecondDesc)
0312 {
0313
0314
0315
0316
0317
0318 HandlerDesc = Object->Region.Handler;
0319 if (HandlerDesc)
0320 {
0321 NextDesc = HandlerDesc->AddressSpace.RegionList;
0322 LastObjPtr = &HandlerDesc->AddressSpace.RegionList;
0323
0324
0325
0326 while (NextDesc)
0327 {
0328 if (NextDesc == Object)
0329 {
0330 *LastObjPtr = NextDesc->Region.Next;
0331 break;
0332 }
0333
0334
0335
0336 LastObjPtr = &NextDesc->Region.Next;
0337 NextDesc = NextDesc->Region.Next;
0338 }
0339
0340 if (HandlerDesc->AddressSpace.HandlerFlags &
0341 ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
0342 {
0343
0344
0345 if (HandlerDesc->AddressSpace.Setup)
0346 {
0347 (void) HandlerDesc->AddressSpace.Setup (Object,
0348 ACPI_REGION_DEACTIVATE,
0349 HandlerDesc->AddressSpace.Context,
0350 &SecondDesc->Extra.RegionContext);
0351 }
0352 }
0353
0354 AcpiUtRemoveReference (HandlerDesc);
0355 }
0356
0357
0358
0359 AcpiUtDeleteObjectDesc (SecondDesc);
0360 }
0361 break;
0362
0363
0364 case ACPI_TYPE_BUFFER_FIELD:
0365
0366 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0367 "***** Buffer Field %p\n", Object));
0368
0369 SecondDesc = AcpiNsGetSecondaryObject (Object);
0370 if (SecondDesc)
0371 {
0372 AcpiUtDeleteObjectDesc (SecondDesc);
0373 }
0374 break;
0375
0376
0377 case ACPI_TYPE_LOCAL_BANK_FIELD:
0378
0379 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0380 "***** Bank Field %p\n", Object));
0381
0382 SecondDesc = AcpiNsGetSecondaryObject (Object);
0383 if (SecondDesc)
0384 {
0385 AcpiUtDeleteObjectDesc (SecondDesc);
0386 }
0387 break;
0388
0389
0390 default:
0391 break;
0392 }
0393
0394
0395
0396 if (ObjPointer)
0397 {
0398 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object Subptr %p\n",
0399 ObjPointer));
0400 ACPI_FREE (ObjPointer);
0401 }
0402
0403
0404
0405 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
0406 Object, AcpiUtGetObjectTypeName (Object)));
0407
0408 AcpiUtDeleteObjectDesc (Object);
0409 return_VOID;
0410 }
0411
0412
0413
0414
0415
0416
0417
0418
0419
0420
0421
0422
0423
0424
0425
0426 void
0427 AcpiUtDeleteInternalObjectList (
0428 ACPI_OPERAND_OBJECT **ObjList)
0429 {
0430 ACPI_OPERAND_OBJECT **InternalObj;
0431
0432
0433 ACPI_FUNCTION_TRACE (UtDeleteInternalObjectList);
0434
0435
0436
0437
0438 for (InternalObj = ObjList; *InternalObj; InternalObj++)
0439 {
0440 AcpiUtRemoveReference (*InternalObj);
0441 }
0442
0443
0444
0445 ACPI_FREE (ObjList);
0446 return_VOID;
0447 }
0448
0449
0450
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460
0461
0462
0463 static void
0464 AcpiUtUpdateRefCount (
0465 ACPI_OPERAND_OBJECT *Object,
0466 UINT32 Action)
0467 {
0468 UINT16 Count;
0469 UINT16 NewCount;
0470
0471
0472 ACPI_FUNCTION_NAME (UtUpdateRefCount);
0473
0474
0475 if (!Object)
0476 {
0477 return;
0478 }
0479
0480 Count = Object->Common.ReferenceCount;
0481 NewCount = Count;
0482
0483
0484
0485
0486 switch (Action)
0487 {
0488 case REF_INCREMENT:
0489
0490 NewCount++;
0491 Object->Common.ReferenceCount = NewCount;
0492
0493 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0494 "Obj %p Refs=%X, [Incremented]\n",
0495 Object, NewCount));
0496 break;
0497
0498 case REF_DECREMENT:
0499
0500 if (Count < 1)
0501 {
0502 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0503 "Obj %p Refs=%X, can't decrement! (Set to 0)\n",
0504 Object, NewCount));
0505
0506 NewCount = 0;
0507 }
0508 else
0509 {
0510 NewCount--;
0511
0512 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0513 "Obj %p Refs=%X, [Decremented]\n",
0514 Object, NewCount));
0515 }
0516
0517 if (Object->Common.Type == ACPI_TYPE_METHOD)
0518 {
0519 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0520 "Method Obj %p Refs=%X, [Decremented]\n", Object, NewCount));
0521 }
0522
0523 Object->Common.ReferenceCount = NewCount;
0524 if (NewCount == 0)
0525 {
0526 AcpiUtDeleteInternalObj (Object);
0527 }
0528 break;
0529
0530 case REF_FORCE_DELETE:
0531
0532 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0533 "Obj %p Refs=%X, Force delete! (Set to 0)\n", Object, Count));
0534
0535 NewCount = 0;
0536 Object->Common.ReferenceCount = NewCount;
0537 AcpiUtDeleteInternalObj (Object);
0538 break;
0539
0540 default:
0541
0542 ACPI_ERROR ((AE_INFO, "Unknown action (%X)", Action));
0543 break;
0544 }
0545
0546
0547
0548
0549
0550 if (Count > ACPI_MAX_REFERENCE_COUNT)
0551 {
0552 ACPI_WARNING ((AE_INFO,
0553 "Large Reference Count (%X) in object %p", Count, Object));
0554 }
0555 }
0556
0557
0558
0559
0560
0561
0562
0563
0564
0565
0566
0567
0568
0569
0570
0571
0572
0573
0574
0575
0576
0577
0578
0579
0580 ACPI_STATUS
0581 AcpiUtUpdateObjectReference (
0582 ACPI_OPERAND_OBJECT *Object,
0583 UINT16 Action)
0584 {
0585 ACPI_STATUS Status = AE_OK;
0586 ACPI_GENERIC_STATE *StateList = NULL;
0587 ACPI_OPERAND_OBJECT *NextObject = NULL;
0588 ACPI_GENERIC_STATE *State;
0589 UINT32 i;
0590
0591
0592 ACPI_FUNCTION_TRACE_PTR (UtUpdateObjectReference, Object);
0593
0594
0595 while (Object)
0596 {
0597
0598
0599 if (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED)
0600 {
0601 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0602 "Object %p is NS handle\n", Object));
0603 return_ACPI_STATUS (AE_OK);
0604 }
0605
0606
0607
0608
0609
0610 switch (Object->Common.Type)
0611 {
0612 case ACPI_TYPE_DEVICE:
0613 case ACPI_TYPE_PROCESSOR:
0614 case ACPI_TYPE_POWER:
0615 case ACPI_TYPE_THERMAL:
0616
0617
0618
0619 AcpiUtUpdateRefCount (Object->CommonNotify.SystemNotify, Action);
0620 AcpiUtUpdateRefCount (Object->CommonNotify.DeviceNotify, Action);
0621 break;
0622
0623 case ACPI_TYPE_PACKAGE:
0624
0625
0626
0627
0628 for (i = 0; i < Object->Package.Count; i++)
0629 {
0630
0631
0632
0633
0634
0635 Status = AcpiUtCreateUpdateStateAndPush (
0636 Object->Package.Elements[i], Action, &StateList);
0637 if (ACPI_FAILURE (Status))
0638 {
0639 goto ErrorExit;
0640 }
0641 }
0642 break;
0643
0644 case ACPI_TYPE_BUFFER_FIELD:
0645
0646 NextObject = Object->BufferField.BufferObj;
0647 break;
0648
0649 case ACPI_TYPE_LOCAL_REGION_FIELD:
0650
0651 NextObject = Object->Field.RegionObj;
0652 break;
0653
0654 case ACPI_TYPE_LOCAL_BANK_FIELD:
0655
0656 NextObject = Object->BankField.BankObj;
0657 Status = AcpiUtCreateUpdateStateAndPush (
0658 Object->BankField.RegionObj, Action, &StateList);
0659 if (ACPI_FAILURE (Status))
0660 {
0661 goto ErrorExit;
0662 }
0663 break;
0664
0665 case ACPI_TYPE_LOCAL_INDEX_FIELD:
0666
0667 NextObject = Object->IndexField.IndexObj;
0668 Status = AcpiUtCreateUpdateStateAndPush (
0669 Object->IndexField.DataObj, Action, &StateList);
0670 if (ACPI_FAILURE (Status))
0671 {
0672 goto ErrorExit;
0673 }
0674 break;
0675
0676 case ACPI_TYPE_LOCAL_REFERENCE:
0677
0678
0679
0680
0681
0682 if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
0683 (Object->Reference.Class== ACPI_REFCLASS_NAME))
0684 {
0685 NextObject = Object->Reference.Object;
0686 }
0687 break;
0688
0689 case ACPI_TYPE_REGION:
0690 default:
0691 break;
0692 }
0693
0694
0695
0696
0697
0698
0699 AcpiUtUpdateRefCount (Object, Action);
0700 Object = NULL;
0701
0702
0703
0704 if (NextObject)
0705 {
0706 Object = NextObject;
0707 NextObject = NULL;
0708 }
0709 else if (StateList)
0710 {
0711 State = AcpiUtPopGenericState (&StateList);
0712 Object = State->Update.Object;
0713 AcpiUtDeleteGenericState (State);
0714 }
0715 }
0716
0717 return_ACPI_STATUS (AE_OK);
0718
0719
0720 ErrorExit:
0721
0722 ACPI_EXCEPTION ((AE_INFO, Status,
0723 "Could not update object reference count"));
0724
0725
0726
0727 while (StateList)
0728 {
0729 State = AcpiUtPopGenericState (&StateList);
0730 AcpiUtDeleteGenericState (State);
0731 }
0732
0733 return_ACPI_STATUS (Status);
0734 }
0735
0736
0737
0738
0739
0740
0741
0742
0743
0744
0745
0746
0747
0748
0749
0750 void
0751 AcpiUtAddReference (
0752 ACPI_OPERAND_OBJECT *Object)
0753 {
0754
0755 ACPI_FUNCTION_TRACE_PTR (UtAddReference, Object);
0756
0757
0758
0759
0760 if (!AcpiUtValidInternalObject (Object))
0761 {
0762 return_VOID;
0763 }
0764
0765 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0766 "Obj %p Current Refs=%X [To Be Incremented]\n",
0767 Object, Object->Common.ReferenceCount));
0768
0769
0770
0771 (void) AcpiUtUpdateObjectReference (Object, REF_INCREMENT);
0772 return_VOID;
0773 }
0774
0775
0776
0777
0778
0779
0780
0781
0782
0783
0784
0785
0786
0787
0788 void
0789 AcpiUtRemoveReference (
0790 ACPI_OPERAND_OBJECT *Object)
0791 {
0792
0793 ACPI_FUNCTION_TRACE_PTR (UtRemoveReference, Object);
0794
0795
0796
0797
0798
0799
0800
0801 if (!Object ||
0802 (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED))
0803
0804 {
0805 return_VOID;
0806 }
0807
0808
0809
0810 if (!AcpiUtValidInternalObject (Object))
0811 {
0812 return_VOID;
0813 }
0814
0815 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
0816 "Obj %p Current Refs=%X [To Be Decremented]\n",
0817 Object, Object->Common.ReferenceCount));
0818
0819
0820
0821
0822
0823
0824 (void) AcpiUtUpdateObjectReference (Object, REF_DECREMENT);
0825 return_VOID;
0826 }
0827
0828