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 - 2019, 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         if (Object->Field.InternalPccBuffer)
 308         {
 309             ACPI_FREE(Object->Field.InternalPccBuffer);
 310         }
 311
 312         break;
 313
 314     case ACPI_TYPE_BUFFER_FIELD:
 315
 316         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 317             "***** Buffer Field %p\n", Object));
 318
 319         SecondDesc = AcpiNsGetSecondaryObject (Object);
 320         if (SecondDesc)
 321         {
 322             AcpiUtDeleteObjectDesc (SecondDesc);
 323         }
 324         break;
 325
 326     case ACPI_TYPE_LOCAL_BANK_FIELD:
 327
 328         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 329             "***** Bank Field %p\n", Object));
 330
 331         SecondDesc = AcpiNsGetSecondaryObject (Object);
 332         if (SecondDesc)
 333         {
 334             AcpiUtDeleteObjectDesc (SecondDesc);
 335         }
 336         break;
 337
 338     default:
 339
 340         break;
 341     }
 342
 343     /* Free any allocated memory (pointer within the object) found above */
 344
 345     if (ObjPointer)
 346     {
 347         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object Subptr %p\n",
 348             ObjPointer));
 349         ACPI_FREE (ObjPointer);
 350     }
 351
 352     /* Now the object can be safely deleted */
 353
 354     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, "%s: Deleting Object %p [%s]\n",
 355         ACPI_GET_FUNCTION_NAME, Object, AcpiUtGetObjectTypeName (Object)));
 356
 357     AcpiUtDeleteObjectDesc (Object);
 358     return_VOID;
 359 }
 360
 361
 362 /*******************************************************************************
 363  *
 364  * FUNCTION:    AcpiUtDeleteInternalObjectList
 365  *
 366  * PARAMETERS:  ObjList         - Pointer to the list to be deleted
 367  *
 368  * RETURN:      None
 369  *
 370  * DESCRIPTION: This function deletes an internal object list, including both
 371  *              simple objects and package objects
 372  *
 373  ******************************************************************************/
 374
 375 void
 376 AcpiUtDeleteInternalObjectList (
 377     ACPI_OPERAND_OBJECT     **ObjList)
 378 {
 379     ACPI_OPERAND_OBJECT     **InternalObj;
 380
 381
 382     ACPI_FUNCTION_ENTRY ();
 383
 384
 385     /* Walk the null-terminated internal list */
 386
 387     for (InternalObj = ObjList; *InternalObj; InternalObj++)
 388     {
 389         AcpiUtRemoveReference (*InternalObj);
 390     }
 391
 392     /* Free the combined parameter pointer list and object array */
 393
 394     ACPI_FREE (ObjList);
 395     return;
 396 }
 397
 398
 399 /*******************************************************************************
 400  *
 401  * FUNCTION:    AcpiUtUpdateRefCount
 402  *
 403  * PARAMETERS:  Object          - Object whose ref count is to be updated
 404  *              Action          - What to do (REF_INCREMENT or REF_DECREMENT)
 405  *
 406  * RETURN:      None. Sets new reference count within the object
 407  *
 408  * DESCRIPTION: Modify the reference count for an internal acpi object
 409  *
 410  ******************************************************************************/
 411
 412 static void
 413 AcpiUtUpdateRefCount (
 414     ACPI_OPERAND_OBJECT     *Object,
 415     UINT32                  Action)
 416 {
 417     UINT16                  OriginalCount;
 418     UINT16                  NewCount = 0;
 419     ACPI_CPU_FLAGS          LockFlags;
 420     char                    *Message;
 421
 422
 423     ACPI_FUNCTION_NAME (UtUpdateRefCount);
 424
 425
 426     if (!Object)
 427     {
 428         return;
 429     }
 430
 431     /*
 432      * Always get the reference count lock. Note: Interpreter and/or
 433      * Namespace is not always locked when this function is called.
 434      */
 435     LockFlags = AcpiOsAcquireLock (AcpiGbl_ReferenceCountLock);
 436     OriginalCount = Object->Common.ReferenceCount;
 437
 438     /* Perform the reference count action (increment, decrement) */
 439
 440     switch (Action)
 441     {
 442     case REF_INCREMENT:
 443
 444         NewCount = OriginalCount + 1;
 445         Object->Common.ReferenceCount = NewCount;
 446         AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
 447
 448         /* The current reference count should never be zero here */
 449
 450         if (!OriginalCount)
 451         {
 452             ACPI_WARNING ((AE_INFO,
 453                 "Obj %p, Reference Count was zero before increment\n",
 454                 Object));
 455         }
 456
 457         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 458             "Obj %p Type %.2X [%s] Refs %.2X [Incremented]\n",
 459             Object, Object->Common.Type,
 460             AcpiUtGetObjectTypeName (Object), NewCount));
 461         Message = "Incremement";
 462         break;
 463
 464     case REF_DECREMENT:
 465
 466         /* The current reference count must be non-zero */
 467
 468         if (OriginalCount)
 469         {
 470             NewCount = OriginalCount - 1;
 471             Object->Common.ReferenceCount = NewCount;
 472         }
 473
 474         AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
 475
 476         if (!OriginalCount)
 477         {
 478             ACPI_WARNING ((AE_INFO,
 479                 "Obj %p, Reference Count is already zero, cannot decrement\n",
 480                 Object));
 481         }
 482
 483         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS,
 484             "%s: Obj %p Type %.2X Refs %.2X [Decremented]\n",
 485             ACPI_GET_FUNCTION_NAME, Object, Object->Common.Type, NewCount));
 486
 487         /* Actually delete the object on a reference count of zero */
 488
 489         if (NewCount == 0)
 490         {
 491             AcpiUtDeleteInternalObj (Object);
 492         }
 493         Message = "Decrement";
 494         break;
 495
 496     default:
 497
 498         AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
 499         ACPI_ERROR ((AE_INFO, "Unknown Reference Count action (0x%X)",
 500             Action));
 501         return;
 502     }
 503
 504     /*
 505      * Sanity check the reference count, for debug purposes only.
 506      * (A deleted object will have a huge reference count)
 507      */
 508     if (NewCount > ACPI_MAX_REFERENCE_COUNT)
 509     {
 510         ACPI_WARNING ((AE_INFO,
 511             "Large Reference Count (0x%X) in object %p, Type=0x%.2X Operation=%s",
 512             NewCount, Object, Object->Common.Type, Message));
 513     }
 514 }
 515
 516
 517 /*******************************************************************************
 518  *
 519  * FUNCTION:    AcpiUtUpdateObjectReference
 520  *
 521  * PARAMETERS:  Object              - Increment ref count for this object
 522  *                                    and all sub-objects
 523  *              Action              - Either REF_INCREMENT or REF_DECREMENT
 524  *
 525  * RETURN:      Status
 526  *
 527  * DESCRIPTION: Increment the object reference count
 528  *
 529  * Object references are incremented when:
 530  * 1) An object is attached to a Node (namespace object)
 531  * 2) An object is copied (all subobjects must be incremented)
 532  *
 533  * Object references are decremented when:
 534  * 1) An object is detached from an Node
 535  *
 536  ******************************************************************************/
 537
 538 ACPI_STATUS
 539 AcpiUtUpdateObjectReference (
 540     ACPI_OPERAND_OBJECT     *Object,
 541     UINT16                  Action)
 542 {
 543     ACPI_STATUS             Status = AE_OK;
 544     ACPI_GENERIC_STATE      *StateList = NULL;
 545     ACPI_OPERAND_OBJECT     *NextObject = NULL;
 546     ACPI_OPERAND_OBJECT     *PrevObject;
 547     ACPI_GENERIC_STATE      *State;
 548     UINT32                  i;
 549
 550
 551     ACPI_FUNCTION_NAME (UtUpdateObjectReference);
 552
 553
 554     while (Object)
 555     {
 556         /* Make sure that this isn't a namespace handle */
 557
 558         if (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED)
 559         {
 560             ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 561                 "Object %p is NS handle\n", Object));
 562             return (AE_OK);
 563         }
 564
 565         /*
 566          * All sub-objects must have their reference count incremented
 567          * also. Different object types have different subobjects.
 568          */
 569         switch (Object->Common.Type)
 570         {
 571         case ACPI_TYPE_DEVICE:
 572         case ACPI_TYPE_PROCESSOR:
 573         case ACPI_TYPE_POWER:
 574         case ACPI_TYPE_THERMAL:
 575             /*
 576              * Update the notify objects for these types (if present)
 577              * Two lists, system and device notify handlers.
 578              */
 579             for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
 580             {
 581                 PrevObject = Object->CommonNotify.NotifyList[i];
 582                 while (PrevObject)
 583                 {
 584                     NextObject = PrevObject->Notify.Next[i];
 585                     AcpiUtUpdateRefCount (PrevObject, Action);
 586                     PrevObject = NextObject;
 587                 }
 588             }
 589             break;
 590
 591         case ACPI_TYPE_PACKAGE:
 592             /*
 593              * We must update all the sub-objects of the package,
 594              * each of whom may have their own sub-objects.
 595              */
 596             for (i = 0; i < Object->Package.Count; i++)
 597             {
 598                 /*
 599                  * Null package elements are legal and can be simply
 600                  * ignored.
 601                  */
 602                 NextObject = Object->Package.Elements[i];
 603                 if (!NextObject)
 604                 {
 605                     continue;
 606                 }
 607
 608                 switch (NextObject->Common.Type)
 609                 {
 610                 case ACPI_TYPE_INTEGER:
 611                 case ACPI_TYPE_STRING:
 612                 case ACPI_TYPE_BUFFER:
 613                     /*
 614                      * For these very simple sub-objects, we can just
 615                      * update the reference count here and continue.
 616                      * Greatly increases performance of this operation.
 617                      */
 618                     AcpiUtUpdateRefCount (NextObject, Action);
 619                     break;
 620
 621                 default:
 622                     /*
 623                      * For complex sub-objects, push them onto the stack
 624                      * for later processing (this eliminates recursion.)
 625                      */
 626                     Status = AcpiUtCreateUpdateStateAndPush (
 627                         NextObject, Action, &StateList);
 628                     if (ACPI_FAILURE (Status))
 629                     {
 630                         goto ErrorExit;
 631                     }
 632                     break;
 633                 }
 634             }
 635             NextObject = NULL;
 636             break;
 637
 638         case ACPI_TYPE_BUFFER_FIELD:
 639
 640             NextObject = Object->BufferField.BufferObj;
 641             break;
 642
 643         case ACPI_TYPE_LOCAL_REGION_FIELD:
 644
 645             NextObject = Object->Field.RegionObj;
 646             break;
 647
 648         case ACPI_TYPE_LOCAL_BANK_FIELD:
 649
 650             NextObject = Object->BankField.BankObj;
 651             Status = AcpiUtCreateUpdateStateAndPush (
 652                 Object->BankField.RegionObj, Action, &StateList);
 653             if (ACPI_FAILURE (Status))
 654             {
 655                 goto ErrorExit;
 656             }
 657             break;
 658
 659         case ACPI_TYPE_LOCAL_INDEX_FIELD:
 660
 661             NextObject = Object->IndexField.IndexObj;
 662             Status = AcpiUtCreateUpdateStateAndPush (
 663                 Object->IndexField.DataObj, Action, &StateList);
 664             if (ACPI_FAILURE (Status))
 665             {
 666                 goto ErrorExit;
 667             }
 668             break;
 669
 670         case ACPI_TYPE_LOCAL_REFERENCE:
 671             /*
 672              * The target of an Index (a package, string, or buffer) or a named
 673              * reference must track changes to the ref count of the index or
 674              * target object.
 675              */
 676             if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
 677                 (Object->Reference.Class== ACPI_REFCLASS_NAME))
 678             {
 679                 NextObject = Object->Reference.Object;
 680             }
 681             break;
 682
 683         case ACPI_TYPE_REGION:
 684         default:
 685
 686             break; /* No subobjects for all other types */
 687         }
 688
 689         /*
 690          * Now we can update the count in the main object. This can only
 691          * happen after we update the sub-objects in case this causes the
 692          * main object to be deleted.
 693          */
 694         AcpiUtUpdateRefCount (Object, Action);
 695         Object = NULL;
 696
 697         /* Move on to the next object to be updated */
 698
 699         if (NextObject)
 700         {
 701             Object = NextObject;
 702             NextObject = NULL;
 703         }
 704         else if (StateList)
 705         {
 706             State = AcpiUtPopGenericState (&StateList);
 707             Object = State->Update.Object;
 708             AcpiUtDeleteGenericState (State);
 709         }
 710     }
 711
 712     return (AE_OK);
 713
 714
 715 ErrorExit:
 716
 717     ACPI_EXCEPTION ((AE_INFO, Status,
 718         "Could not update object reference count"));
 719
 720     /* Free any stacked Update State objects */
 721
 722     while (StateList)
 723     {
 724         State = AcpiUtPopGenericState (&StateList);
 725         AcpiUtDeleteGenericState (State);
 726     }
 727
 728     return (Status);
 729 }
 730
 731
 732 /*******************************************************************************
 733  *
 734  * FUNCTION:    AcpiUtAddReference
 735  *
 736  * PARAMETERS:  Object          - Object whose reference count is to be
 737  *                                incremented
 738  *
 739  * RETURN:      None
 740  *
 741  * DESCRIPTION: Add one reference to an ACPI object
 742  *
 743  ******************************************************************************/
 744
 745 void
 746 AcpiUtAddReference (
 747     ACPI_OPERAND_OBJECT     *Object)
 748 {
 749
 750     ACPI_FUNCTION_NAME (UtAddReference);
 751
 752
 753     /* Ensure that we have a valid object */
 754
 755     if (!AcpiUtValidInternalObject (Object))
 756     {
 757         return;
 758     }
 759
 760     ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 761         "Obj %p Current Refs=%X [To Be Incremented]\n",
 762         Object, Object->Common.ReferenceCount));
 763
 764     /* Increment the reference count */
 765
 766     (void) AcpiUtUpdateObjectReference (Object, REF_INCREMENT);
 767     return;
 768 }
 769
 770
 771 /*******************************************************************************
 772  *
 773  * FUNCTION:    AcpiUtRemoveReference
 774  *
 775  * PARAMETERS:  Object         - Object whose ref count will be decremented
 776  *
 777  * RETURN:      None
 778  *
 779  * DESCRIPTION: Decrement the reference count of an ACPI internal object
 780  *
 781  ******************************************************************************/
 782
 783 void
 784 AcpiUtRemoveReference (
 785     ACPI_OPERAND_OBJECT     *Object)
 786 {
 787
 788     ACPI_FUNCTION_NAME (UtRemoveReference);
 789
 790
 791     /*
 792      * Allow a NULL pointer to be passed in, just ignore it. This saves
 793      * each caller from having to check. Also, ignore NS nodes.
 794      */
 795     if (!Object ||
 796         (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED))
 797
 798     {
 799         return;
 800     }
 801
 802     /* Ensure that we have a valid object */
 803
 804     if (!AcpiUtValidInternalObject (Object))
 805     {
 806         return;
 807     }
 808
 809     ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS,
 810         "%s: Obj %p Current Refs=%X [To Be Decremented]\n",
 811         ACPI_GET_FUNCTION_NAME, Object, Object->Common.ReferenceCount));
 812
 813     /*
 814      * Decrement the reference count, and only actually delete the object
 815      * if the reference count becomes 0. (Must also decrement the ref count
 816      * of all subobjects!)
 817      */
 818     (void) AcpiUtUpdateObjectReference (Object, REF_DECREMENT);
 819     return;
 820 }