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 "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
AcpiUtDeleteInternalObj(ACPI_OPERAND_OBJECT * Object)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
AcpiUtDeleteInternalObjectList(ACPI_OPERAND_OBJECT ** ObjList)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
AcpiUtUpdateRefCount(ACPI_OPERAND_OBJECT * Object,UINT32 Action)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 Refs %.2X [Incremented]\n",
453 Object, Object->Common.Type, NewCount));
454 break;
455
456 case REF_DECREMENT:
457
458 /* The current reference count must be non-zero */
459
460 if (OriginalCount)
461 {
462 NewCount = OriginalCount - 1;
463 Object->Common.ReferenceCount = NewCount;
464 }
465
466 AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
467
468 if (!OriginalCount)
469 {
470 ACPI_WARNING ((AE_INFO,
471 "Obj %p, Reference Count is already zero, cannot decrement\n",
472 Object));
473 }
474
475 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
476 "Obj %p Type %.2X Refs %.2X [Decremented]\n",
477 Object, Object->Common.Type, NewCount));
478
479 /* Actually delete the object on a reference count of zero */
480
481 if (NewCount == 0)
482 {
483 AcpiUtDeleteInternalObj (Object);
484 }
485 break;
486
487 default:
488
489 AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
490 ACPI_ERROR ((AE_INFO, "Unknown Reference Count action (0x%X)",
491 Action));
492 return;
493 }
494
495 /*
496 * Sanity check the reference count, for debug purposes only.
497 * (A deleted object will have a huge reference count)
498 */
499 if (NewCount > ACPI_MAX_REFERENCE_COUNT)
500 {
501 ACPI_WARNING ((AE_INFO,
502 "Large Reference Count (0x%X) in object %p, Type=0x%.2X",
503 NewCount, Object, Object->Common.Type));
504 }
505 }
506
507
508 /*******************************************************************************
509 *
510 * FUNCTION: AcpiUtUpdateObjectReference
511 *
512 * PARAMETERS: Object - Increment ref count for this object
513 * and all sub-objects
514 * Action - Either REF_INCREMENT or REF_DECREMENT
515 *
516 * RETURN: Status
517 *
518 * DESCRIPTION: Increment the object reference count
519 *
520 * Object references are incremented when:
521 * 1) An object is attached to a Node (namespace object)
522 * 2) An object is copied (all subobjects must be incremented)
523 *
524 * Object references are decremented when:
525 * 1) An object is detached from an Node
526 *
527 ******************************************************************************/
528
529 ACPI_STATUS
AcpiUtUpdateObjectReference(ACPI_OPERAND_OBJECT * Object,UINT16 Action)530 AcpiUtUpdateObjectReference (
531 ACPI_OPERAND_OBJECT *Object,
532 UINT16 Action)
533 {
534 ACPI_STATUS Status = AE_OK;
535 ACPI_GENERIC_STATE *StateList = NULL;
536 ACPI_OPERAND_OBJECT *NextObject = NULL;
537 ACPI_OPERAND_OBJECT *PrevObject;
538 ACPI_GENERIC_STATE *State;
539 UINT32 i;
540
541
542 ACPI_FUNCTION_NAME (UtUpdateObjectReference);
543
544
545 while (Object)
546 {
547 /* Make sure that this isn't a namespace handle */
548
549 if (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED)
550 {
551 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
552 "Object %p is NS handle\n", Object));
553 return (AE_OK);
554 }
555
556 /*
557 * All sub-objects must have their reference count incremented
558 * also. Different object types have different subobjects.
559 */
560 switch (Object->Common.Type)
561 {
562 case ACPI_TYPE_DEVICE:
563 case ACPI_TYPE_PROCESSOR:
564 case ACPI_TYPE_POWER:
565 case ACPI_TYPE_THERMAL:
566 /*
567 * Update the notify objects for these types (if present)
568 * Two lists, system and device notify handlers.
569 */
570 for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
571 {
572 PrevObject = Object->CommonNotify.NotifyList[i];
573 while (PrevObject)
574 {
575 NextObject = PrevObject->Notify.Next[i];
576 AcpiUtUpdateRefCount (PrevObject, Action);
577 PrevObject = NextObject;
578 }
579 }
580 break;
581
582 case ACPI_TYPE_PACKAGE:
583 /*
584 * We must update all the sub-objects of the package,
585 * each of whom may have their own sub-objects.
586 */
587 for (i = 0; i < Object->Package.Count; i++)
588 {
589 /*
590 * Null package elements are legal and can be simply
591 * ignored.
592 */
593 NextObject = Object->Package.Elements[i];
594 if (!NextObject)
595 {
596 continue;
597 }
598
599 switch (NextObject->Common.Type)
600 {
601 case ACPI_TYPE_INTEGER:
602 case ACPI_TYPE_STRING:
603 case ACPI_TYPE_BUFFER:
604 /*
605 * For these very simple sub-objects, we can just
606 * update the reference count here and continue.
607 * Greatly increases performance of this operation.
608 */
609 AcpiUtUpdateRefCount (NextObject, Action);
610 break;
611
612 default:
613 /*
614 * For complex sub-objects, push them onto the stack
615 * for later processing (this eliminates recursion.)
616 */
617 Status = AcpiUtCreateUpdateStateAndPush (
618 NextObject, Action, &StateList);
619 if (ACPI_FAILURE (Status))
620 {
621 goto ErrorExit;
622 }
623 break;
624 }
625 }
626 NextObject = NULL;
627 break;
628
629 case ACPI_TYPE_BUFFER_FIELD:
630
631 NextObject = Object->BufferField.BufferObj;
632 break;
633
634 case ACPI_TYPE_LOCAL_REGION_FIELD:
635
636 NextObject = Object->Field.RegionObj;
637 break;
638
639 case ACPI_TYPE_LOCAL_BANK_FIELD:
640
641 NextObject = Object->BankField.BankObj;
642 Status = AcpiUtCreateUpdateStateAndPush (
643 Object->BankField.RegionObj, Action, &StateList);
644 if (ACPI_FAILURE (Status))
645 {
646 goto ErrorExit;
647 }
648 break;
649
650 case ACPI_TYPE_LOCAL_INDEX_FIELD:
651
652 NextObject = Object->IndexField.IndexObj;
653 Status = AcpiUtCreateUpdateStateAndPush (
654 Object->IndexField.DataObj, Action, &StateList);
655 if (ACPI_FAILURE (Status))
656 {
657 goto ErrorExit;
658 }
659 break;
660
661 case ACPI_TYPE_LOCAL_REFERENCE:
662 /*
663 * The target of an Index (a package, string, or buffer) or a named
664 * reference must track changes to the ref count of the index or
665 * target object.
666 */
667 if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
668 (Object->Reference.Class== ACPI_REFCLASS_NAME))
669 {
670 NextObject = Object->Reference.Object;
671 }
672 break;
673
674 case ACPI_TYPE_REGION:
675 default:
676
677 break; /* No subobjects for all other types */
678 }
679
680 /*
681 * Now we can update the count in the main object. This can only
682 * happen after we update the sub-objects in case this causes the
683 * main object to be deleted.
684 */
685 AcpiUtUpdateRefCount (Object, Action);
686 Object = NULL;
687
688 /* Move on to the next object to be updated */
689
690 if (NextObject)
691 {
692 Object = NextObject;
693 NextObject = NULL;
694 }
695 else if (StateList)
696 {
697 State = AcpiUtPopGenericState (&StateList);
698 Object = State->Update.Object;
699 AcpiUtDeleteGenericState (State);
700 }
701 }
702
703 return (AE_OK);
704
705
706 ErrorExit:
707
708 ACPI_EXCEPTION ((AE_INFO, Status,
709 "Could not update object reference count"));
710
711 /* Free any stacked Update State objects */
712
713 while (StateList)
714 {
715 State = AcpiUtPopGenericState (&StateList);
716 AcpiUtDeleteGenericState (State);
717 }
718
719 return (Status);
720 }
721
722
723 /*******************************************************************************
724 *
725 * FUNCTION: AcpiUtAddReference
726 *
727 * PARAMETERS: Object - Object whose reference count is to be
728 * incremented
729 *
730 * RETURN: None
731 *
732 * DESCRIPTION: Add one reference to an ACPI object
733 *
734 ******************************************************************************/
735
736 void
AcpiUtAddReference(ACPI_OPERAND_OBJECT * Object)737 AcpiUtAddReference (
738 ACPI_OPERAND_OBJECT *Object)
739 {
740
741 ACPI_FUNCTION_NAME (UtAddReference);
742
743
744 /* Ensure that we have a valid object */
745
746 if (!AcpiUtValidInternalObject (Object))
747 {
748 return;
749 }
750
751 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
752 "Obj %p Current Refs=%X [To Be Incremented]\n",
753 Object, Object->Common.ReferenceCount));
754
755 /* Increment the reference count */
756
757 (void) AcpiUtUpdateObjectReference (Object, REF_INCREMENT);
758 return;
759 }
760
761
762 /*******************************************************************************
763 *
764 * FUNCTION: AcpiUtRemoveReference
765 *
766 * PARAMETERS: Object - Object whose ref count will be decremented
767 *
768 * RETURN: None
769 *
770 * DESCRIPTION: Decrement the reference count of an ACPI internal object
771 *
772 ******************************************************************************/
773
774 void
AcpiUtRemoveReference(ACPI_OPERAND_OBJECT * Object)775 AcpiUtRemoveReference (
776 ACPI_OPERAND_OBJECT *Object)
777 {
778
779 ACPI_FUNCTION_NAME (UtRemoveReference);
780
781
782 /*
783 * Allow a NULL pointer to be passed in, just ignore it. This saves
784 * each caller from having to check. Also, ignore NS nodes.
785 */
786 if (!Object ||
787 (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED))
788
789 {
790 return;
791 }
792
793 /* Ensure that we have a valid object */
794
795 if (!AcpiUtValidInternalObject (Object))
796 {
797 return;
798 }
799
800 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
801 "Obj %p Current Refs=%X [To Be Decremented]\n",
802 Object, Object->Common.ReferenceCount));
803
804 /*
805 * Decrement the reference count, and only actually delete the object
806 * if the reference count becomes 0. (Must also decrement the ref count
807 * of all subobjects!)
808 */
809 (void) AcpiUtUpdateObjectReference (Object, REF_DECREMENT);
810 return;
811 }
812