xref: /freebsd/sys/contrib/dev/acpica/components/utilities/utdelete.c (revision 63d1fd5970ec814904aa0f4580b10a0d302d08b2)
1 /*******************************************************************************
2  *
3  * Module Name: utdelete - object deletion and reference count utilities
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, 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 <contrib/dev/acpica/include/acpi.h>
45 #include <contrib/dev/acpica/include/accommon.h>
46 #include <contrib/dev/acpica/include/acinterp.h>
47 #include <contrib/dev/acpica/include/acnamesp.h>
48 #include <contrib/dev/acpica/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 }
813