source/components/utilities/utdelete.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: utdelete - object deletion and reference count utilities
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2012, 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 #define __UTDELETE_C__
  45
  46 #include "acpi.h"
  47 #include "accommon.h"
  48 #include "acinterp.h"
  49 #include "acnamesp.h"
  50 #include "acevents.h"
  51
  52
  53 #define _COMPONENT          ACPI_UTILITIES
  54         ACPI_MODULE_NAME    ("utdelete")
  55
  56 /* Local prototypes */
  57
  58 static void
  59 AcpiUtDeleteInternalObj (
  60     ACPI_OPERAND_OBJECT     *Object);
  61
  62 static void
  63 AcpiUtUpdateRefCount (
  64     ACPI_OPERAND_OBJECT     *Object,
  65     UINT32                  Action);
  66
  67
  68 /*******************************************************************************
  69  *
  70  * FUNCTION:    AcpiUtDeleteInternalObj
  71  *
  72  * PARAMETERS:  Object         - Object to be deleted
  73  *
  74  * RETURN:      None
  75  *
  76  * DESCRIPTION: Low level object deletion, after reference counts have been
  77  *              updated (All reference counts, including sub-objects!)
  78  *
  79  ******************************************************************************/
  80
  81 static void
  82 AcpiUtDeleteInternalObj (
  83     ACPI_OPERAND_OBJECT     *Object)
  84 {
  85     void                    *ObjPointer = NULL;
  86     ACPI_OPERAND_OBJECT     *HandlerDesc;
  87     ACPI_OPERAND_OBJECT     *SecondDesc;
  88     ACPI_OPERAND_OBJECT     *NextDesc;
  89     ACPI_OPERAND_OBJECT     **LastObjPtr;
  90
  91
  92     ACPI_FUNCTION_TRACE_PTR (UtDeleteInternalObj, Object);
  93
  94
  95     if (!Object)
  96     {
  97         return_VOID;
  98     }
  99
 100     /*
 101      * Must delete or free any pointers within the object that are not
 102      * actual ACPI objects (for example, a raw buffer pointer).
 103      */
 104     switch (Object->Common.Type)
 105     {
 106     case ACPI_TYPE_STRING:
 107
 108         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** String %p, ptr %p\n",
 109             Object, Object->String.Pointer));
 110
 111         /* Free the actual string buffer */
 112
 113         if (!(Object->Common.Flags & AOPOBJ_STATIC_POINTER))
 114         {
 115             /* But only if it is NOT a pointer into an ACPI table */
 116
 117             ObjPointer = Object->String.Pointer;
 118         }
 119         break;
 120
 121
 122     case ACPI_TYPE_BUFFER:
 123
 124         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** Buffer %p, ptr %p\n",
 125             Object, Object->Buffer.Pointer));
 126
 127         /* Free the actual buffer */
 128
 129         if (!(Object->Common.Flags & AOPOBJ_STATIC_POINTER))
 130         {
 131             /* But only if it is NOT a pointer into an ACPI table */
 132
 133             ObjPointer = Object->Buffer.Pointer;
 134         }
 135         break;
 136
 137
 138     case ACPI_TYPE_PACKAGE:
 139
 140         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, " **** Package of count %X\n",
 141             Object->Package.Count));
 142
 143         /*
 144          * Elements of the package are not handled here, they are deleted
 145          * separately
 146          */
 147
 148         /* Free the (variable length) element pointer array */
 149
 150         ObjPointer = Object->Package.Elements;
 151         break;
 152
 153
 154     /*
 155      * These objects have a possible list of notify handlers.
 156      * Device object also may have a GPE block.
 157      */
 158     case ACPI_TYPE_DEVICE:
 159
 160         if (Object->Device.GpeBlock)
 161         {
 162             (void) AcpiEvDeleteGpeBlock (Object->Device.GpeBlock);
 163         }
 164
 165         /*lint -fallthrough */
 166
 167     case ACPI_TYPE_PROCESSOR:
 168     case ACPI_TYPE_THERMAL:
 169
 170         /* Walk the notify handler list for this object */
 171
 172         HandlerDesc = Object->CommonNotify.Handler;
 173         while (HandlerDesc)
 174         {
 175             NextDesc = HandlerDesc->AddressSpace.Next;
 176             AcpiUtRemoveReference (HandlerDesc);
 177             HandlerDesc = NextDesc;
 178         }
 179         break;
 180
 181
 182     case ACPI_TYPE_MUTEX:
 183
 184         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 185             "***** Mutex %p, OS Mutex %p\n",
 186             Object, Object->Mutex.OsMutex));
 187
 188         if (Object == AcpiGbl_GlobalLockMutex)
 189         {
 190             /* Global Lock has extra semaphore */
 191
 192             (void) AcpiOsDeleteSemaphore (AcpiGbl_GlobalLockSemaphore);
 193             AcpiGbl_GlobalLockSemaphore = NULL;
 194
 195             AcpiOsDeleteMutex (Object->Mutex.OsMutex);
 196             AcpiGbl_GlobalLockMutex = NULL;
 197         }
 198         else
 199         {
 200             AcpiExUnlinkMutex (Object);
 201             AcpiOsDeleteMutex (Object->Mutex.OsMutex);
 202         }
 203         break;
 204
 205
 206     case ACPI_TYPE_EVENT:
 207
 208         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 209             "***** Event %p, OS Semaphore %p\n",
 210             Object, Object->Event.OsSemaphore));
 211
 212         (void) AcpiOsDeleteSemaphore (Object->Event.OsSemaphore);
 213         Object->Event.OsSemaphore = NULL;
 214         break;
 215
 216
 217     case ACPI_TYPE_METHOD:
 218
 219         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 220             "***** Method %p\n", Object));
 221
 222         /* Delete the method mutex if it exists */
 223
 224         if (Object->Method.Mutex)
 225         {
 226             AcpiOsDeleteMutex (Object->Method.Mutex->Mutex.OsMutex);
 227             AcpiUtDeleteObjectDesc (Object->Method.Mutex);
 228             Object->Method.Mutex = NULL;
 229         }
 230         break;
 231
 232
 233     case ACPI_TYPE_REGION:
 234
 235         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 236             "***** Region %p\n", Object));
 237
 238         /*
 239          * Update AddressRange list. However, only permanent regions
 240          * are installed in this list. (Not created within a method)
 241          */
 242         if (!(Object->Region.Node->Flags & ANOBJ_TEMPORARY))
 243         {
 244             AcpiUtRemoveAddressRange (Object->Region.SpaceId,
 245                 Object->Region.Node);
 246         }
 247
 248         SecondDesc = AcpiNsGetSecondaryObject (Object);
 249         if (SecondDesc)
 250         {
 251             /*
 252              * Free the RegionContext if and only if the handler is one of the
 253              * default handlers -- and therefore, we created the context object
 254              * locally, it was not created by an external caller.
 255              */
 256             HandlerDesc = Object->Region.Handler;
 257             if (HandlerDesc)
 258             {
 259                 NextDesc = HandlerDesc->AddressSpace.RegionList;
 260                 LastObjPtr = &HandlerDesc->AddressSpace.RegionList;
 261
 262                 /* Remove the region object from the handler's list */
 263
 264                 while (NextDesc)
 265                 {
 266                     if (NextDesc == Object)
 267                     {
 268                         *LastObjPtr = NextDesc->Region.Next;
 269                         break;
 270                     }
 271
 272                     /* Walk the linked list of handler */
 273
 274                     LastObjPtr = &NextDesc->Region.Next;
 275                     NextDesc = NextDesc->Region.Next;
 276                 }
 277
 278                 if (HandlerDesc->AddressSpace.HandlerFlags &
 279                     ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
 280                 {
 281                     /* Deactivate region and free region context */
 282
 283                     if (HandlerDesc->AddressSpace.Setup)
 284                     {
 285                         (void) HandlerDesc->AddressSpace.Setup (Object,
 286                             ACPI_REGION_DEACTIVATE,
 287                             HandlerDesc->AddressSpace.Context,
 288                             &SecondDesc->Extra.RegionContext);
 289                     }
 290                 }
 291
 292                 AcpiUtRemoveReference (HandlerDesc);
 293             }
 294
 295             /* Now we can free the Extra object */
 296
 297             AcpiUtDeleteObjectDesc (SecondDesc);
 298         }
 299         break;
 300
 301
 302     case ACPI_TYPE_BUFFER_FIELD:
 303
 304         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 305             "***** Buffer Field %p\n", Object));
 306
 307         SecondDesc = AcpiNsGetSecondaryObject (Object);
 308         if (SecondDesc)
 309         {
 310             AcpiUtDeleteObjectDesc (SecondDesc);
 311         }
 312         break;
 313
 314
 315     case ACPI_TYPE_LOCAL_BANK_FIELD:
 316
 317         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 318             "***** Bank Field %p\n", Object));
 319
 320         SecondDesc = AcpiNsGetSecondaryObject (Object);
 321         if (SecondDesc)
 322         {
 323             AcpiUtDeleteObjectDesc (SecondDesc);
 324         }
 325         break;
 326
 327
 328     default:
 329         break;
 330     }
 331
 332     /* Free any allocated memory (pointer within the object) found above */
 333
 334     if (ObjPointer)
 335     {
 336         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object Subptr %p\n",
 337             ObjPointer));
 338         ACPI_FREE (ObjPointer);
 339     }
 340
 341     /* Now the object can be safely deleted */
 342
 343     ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
 344         Object, AcpiUtGetObjectTypeName (Object)));
 345
 346     AcpiUtDeleteObjectDesc (Object);
 347     return_VOID;
 348 }
 349
 350
 351 /*******************************************************************************
 352  *
 353  * FUNCTION:    AcpiUtDeleteInternalObjectList
 354  *
 355  * PARAMETERS:  ObjList         - Pointer to the list to be deleted
 356  *
 357  * RETURN:      None
 358  *
 359  * DESCRIPTION: This function deletes an internal object list, including both
 360  *              simple objects and package objects
 361  *
 362  ******************************************************************************/
 363
 364 void
 365 AcpiUtDeleteInternalObjectList (
 366     ACPI_OPERAND_OBJECT     **ObjList)
 367 {
 368     ACPI_OPERAND_OBJECT     **InternalObj;
 369
 370
 371     ACPI_FUNCTION_TRACE (UtDeleteInternalObjectList);
 372
 373
 374     /* Walk the null-terminated internal list */
 375
 376     for (InternalObj = ObjList; *InternalObj; InternalObj++)
 377     {
 378         AcpiUtRemoveReference (*InternalObj);
 379     }
 380
 381     /* Free the combined parameter pointer list and object array */
 382
 383     ACPI_FREE (ObjList);
 384     return_VOID;
 385 }
 386
 387
 388 /*******************************************************************************
 389  *
 390  * FUNCTION:    AcpiUtUpdateRefCount
 391  *
 392  * PARAMETERS:  Object          - Object whose ref count is to be updated
 393  *              Action          - What to do
 394  *
 395  * RETURN:      New ref count
 396  *
 397  * DESCRIPTION: Modify the ref count and return it.
 398  *
 399  ******************************************************************************/
 400
 401 static void
 402 AcpiUtUpdateRefCount (
 403     ACPI_OPERAND_OBJECT     *Object,
 404     UINT32                  Action)
 405 {
 406     UINT16                  Count;
 407     UINT16                  NewCount;
 408
 409
 410     ACPI_FUNCTION_NAME (UtUpdateRefCount);
 411
 412
 413     if (!Object)
 414     {
 415         return;
 416     }
 417
 418     Count = Object->Common.ReferenceCount;
 419     NewCount = Count;
 420
 421     /*
 422      * Perform the reference count action (increment, decrement, force delete)
 423      */
 424     switch (Action)
 425     {
 426     case REF_INCREMENT:
 427
 428         NewCount++;
 429         Object->Common.ReferenceCount = NewCount;
 430
 431         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 432             "Obj %p Refs=%X, [Incremented]\n",
 433             Object, NewCount));
 434         break;
 435
 436     case REF_DECREMENT:
 437
 438         if (Count < 1)
 439         {
 440             ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 441                 "Obj %p Refs=%X, can't decrement! (Set to 0)\n",
 442                 Object, NewCount));
 443
 444             NewCount = 0;
 445         }
 446         else
 447         {
 448             NewCount--;
 449
 450             ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 451                 "Obj %p Refs=%X, [Decremented]\n",
 452                 Object, NewCount));
 453         }
 454
 455         if (Object->Common.Type == ACPI_TYPE_METHOD)
 456         {
 457             ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 458                 "Method Obj %p Refs=%X, [Decremented]\n", Object, NewCount));
 459         }
 460
 461         Object->Common.ReferenceCount = NewCount;
 462         if (NewCount == 0)
 463         {
 464             AcpiUtDeleteInternalObj (Object);
 465         }
 466         break;
 467
 468     case REF_FORCE_DELETE:
 469
 470         ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 471             "Obj %p Refs=%X, Force delete! (Set to 0)\n", Object, Count));
 472
 473         NewCount = 0;
 474         Object->Common.ReferenceCount = NewCount;
 475         AcpiUtDeleteInternalObj (Object);
 476         break;
 477
 478     default:
 479
 480         ACPI_ERROR ((AE_INFO, "Unknown action (0x%X)", Action));
 481         break;
 482     }
 483
 484     /*
 485      * Sanity check the reference count, for debug purposes only.
 486      * (A deleted object will have a huge reference count)
 487      */
 488     if (Count > ACPI_MAX_REFERENCE_COUNT)
 489     {
 490         ACPI_WARNING ((AE_INFO,
 491             "Large Reference Count (0x%X) in object %p", Count, Object));
 492     }
 493 }
 494
 495
 496 /*******************************************************************************
 497  *
 498  * FUNCTION:    AcpiUtUpdateObjectReference
 499  *
 500  * PARAMETERS:  Object              - Increment ref count for this object
 501  *                                    and all sub-objects
 502  *              Action              - Either REF_INCREMENT or REF_DECREMENT or
 503  *                                    REF_FORCE_DELETE
 504  *
 505  * RETURN:      Status
 506  *
 507  * DESCRIPTION: Increment the object reference count
 508  *
 509  * Object references are incremented when:
 510  * 1) An object is attached to a Node (namespace object)
 511  * 2) An object is copied (all subobjects must be incremented)
 512  *
 513  * Object references are decremented when:
 514  * 1) An object is detached from an Node
 515  *
 516  ******************************************************************************/
 517
 518 ACPI_STATUS
 519 AcpiUtUpdateObjectReference (
 520     ACPI_OPERAND_OBJECT     *Object,
 521     UINT16                  Action)
 522 {
 523     ACPI_STATUS             Status = AE_OK;
 524     ACPI_GENERIC_STATE      *StateList = NULL;
 525     ACPI_OPERAND_OBJECT     *NextObject = NULL;
 526     ACPI_GENERIC_STATE      *State;
 527     UINT32                  i;
 528
 529
 530     ACPI_FUNCTION_TRACE_PTR (UtUpdateObjectReference, Object);
 531
 532
 533     while (Object)
 534     {
 535         /* Make sure that this isn't a namespace handle */
 536
 537         if (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED)
 538         {
 539             ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 540                 "Object %p is NS handle\n", Object));
 541             return_ACPI_STATUS (AE_OK);
 542         }
 543
 544         /*
 545          * All sub-objects must have their reference count incremented also.
 546          * Different object types have different subobjects.
 547          */
 548         switch (Object->Common.Type)
 549         {
 550         case ACPI_TYPE_DEVICE:
 551         case ACPI_TYPE_PROCESSOR:
 552         case ACPI_TYPE_POWER:
 553         case ACPI_TYPE_THERMAL:
 554
 555             /* Update the notify objects for these types (if present) */
 556
 557             AcpiUtUpdateRefCount (Object->CommonNotify.SystemNotify, Action);
 558             AcpiUtUpdateRefCount (Object->CommonNotify.DeviceNotify, Action);
 559             break;
 560
 561         case ACPI_TYPE_PACKAGE:
 562             /*
 563              * We must update all the sub-objects of the package,
 564              * each of whom may have their own sub-objects.
 565              */
 566             for (i = 0; i < Object->Package.Count; i++)
 567             {
 568                 /*
 569                  * Push each element onto the stack for later processing.
 570                  * Note: There can be null elements within the package,
 571                  * these are simply ignored
 572                  */
 573                 Status = AcpiUtCreateUpdateStateAndPush (
 574                             Object->Package.Elements[i], Action, &StateList);
 575                 if (ACPI_FAILURE (Status))
 576                 {
 577                     goto ErrorExit;
 578                 }
 579             }
 580             break;
 581
 582         case ACPI_TYPE_BUFFER_FIELD:
 583
 584             NextObject = Object->BufferField.BufferObj;
 585             break;
 586
 587         case ACPI_TYPE_LOCAL_REGION_FIELD:
 588
 589             NextObject = Object->Field.RegionObj;
 590             break;
 591
 592         case ACPI_TYPE_LOCAL_BANK_FIELD:
 593
 594             NextObject = Object->BankField.BankObj;
 595             Status = AcpiUtCreateUpdateStateAndPush (
 596                         Object->BankField.RegionObj, Action, &StateList);
 597             if (ACPI_FAILURE (Status))
 598             {
 599                 goto ErrorExit;
 600             }
 601             break;
 602
 603         case ACPI_TYPE_LOCAL_INDEX_FIELD:
 604
 605             NextObject = Object->IndexField.IndexObj;
 606             Status = AcpiUtCreateUpdateStateAndPush (
 607                         Object->IndexField.DataObj, Action, &StateList);
 608             if (ACPI_FAILURE (Status))
 609             {
 610                 goto ErrorExit;
 611             }
 612             break;
 613
 614         case ACPI_TYPE_LOCAL_REFERENCE:
 615             /*
 616              * The target of an Index (a package, string, or buffer) or a named
 617              * reference must track changes to the ref count of the index or
 618              * target object.
 619              */
 620             if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
 621                 (Object->Reference.Class== ACPI_REFCLASS_NAME))
 622             {
 623                 NextObject = Object->Reference.Object;
 624             }
 625             break;
 626
 627         case ACPI_TYPE_REGION:
 628         default:
 629             break; /* No subobjects for all other types */
 630         }
 631
 632         /*
 633          * Now we can update the count in the main object. This can only
 634          * happen after we update the sub-objects in case this causes the
 635          * main object to be deleted.
 636          */
 637         AcpiUtUpdateRefCount (Object, Action);
 638         Object = NULL;
 639
 640         /* Move on to the next object to be updated */
 641
 642         if (NextObject)
 643         {
 644             Object = NextObject;
 645             NextObject = NULL;
 646         }
 647         else if (StateList)
 648         {
 649             State = AcpiUtPopGenericState (&StateList);
 650             Object = State->Update.Object;
 651             AcpiUtDeleteGenericState (State);
 652         }
 653     }
 654
 655     return_ACPI_STATUS (AE_OK);
 656
 657
 658 ErrorExit:
 659
 660     ACPI_EXCEPTION ((AE_INFO, Status,
 661         "Could not update object reference count"));
 662
 663     /* Free any stacked Update State objects */
 664
 665     while (StateList)
 666     {
 667         State = AcpiUtPopGenericState (&StateList);
 668         AcpiUtDeleteGenericState (State);
 669     }
 670
 671     return_ACPI_STATUS (Status);
 672 }
 673
 674
 675 /*******************************************************************************
 676  *
 677  * FUNCTION:    AcpiUtAddReference
 678  *
 679  * PARAMETERS:  Object          - Object whose reference count is to be
 680  *                                incremented
 681  *
 682  * RETURN:      None
 683  *
 684  * DESCRIPTION: Add one reference to an ACPI object
 685  *
 686  ******************************************************************************/
 687
 688 void
 689 AcpiUtAddReference (
 690     ACPI_OPERAND_OBJECT     *Object)
 691 {
 692
 693     ACPI_FUNCTION_TRACE_PTR (UtAddReference, Object);
 694
 695
 696     /* Ensure that we have a valid object */
 697
 698     if (!AcpiUtValidInternalObject (Object))
 699     {
 700         return_VOID;
 701     }
 702
 703     ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 704         "Obj %p Current Refs=%X [To Be Incremented]\n",
 705         Object, Object->Common.ReferenceCount));
 706
 707     /* Increment the reference count */
 708
 709     (void) AcpiUtUpdateObjectReference (Object, REF_INCREMENT);
 710     return_VOID;
 711 }
 712
 713
 714 /*******************************************************************************
 715  *
 716  * FUNCTION:    AcpiUtRemoveReference
 717  *
 718  * PARAMETERS:  Object         - Object whose ref count will be decremented
 719  *
 720  * RETURN:      None
 721  *
 722  * DESCRIPTION: Decrement the reference count of an ACPI internal object
 723  *
 724  ******************************************************************************/
 725
 726 void
 727 AcpiUtRemoveReference (
 728     ACPI_OPERAND_OBJECT     *Object)
 729 {
 730
 731     ACPI_FUNCTION_TRACE_PTR (UtRemoveReference, Object);
 732
 733
 734     /*
 735      * Allow a NULL pointer to be passed in, just ignore it. This saves
 736      * each caller from having to check. Also, ignore NS nodes.
 737      *
 738      */
 739     if (!Object ||
 740         (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED))
 741
 742     {
 743         return_VOID;
 744     }
 745
 746     /* Ensure that we have a valid object */
 747
 748     if (!AcpiUtValidInternalObject (Object))
 749     {
 750         return_VOID;
 751     }
 752
 753     ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
 754         "Obj %p Current Refs=%X [To Be Decremented]\n",
 755         Object, Object->Common.ReferenceCount));
 756
 757     /*
 758      * Decrement the reference count, and only actually delete the object
 759      * if the reference count becomes 0. (Must also decrement the ref count
 760      * of all subobjects!)
 761      */
 762     (void) AcpiUtUpdateObjectReference (Object, REF_DECREMENT);
 763     return_VOID;
 764 }
 765
 766