drivers/bus/acpi/acpica/utilities/utdelete.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: utdelete - object deletion and reference count utilities
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2018, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include "acpi.h"
  45 #include "accommon.h"
  46 #include "acinterp.h"
  47 #include "acnamesp.h"
  48 #include "acevents.h"
  49
  50
  51 #define _COMPONENT          ACPI_UTILITIES
  52         ACPI_MODULE_NAME    ("utdelete")
  53
  54 /* Local prototypes */
  55
  56 static void
  57 AcpiUtDeleteInternalObj (
  58     ACPI_OPERAND_OBJECT     *Object);
  59
  60 static void
  61 AcpiUtUpdateRefCount (
  62     ACPI_OPERAND_OBJECT     *Object,
  63     UINT32                  Action);
  64
  65
  66 /*******************************************************************************
  67  *
  68  * FUNCTION:    AcpiUtDeleteInternalObj
  69  *
  70  * PARAMETERS:  Object         - Object to be deleted
  71  *
  72  * RETURN:      None
  73  *
  74  * DESCRIPTION: Low level object deletion, after reference counts have been
  75  *              updated (All reference counts, including sub-objects!)
  76  *
  77  ******************************************************************************/
  78
  79 static void
  80 AcpiUtDeleteInternalObj (
  81     ACPI_OPERAND_OBJECT     *Object)
  82 {
  83     void                    *ObjPointer = NULL;
  84     ACPI_OPERAND_OBJECT     *HandlerDesc;
  85     ACPI_OPERAND_OBJECT     *SecondDesc;
  86     ACPI_OPERAND_OBJECT     *NextDesc;
  87     ACPI_OPERAND_OBJECT     *StartDesc;
  88     ACPI_OPERAND_OBJECT     **LastObjPtr;
  89
  90
  91     ACPI_FUNCTION_TRACE_PTR (UtDeleteInternalObj, Object);
  92
  93
  94     if (!Object)
  95     {
  96         return_VOID;
  97     }
  98
  99     /*
 100      * Must delete or free any pointers within the object that are not
 101      * actual ACPI objects (for example, a raw buffer pointer).
 102      */
 103     switch (Object->Common.Type)
 104     {
 105     case ACPI_TYPE_STRING:
 106
 107         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** String %p, ptr %p\n",
 108             Object, Object->String.Pointer));
 109
 110         /* Free the actual string buffer */
 111
 112         if (!(Object->Common.Flags & AOPOBJ_STATIC_POINTER))
 113         {
 114             /* But only if it is NOT a pointer into an ACPI table */
 115
 116             ObjPointer = Object->String.Pointer;
 117         }
 118         break;
 119
 120     case ACPI_TYPE_BUFFER:
 121
 122         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** Buffer %p, ptr %p\n",
 123             Object, Object->Buffer.Pointer));
 124
 125         /* Free the actual buffer */
 126
 127         if (!(Object->Common.Flags & AOPOBJ_STATIC_POINTER))
 128         {
 129             /* But only if it is NOT a pointer into an ACPI table */
 130
 131             ObjPointer = Object->Buffer.Pointer;
 132         }
 133         break;
 134
 135     case ACPI_TYPE_PACKAGE:
 136
 137         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, " **** Package of count %X\n",
 138             Object->Package.Count));
 139
 140         /*
 141          * Elements of the package are not handled here, they are deleted
 142          * separately
 143          */
 144
 145         /* Free the (variable length) element pointer array */
 146
 147         ObjPointer = Object->Package.Elements;
 148         break;
 149
 150     /*
 151      * These objects have a possible list of notify handlers.
 152      * Device object also may have a GPE block.
 153      */
 154     case ACPI_TYPE_DEVICE:
 155
 156         if (Object->Device.GpeBlock)
 157         {
 158             (void) AcpiEvDeleteGpeBlock (Object->Device.GpeBlock);
 159         }
 160
 161         /*lint -fallthrough */
 162
 163     case ACPI_TYPE_PROCESSOR:
 164     case ACPI_TYPE_THERMAL:
 165
 166         /* Walk the address handler list for this object */
 167
 168         HandlerDesc = Object->CommonNotify.Handler;
 169         while (HandlerDesc)
 170         {
 171             NextDesc = HandlerDesc->AddressSpace.Next;
 172             AcpiUtRemoveReference (HandlerDesc);
 173             HandlerDesc = NextDesc;
 174         }
 175         break;
 176
 177     case ACPI_TYPE_MUTEX:
 178
 179         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 180             "***** Mutex %p, OS Mutex %p\n",
 181             Object, Object->Mutex.OsMutex));
 182
 183         if (Object == AcpiGbl_GlobalLockMutex)
 184         {
 185             /* Global Lock has extra semaphore */
 186
 187             (void) AcpiOsDeleteSemaphore (AcpiGbl_GlobalLockSemaphore);
 188             AcpiGbl_GlobalLockSemaphore = NULL;
 189
 190             AcpiOsDeleteMutex (Object->Mutex.OsMutex);
 191             AcpiGbl_GlobalLockMutex = NULL;
 192         }
 193         else
 194         {
 195             AcpiExUnlinkMutex (Object);
 196             AcpiOsDeleteMutex (Object->Mutex.OsMutex);
 197         }
 198         break;
 199
 200     case ACPI_TYPE_EVENT:
 201
 202         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 203             "***** Event %p, OS Semaphore %p\n",
 204             Object, Object->Event.OsSemaphore));
 205
 206         (void) AcpiOsDeleteSemaphore (Object->Event.OsSemaphore);
 207         Object->Event.OsSemaphore = NULL;
 208         break;
 209
 210     case ACPI_TYPE_METHOD:
 211
 212         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 213             "***** Method %p\n", Object));
 214
 215         /* Delete the method mutex if it exists */
 216
 217         if (Object->Method.Mutex)
 218         {
 219             AcpiOsDeleteMutex (Object->Method.Mutex->Mutex.OsMutex);
 220             AcpiUtDeleteObjectDesc (Object->Method.Mutex);
 221             Object->Method.Mutex = NULL;
 222         }
 223
 224         if (Object->Method.Node)
 225         {
 226             Object->Method.Node = NULL;
 227         }
 228         break;
 229
 230     case ACPI_TYPE_REGION:
 231
 232         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 233             "***** Region %p\n", Object));
 234
 235         /*
 236          * Update AddressRange list. However, only permanent regions
 237          * are installed in this list. (Not created within a method)
 238          */
 239         if (!(Object->Region.Node->Flags & ANOBJ_TEMPORARY))
 240         {
 241             AcpiUtRemoveAddressRange (Object->Region.SpaceId,
 242                 Object->Region.Node);
 243         }
 244
 245         SecondDesc = AcpiNsGetSecondaryObject (Object);
 246         if (SecondDesc)
 247         {
 248             /*
 249              * Free the RegionContext if and only if the handler is one of the
 250              * default handlers -- and therefore, we created the context object
 251              * locally, it was not created by an external caller.
 252              */
 253             HandlerDesc = Object->Region.Handler;
 254             if (HandlerDesc)
 255             {
 256                 NextDesc = HandlerDesc->AddressSpace.RegionList;
 257                 StartDesc = NextDesc;
 258                 LastObjPtr = &HandlerDesc->AddressSpace.RegionList;
 259
 260                 /* Remove the region object from the handler list */
 261
 262                 while (NextDesc)
 263                 {
 264                     if (NextDesc == Object)
 265                     {
 266                         *LastObjPtr = NextDesc->Region.Next;
 267                         break;
 268                     }
 269
 270                     /* Walk the linked list of handlers */
 271
 272                     LastObjPtr = &NextDesc->Region.Next;
 273                     NextDesc = NextDesc->Region.Next;
 274
 275                     /* Prevent infinite loop if list is corrupted */
 276
 277                     if (NextDesc == StartDesc)
 278                     {
 279                         ACPI_ERROR ((AE_INFO,
 280                             "Circular region list in address handler object %p",
 281                             HandlerDesc));
 282                         return_VOID;
 283                     }
 284                 }
 285
 286                 if (HandlerDesc->AddressSpace.HandlerFlags &
 287                     ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
 288                 {
 289                     /* Deactivate region and free region context */
 290
 291                     if (HandlerDesc->AddressSpace.Setup)
 292                     {
 293                         (void) HandlerDesc->AddressSpace.Setup (Object,
 294                             ACPI_REGION_DEACTIVATE,
 295                             HandlerDesc->AddressSpace.Context,
 296                             &SecondDesc->Extra.RegionContext);
 297                     }
 298                 }
 299
 300                 AcpiUtRemoveReference (HandlerDesc);
 301             }
 302
 303             /* Now we can free the Extra object */
 304
 305             AcpiUtDeleteObjectDesc (SecondDesc);
 306         }
 307         break;
 308
 309     case ACPI_TYPE_BUFFER_FIELD:
 310
 311         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 312             "***** Buffer Field %p\n", Object));
 313
 314         SecondDesc = AcpiNsGetSecondaryObject (Object);
 315         if (SecondDesc)
 316         {
 317             AcpiUtDeleteObjectDesc (SecondDesc);
 318         }
 319         break;
 320
 321     case ACPI_TYPE_LOCAL_BANK_FIELD:
 322
 323         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 324             "***** Bank Field %p\n", Object));
 325
 326         SecondDesc = AcpiNsGetSecondaryObject (Object);
 327         if (SecondDesc)
 328         {
 329             AcpiUtDeleteObjectDesc (SecondDesc);
 330         }
 331         break;
 332
 333     default:
 334
 335         break;
 336     }
 337
 338     /* Free any allocated memory (pointer within the object) found above */
 339
 340     if (ObjPointer)
 341     {
 342         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object Subptr %p\n",
 343             ObjPointer));
 344         ACPI_FREE (ObjPointer);
 345     }
 346
 347     /* Now the object can be safely deleted */
 348
 349     ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
 350         Object, AcpiUtGetObjectTypeName (Object)));
 351
 352     AcpiUtDeleteObjectDesc (Object);
 353     return_VOID;
 354 }
 355
 356
 357 /*******************************************************************************
 358  *
 359  * FUNCTION:    AcpiUtDeleteInternalObjectList
 360  *
 361  * PARAMETERS:  ObjList         - Pointer to the list to be deleted
 362  *
 363  * RETURN:      None
 364  *
 365  * DESCRIPTION: This function deletes an internal object list, including both
 366  *              simple objects and package objects
 367  *
 368  ******************************************************************************/
 369
 370 void
 371 AcpiUtDeleteInternalObjectList (
 372     ACPI_OPERAND_OBJECT     **ObjList)
 373 {
 374     ACPI_OPERAND_OBJECT     **InternalObj;
 375
 376
 377     ACPI_FUNCTION_ENTRY ();
 378
 379
 380     /* Walk the null-terminated internal list */
 381
 382     for (InternalObj = ObjList; *InternalObj; InternalObj++)
 383     {
 384         AcpiUtRemoveReference (*InternalObj);
 385     }
 386
 387     /* Free the combined parameter pointer list and object array */
 388
 389     ACPI_FREE (ObjList);
 390     return;
 391 }
 392
 393
 394 /*******************************************************************************
 395  *
 396  * FUNCTION:    AcpiUtUpdateRefCount
 397  *
 398  * PARAMETERS:  Object          - Object whose ref count is to be updated
 399  *              Action          - What to do (REF_INCREMENT or REF_DECREMENT)
 400  *
 401  * RETURN:      None. Sets new reference count within the object
 402  *
 403  * DESCRIPTION: Modify the reference count for an internal acpi object
 404  *
 405  ******************************************************************************/
 406
 407 static void
 408 AcpiUtUpdateRefCount (
 409     ACPI_OPERAND_OBJECT     *Object,
 410     UINT32                  Action)
 411 {
 412     UINT16                  OriginalCount;
 413     UINT16                  NewCount = 0;
 414     ACPI_CPU_FLAGS          LockFlags;
 415
 416
 417     ACPI_FUNCTION_NAME (UtUpdateRefCount);
 418
 419
 420     if (!Object)
 421     {
 422         return;
 423     }
 424
 425     /*
 426      * Always get the reference count lock. Note: Interpreter and/or
 427      * Namespace is not always locked when this function is called.
 428      */
 429     LockFlags = AcpiOsAcquireLock (AcpiGbl_ReferenceCountLock);
 430     OriginalCount = Object->Common.ReferenceCount;
 431
 432     /* Perform the reference count action (increment, decrement) */
 433
 434     switch (Action)
 435     {
 436     case REF_INCREMENT:
 437
 438         NewCount = OriginalCount + 1;
 439         Object->Common.ReferenceCount = NewCount;
 440         AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
 441
 442         /* The current reference count should never be zero here */
 443
 444         if (!OriginalCount)
 445         {
 446             ACPI_WARNING ((AE_INFO,
 447                 "Obj %p, Reference Count was zero before increment\n",
 448                 Object));
 449         }
 450
 451         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 452             "Obj %p Type %.2X [%s] Refs %.2X [Incremented]\n",
 453             Object, Object->Common.Type,
 454             AcpiUtGetObjectTypeName (Object), NewCount));
 455         break;
 456
 457     case REF_DECREMENT:
 458
 459         /* The current reference count must be non-zero */
 460
 461         if (OriginalCount)
 462         {
 463             NewCount = OriginalCount - 1;
 464             Object->Common.ReferenceCount = NewCount;
 465         }
 466
 467         AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
 468
 469         if (!OriginalCount)
 470         {
 471             ACPI_WARNING ((AE_INFO,
 472                 "Obj %p, Reference Count is already zero, cannot decrement\n",
 473                 Object));
 474         }
 475
 476         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 477             "Obj %p Type %.2X Refs %.2X [Decremented]\n",
 478             Object, Object->Common.Type, NewCount));
 479
 480         /* Actually delete the object on a reference count of zero */
 481
 482         if (NewCount == 0)
 483         {
 484             AcpiUtDeleteInternalObj (Object);
 485         }
 486         break;
 487
 488     default:
 489
 490         AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
 491         ACPI_ERROR ((AE_INFO, "Unknown Reference Count action (0x%X)",
 492             Action));
 493         return;
 494     }
 495
 496     /*
 497      * Sanity check the reference count, for debug purposes only.
 498      * (A deleted object will have a huge reference count)
 499      */
 500     if (NewCount > ACPI_MAX_REFERENCE_COUNT)
 501     {
 502         ACPI_WARNING ((AE_INFO,
 503             "Large Reference Count (0x%X) in object %p, Type=0x%.2X",
 504             NewCount, Object, Object->Common.Type));
 505     }
 506 }
 507
 508
 509 /*******************************************************************************
 510  *
 511  * FUNCTION:    AcpiUtUpdateObjectReference
 512  *
 513  * PARAMETERS:  Object              - Increment ref count for this object
 514  *                                    and all sub-objects
 515  *              Action              - Either REF_INCREMENT or REF_DECREMENT
 516  *
 517  * RETURN:      Status
 518  *
 519  * DESCRIPTION: Increment the object reference count
 520  *
 521  * Object references are incremented when:
 522  * 1) An object is attached to a Node (namespace object)
 523  * 2) An object is copied (all subobjects must be incremented)
 524  *
 525  * Object references are decremented when:
 526  * 1) An object is detached from an Node
 527  *
 528  ******************************************************************************/
 529
 530 ACPI_STATUS
 531 AcpiUtUpdateObjectReference (
 532     ACPI_OPERAND_OBJECT     *Object,
 533     UINT16                  Action)
 534 {
 535     ACPI_STATUS             Status = AE_OK;
 536     ACPI_GENERIC_STATE      *StateList = NULL;
 537     ACPI_OPERAND_OBJECT     *NextObject = NULL;
 538     ACPI_OPERAND_OBJECT     *PrevObject;
 539     ACPI_GENERIC_STATE      *State;
 540     UINT32                  i;
 541
 542
 543     ACPI_FUNCTION_NAME (UtUpdateObjectReference);
 544
 545
 546     while (Object)
 547     {
 548         /* Make sure that this isn't a namespace handle */
 549
 550         if (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED)
 551         {
 552             ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 553                 "Object %p is NS handle\n", Object));
 554             return (AE_OK);
 555         }
 556
 557         /*
 558          * All sub-objects must have their reference count incremented
 559          * also. Different object types have different subobjects.
 560          */
 561         switch (Object->Common.Type)
 562         {
 563         case ACPI_TYPE_DEVICE:
 564         case ACPI_TYPE_PROCESSOR:
 565         case ACPI_TYPE_POWER:
 566         case ACPI_TYPE_THERMAL:
 567             /*
 568              * Update the notify objects for these types (if present)
 569              * Two lists, system and device notify handlers.
 570              */
 571             for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
 572             {
 573                 PrevObject = Object->CommonNotify.NotifyList[i];
 574                 while (PrevObject)
 575                 {
 576                     NextObject = PrevObject->Notify.Next[i];
 577                     AcpiUtUpdateRefCount (PrevObject, Action);
 578                     PrevObject = NextObject;
 579                 }
 580             }
 581             break;
 582
 583         case ACPI_TYPE_PACKAGE:
 584             /*
 585              * We must update all the sub-objects of the package,
 586              * each of whom may have their own sub-objects.
 587              */
 588             for (i = 0; i < Object->Package.Count; i++)
 589             {
 590                 /*
 591                  * Null package elements are legal and can be simply
 592                  * ignored.
 593                  */
 594                 NextObject = Object->Package.Elements[i];
 595                 if (!NextObject)
 596                 {
 597                     continue;
 598                 }
 599
 600                 switch (NextObject->Common.Type)
 601                 {
 602                 case ACPI_TYPE_INTEGER:
 603                 case ACPI_TYPE_STRING:
 604                 case ACPI_TYPE_BUFFER:
 605                     /*
 606                      * For these very simple sub-objects, we can just
 607                      * update the reference count here and continue.
 608                      * Greatly increases performance of this operation.
 609                      */
 610                     AcpiUtUpdateRefCount (NextObject, Action);
 611                     break;
 612
 613                 default:
 614                     /*
 615                      * For complex sub-objects, push them onto the stack
 616                      * for later processing (this eliminates recursion.)
 617                      */
 618                     Status = AcpiUtCreateUpdateStateAndPush (
 619                         NextObject, Action, &StateList);
 620                     if (ACPI_FAILURE (Status))
 621                     {
 622                         goto ErrorExit;
 623                     }
 624                     break;
 625                 }
 626             }
 627             NextObject = NULL;
 628             break;
 629
 630         case ACPI_TYPE_BUFFER_FIELD:
 631
 632             NextObject = Object->BufferField.BufferObj;
 633             break;
 634
 635         case ACPI_TYPE_LOCAL_REGION_FIELD:
 636
 637             NextObject = Object->Field.RegionObj;
 638             break;
 639
 640         case ACPI_TYPE_LOCAL_BANK_FIELD:
 641
 642             NextObject = Object->BankField.BankObj;
 643             Status = AcpiUtCreateUpdateStateAndPush (
 644                 Object->BankField.RegionObj, Action, &StateList);
 645             if (ACPI_FAILURE (Status))
 646             {
 647                 goto ErrorExit;
 648             }
 649             break;
 650
 651         case ACPI_TYPE_LOCAL_INDEX_FIELD:
 652
 653             NextObject = Object->IndexField.IndexObj;
 654             Status = AcpiUtCreateUpdateStateAndPush (
 655                 Object->IndexField.DataObj, Action, &StateList);
 656             if (ACPI_FAILURE (Status))
 657             {
 658                 goto ErrorExit;
 659             }
 660             break;
 661
 662         case ACPI_TYPE_LOCAL_REFERENCE:
 663             /*
 664              * The target of an Index (a package, string, or buffer) or a named
 665              * reference must track changes to the ref count of the index or
 666              * target object.
 667              */
 668             if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
 669                 (Object->Reference.Class== ACPI_REFCLASS_NAME))
 670             {
 671                 NextObject = Object->Reference.Object;
 672             }
 673             break;
 674
 675         case ACPI_TYPE_REGION:
 676         default:
 677
 678             break; /* No subobjects for all other types */
 679         }
 680
 681         /*
 682          * Now we can update the count in the main object. This can only
 683          * happen after we update the sub-objects in case this causes the
 684          * main object to be deleted.
 685          */
 686         AcpiUtUpdateRefCount (Object, Action);
 687         Object = NULL;
 688
 689         /* Move on to the next object to be updated */
 690
 691         if (NextObject)
 692         {
 693             Object = NextObject;
 694             NextObject = NULL;
 695         }
 696         else if (StateList)
 697         {
 698             State = AcpiUtPopGenericState (&StateList);
 699             Object = State->Update.Object;
 700             AcpiUtDeleteGenericState (State);
 701         }
 702     }
 703
 704     return (AE_OK);
 705
 706
 707 ErrorExit:
 708
 709     ACPI_EXCEPTION ((AE_INFO, Status,
 710         "Could not update object reference count"));
 711
 712     /* Free any stacked Update State objects */
 713
 714     while (StateList)
 715     {
 716         State = AcpiUtPopGenericState (&StateList);
 717         AcpiUtDeleteGenericState (State);
 718     }
 719
 720     return (Status);
 721 }
 722
 723
 724 /*******************************************************************************
 725  *
 726  * FUNCTION:    AcpiUtAddReference
 727  *
 728  * PARAMETERS:  Object          - Object whose reference count is to be
 729  *                                incremented
 730  *
 731  * RETURN:      None
 732  *
 733  * DESCRIPTION: Add one reference to an ACPI object
 734  *
 735  ******************************************************************************/
 736
 737 void
 738 AcpiUtAddReference (
 739     ACPI_OPERAND_OBJECT     *Object)
 740 {
 741
 742     ACPI_FUNCTION_NAME (UtAddReference);
 743
 744
 745     /* Ensure that we have a valid object */
 746
 747     if (!AcpiUtValidInternalObject (Object))
 748     {
 749         return;
 750     }
 751
 752     ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 753         "Obj %p Current Refs=%X [To Be Incremented]\n",
 754         Object, Object->Common.ReferenceCount));
 755
 756     /* Increment the reference count */
 757
 758     (void) AcpiUtUpdateObjectReference (Object, REF_INCREMENT);
 759     return;
 760 }
 761
 762
 763 /*******************************************************************************
 764  *
 765  * FUNCTION:    AcpiUtRemoveReference
 766  *
 767  * PARAMETERS:  Object         - Object whose ref count will be decremented
 768  *
 769  * RETURN:      None
 770  *
 771  * DESCRIPTION: Decrement the reference count of an ACPI internal object
 772  *
 773  ******************************************************************************/
 774
 775 void
 776 AcpiUtRemoveReference (
 777     ACPI_OPERAND_OBJECT     *Object)
 778 {
 779
 780     ACPI_FUNCTION_NAME (UtRemoveReference);
 781
 782
 783     /*
 784      * Allow a NULL pointer to be passed in, just ignore it. This saves
 785      * each caller from having to check. Also, ignore NS nodes.
 786      */
 787     if (!Object ||
 788         (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED))
 789
 790     {
 791         return;
 792     }
 793
 794     /* Ensure that we have a valid object */
 795
 796     if (!AcpiUtValidInternalObject (Object))
 797     {
 798         return;
 799     }
 800
 801     ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 802         "Obj %p Current Refs=%X [To Be Decremented]\n",
 803         Object, Object->Common.ReferenceCount));
 804
 805     /*
 806      * Decrement the reference count, and only actually delete the object
 807      * if the reference count becomes 0. (Must also decrement the ref count
 808      * of all subobjects!)
 809      */
 810     (void) AcpiUtUpdateObjectReference (Object, REF_DECREMENT);
 811     return;
 812 }