ReactOS 0.4.15-dev-8231-g29a56f3
utdelete.c File Reference
#include "acpi.h"
#include "accommon.h"
#include "acinterp.h"
#include "acnamesp.h"
#include "acevents.h"
Include dependency graph for utdelete.c:

Go to the source code of this file.

Macros

#define _COMPONENT   ACPI_UTILITIES
 

Functions

static void AcpiUtDeleteInternalObj (ACPI_OPERAND_OBJECT *Object)
 
static void AcpiUtUpdateRefCount (ACPI_OPERAND_OBJECT *Object, UINT32 Action)
 
void AcpiUtDeleteInternalObjectList (ACPI_OPERAND_OBJECT **ObjList)
 
ACPI_STATUS AcpiUtUpdateObjectReference (ACPI_OPERAND_OBJECT *Object, UINT16 Action)
 
void AcpiUtAddReference (ACPI_OPERAND_OBJECT *Object)
 
void AcpiUtRemoveReference (ACPI_OPERAND_OBJECT *Object)
 

Macro Definition Documentation

◆ _COMPONENT

#define _COMPONENT   ACPI_UTILITIES

Definition at line 51 of file utdelete.c.

Function Documentation

◆ AcpiUtAddReference()

void AcpiUtAddReference ( ACPI_OPERAND_OBJECT Object)

Definition at line 752 of file utdelete.c.

754{
755
756 ACPI_FUNCTION_NAME (UtAddReference);
757
758
759 /* Ensure that we have a valid object */
760
762 {
763 return;
764 }
765
767 "Obj %p Current Refs=%X [To Be Incremented]\n",
768 Object, Object->Common.ReferenceCount));
769
770 /* Increment the reference count */
771
773 return;
774}
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define ACPI_DB_ALLOCATIONS
Definition: acoutput.h:175
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
BOOLEAN AcpiUtValidInternalObject(void *Object)
Definition: utobject.c:376
#define REF_INCREMENT
Definition: acutils.h:181
ACPI_STATUS AcpiUtUpdateObjectReference(ACPI_OPERAND_OBJECT *Object, UINT16 Action)
Definition: utdelete.c:548
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object

Referenced by AcpiDsBuildInternalPackageObj(), AcpiDsDoImplicitReturn(), AcpiDsExecEndOp(), AcpiDsMethodDataGetValue(), AcpiDsMethodDataSetValue(), AcpiEvAttachRegion(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_1A_1T_1R(), AcpiExOpcode_2A_1T_1R(), AcpiExPrepFieldValue(), AcpiExResolveNodeToValue(), AcpiExResolveObjectToValue(), AcpiExStoreObjectToIndex(), AcpiInstallNotifyHandler(), AcpiNsAttachObject(), AcpiNsConvertToReference(), AcpiNsResolveReferences(), and AcpiUtCopySimpleObject().

◆ AcpiUtDeleteInternalObj()

static void AcpiUtDeleteInternalObj ( ACPI_OPERAND_OBJECT Object)
static

Definition at line 80 of file utdelete.c.

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 {
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
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
162
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
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 {
196 AcpiOsDeleteMutex (Object->Mutex.OsMutex);
197 }
198 break;
199
200 case ACPI_TYPE_EVENT:
201
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
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
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 {
280 "Circular region list in address handler object %p",
281 HandlerDesc));
283 }
284 }
285
286 if (HandlerDesc->AddressSpace.HandlerFlags &
288 {
289 /* Deactivate region and free region context */
290
291 if (HandlerDesc->AddressSpace.Setup)
292 {
293 (void) HandlerDesc->AddressSpace.Setup (Object,
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
315
317 "***** Buffer Field %p\n", Object));
318
319 SecondDesc = AcpiNsGetSecondaryObject (Object);
320 if (SecondDesc)
321 {
322 AcpiUtDeleteObjectDesc (SecondDesc);
323 }
324 break;
325
327
329 "***** Bank Field %p\n", Object));
330
331 SecondDesc = AcpiNsGetSecondaryObject (Object);
332 if (SecondDesc)
333 {
334 AcpiUtDeleteObjectDesc (SecondDesc);
335 }
336 break;
337
339
341 "***** Address handler %p\n", Object));
342
343 AcpiOsDeleteMutex (Object->AddressSpace.ContextMutex);
344 break;
345
346 default:
347
348 break;
349 }
350
351 /* Free any allocated memory (pointer within the object) found above */
352
353 if (ObjPointer)
354 {
355 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object Subptr %p\n",
356 ObjPointer));
357 ACPI_FREE (ObjPointer);
358 }
359
360 /* Now the object can be safely deleted */
361
362 ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ALLOCATIONS, "%s: Deleting Object %p [%s]\n",
364
367}
#define ACPI_GET_FUNCTION_NAME
Definition: acgcc.h:67
#define ANOBJ_TEMPORARY
Definition: aclocal.h:216
ACPI_OPERAND_OBJECT * AcpiNsGetSecondaryObject(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: nsobject.c:346
#define AOPOBJ_STATIC_POINTER
Definition: acobject.h:95
#define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED
Definition: acobject.h:426
#define ACPI_FUNCTION_TRACE_PTR(a, b)
Definition: acoutput.h:481
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
#define AE_INFO
Definition: acoutput.h:230
#define ACPI_DEBUG_PRINT_RAW(pl)
Definition: acoutput.h:476
#define return_VOID
Definition: acoutput.h:495
ACPI_STATUS AcpiOsDeleteSemaphore(ACPI_SEMAPHORE Handle)
Definition: osl.c:378
#define ACPI_REGION_DEACTIVATE
Definition: actypes.h:1246
#define ACPI_TYPE_BUFFER_FIELD
Definition: actypes.h:701
#define ACPI_TYPE_STRING
Definition: actypes.h:689
#define ACPI_TYPE_LOCAL_BANK_FIELD
Definition: actypes.h:717
#define ACPI_TYPE_EVENT
Definition: actypes.h:694
#define ACPI_TYPE_PROCESSOR
Definition: actypes.h:699
#define AcpiOsDeleteMutex(Handle)
Definition: actypes.h:275
#define ACPI_TYPE_MUTEX
Definition: actypes.h:696
#define ACPI_TYPE_BUFFER
Definition: actypes.h:690
#define ACPI_TYPE_REGION
Definition: actypes.h:697
#define ACPI_FREE(a)
Definition: actypes.h:386
#define ACPI_TYPE_DEVICE
Definition: actypes.h:693
#define ACPI_TYPE_LOCAL_ADDRESS_HANDLER
Definition: actypes.h:723
#define ACPI_TYPE_PACKAGE
Definition: actypes.h:691
#define ACPI_TYPE_METHOD
Definition: actypes.h:695
#define ACPI_TYPE_THERMAL
Definition: actypes.h:700
#define ACPI_FALLTHROUGH
Definition: actypes.h:1466
void AcpiUtDeleteObjectDesc(ACPI_OPERAND_OBJECT *Object)
Definition: utobject.c:473
const char * AcpiUtGetObjectTypeName(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: utdecode.c:264
void AcpiUtRemoveAddressRange(ACPI_ADR_SPACE_TYPE SpaceId, ACPI_NAMESPACE_NODE *RegionNode)
Definition: utaddress.c:139
#define NULL
Definition: types.h:112
ACPI_STATUS AcpiEvDeleteGpeBlock(ACPI_GPE_BLOCK_INFO *GpeBlock)
Definition: evgpeblk.c:148
void AcpiExUnlinkMutex(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: exmutex.c:73
union acpi_operand_object * RegionList
Definition: acobject.h:419
ACPI_ADR_SPACE_SETUP Setup
Definition: acobject.h:418
union acpi_operand_object * Next
Definition: acobject.h:420
void * RegionContext
Definition: acobject.h:483
union acpi_operand_object * Handler
Definition: acobject.h:204
union acpi_operand_object * Next
Definition: acobject.h:205
ACPI_OBJECT_ADDR_HANDLER AddressSpace
Definition: acobject.h:539
ACPI_OBJECT_NOTIFY_COMMON CommonNotify
Definition: acobject.h:528
ACPI_OBJECT_REGION Region
Definition: acobject.h:527
ACPI_OBJECT_EXTRA Extra
Definition: acobject.h:541
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:790

Referenced by AcpiUtUpdateRefCount().

◆ AcpiUtDeleteInternalObjectList()

void AcpiUtDeleteInternalObjectList ( ACPI_OPERAND_OBJECT **  ObjList)

Definition at line 384 of file utdelete.c.

386{
387 ACPI_OPERAND_OBJECT **InternalObj;
388
389
391
392
393 /* Walk the null-terminated internal list */
394
395 for (InternalObj = ObjList; *InternalObj; InternalObj++)
396 {
397 AcpiUtRemoveReference (*InternalObj);
398 }
399
400 /* Free the combined parameter pointer list and object array */
401
402 ACPI_FREE (ObjList);
403 return;
404}
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484

Referenced by AcpiEvaluateObject().

◆ AcpiUtRemoveReference()

void AcpiUtRemoveReference ( ACPI_OPERAND_OBJECT Object)

Definition at line 790 of file utdelete.c.

792{
793
794 ACPI_FUNCTION_NAME (UtRemoveReference);
795
796
797 /*
798 * Allow a NULL pointer to be passed in, just ignore it. This saves
799 * each caller from having to check. Also, ignore NS nodes.
800 */
801 if (!Object ||
803
804 {
805 return;
806 }
807
808 /* Ensure that we have a valid object */
809
811 {
812 return;
813 }
814
816 "%s: Obj %p Current Refs=%X [To Be Decremented]\n",
817 ACPI_GET_FUNCTION_NAME, Object, Object->Common.ReferenceCount));
818
819 /*
820 * Decrement the reference count, and only actually delete the object
821 * if the reference count becomes 0. (Must also decrement the ref count
822 * of all subobjects!)
823 */
825 return;
826}
#define ACPI_GET_DESCRIPTOR_TYPE(d)
Definition: acmacros.h:414
#define ACPI_DESC_TYPE_NAMED
Definition: acobject.h:577
#define REF_DECREMENT
Definition: acutils.h:182

Referenced by AcpiDsBuildInternalBufferObj(), AcpiDsBuildInternalObject(), AcpiDsBuildInternalPackageObj(), AcpiDsCallControlMethod(), AcpiDsClearImplicitReturn(), AcpiDsClearOperands(), AcpiDsCreateBufferField(), AcpiDsCreateNode(), AcpiDsDeleteResultIfNotUsed(), AcpiDsEvalBankFieldOperands(), AcpiDsEvalDataObjectOperands(), AcpiDsEvalRegionOperands(), AcpiDsEvalTableRegionOperands(), AcpiDsEvaluateNamePath(), AcpiDsExecEndControlOp(), AcpiDsGetFieldNames(), AcpiDsGetPredicateValue(), AcpiDsInitBufferField(), AcpiDsLoad2EndOp(), AcpiDsMethodDataDeleteValue(), AcpiDsObjStackPopAndDelete(), AcpiDsResolvePackageElement(), AcpiDsRestartControlMethod(), AcpiDsStoreObjectToLocal(), AcpiEvaluateObject(), AcpiEvDetachRegion(), AcpiEvExecuteRegMethod(), AcpiEvInstallSpaceHandler(), AcpiExCreateEvent(), AcpiExCreateMethod(), AcpiExCreateMutex(), AcpiExCreatePowerResource(), AcpiExCreateProcessor(), AcpiExCreateRegion(), AcpiExDoConcatenate(), AcpiExDoLogicalOp(), AcpiExLoadOp(), AcpiExLoadTableOp(), AcpiExOpcode_0A_0T_1R(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_1A_1T_1R(), AcpiExOpcode_2A_0T_1R(), AcpiExOpcode_2A_1T_1R(), AcpiExOpcode_2A_2T_1R(), AcpiExOpcode_3A_1T_1R(), AcpiExOpcode_6A_0T_1R(), AcpiExPrepFieldValue(), AcpiExReadDataFromField(), AcpiExResolveMultiple(), AcpiExResolveObjectToValue(), AcpiExResolveOperands(), AcpiExStoreDirectToNode(), AcpiExStoreObjectToIndex(), AcpiExStoreObjectToObject(), AcpiGetSleepTypeData(), AcpiInstallGpeBlock(), AcpiInstallMethod(), AcpiInstallNotifyHandler(), AcpiNsDeleteNode(), AcpiNsDetachData(), AcpiNsDetachObject(), AcpiNsEvaluate(), AcpiNsExecuteTable(), AcpiNsRemoveElement(), AcpiNsRepair_CID(), AcpiNsRepair_FDE(), AcpiNsRepair_HID(), AcpiNsResolveReferences(), AcpiNsRootInitialize(), AcpiNsSearchAndEnter(), AcpiNsSimpleRepair(), AcpiPsParseAml(), AcpiRemoveAddressSpaceHandler(), AcpiRemoveNotifyHandler(), AcpiRsGetAeiMethodData(), AcpiRsGetCrsMethodData(), AcpiRsGetMethodData(), AcpiRsGetPrsMethodData(), AcpiRsGetPrtMethodData(), AcpiRsSetSrsMethodData(), AcpiUtCopyEpackageToIpackage(), AcpiUtCopyEsimpleToIsimple(), AcpiUtCopyIelementToIelement(), AcpiUtCopyIobjectToIobject(), AcpiUtCopyIpackageToIpackage(), AcpiUtCreateBufferObject(), AcpiUtCreateStringObject(), AcpiUtDeleteInternalObj(), AcpiUtDeleteInternalObjectList(), AcpiUtEvaluateNumericObject(), AcpiUtEvaluateObject(), AcpiUtExecute_CID(), AcpiUtExecute_CLS(), AcpiUtExecute_HID(), AcpiUtExecute_STA(), AcpiUtExecute_UID(), AcpiUtExecutePowerMethods(), and AcpiUtOsiImplementation().

◆ AcpiUtUpdateObjectReference()

ACPI_STATUS AcpiUtUpdateObjectReference ( ACPI_OPERAND_OBJECT Object,
UINT16  Action 
)

Definition at line 548 of file utdelete.c.

551{
553 ACPI_GENERIC_STATE *StateList = NULL;
554 ACPI_OPERAND_OBJECT *NextObject = NULL;
555 ACPI_OPERAND_OBJECT *PrevObject;
557 UINT32 i;
558
559
560 ACPI_FUNCTION_NAME (UtUpdateObjectReference);
561
562
563 while (Object)
564 {
565 /* Make sure that this isn't a namespace handle */
566
568 {
570 "Object %p is NS handle\n", Object));
571 return (AE_OK);
572 }
573
574 /*
575 * All sub-objects must have their reference count updated
576 * also. Different object types have different subobjects.
577 */
578 switch (Object->Common.Type)
579 {
580 case ACPI_TYPE_DEVICE:
582 case ACPI_TYPE_POWER:
584 /*
585 * Update the notify objects for these types (if present)
586 * Two lists, system and device notify handlers.
587 */
588 for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
589 {
590 PrevObject = Object->CommonNotify.NotifyList[i];
591 while (PrevObject)
592 {
593 NextObject = PrevObject->Notify.Next[i];
594 AcpiUtUpdateRefCount (PrevObject, Action);
595 PrevObject = NextObject;
596 }
597 }
598 break;
599
601 /*
602 * We must update all the sub-objects of the package,
603 * each of whom may have their own sub-objects.
604 */
605 for (i = 0; i < Object->Package.Count; i++)
606 {
607 /*
608 * Null package elements are legal and can be simply
609 * ignored.
610 */
611 NextObject = Object->Package.Elements[i];
612 if (!NextObject)
613 {
614 continue;
615 }
616
617 switch (NextObject->Common.Type)
618 {
620 case ACPI_TYPE_STRING:
621 case ACPI_TYPE_BUFFER:
622 /*
623 * For these very simple sub-objects, we can just
624 * update the reference count here and continue.
625 * Greatly increases performance of this operation.
626 */
627 AcpiUtUpdateRefCount (NextObject, Action);
628 break;
629
630 default:
631 /*
632 * For complex sub-objects, push them onto the stack
633 * for later processing (this eliminates recursion.)
634 */
636 NextObject, Action, &StateList);
637 if (ACPI_FAILURE (Status))
638 {
639 goto ErrorExit;
640 }
641 break;
642 }
643 }
644
645 NextObject = NULL;
646 break;
647
649
650 NextObject = Object->BufferField.BufferObj;
651 break;
652
654
655 NextObject = Object->BankField.BankObj;
657 Object->BankField.RegionObj, Action, &StateList);
658 if (ACPI_FAILURE (Status))
659 {
660 goto ErrorExit;
661 }
662 break;
663
665
666 NextObject = Object->IndexField.IndexObj;
668 Object->IndexField.DataObj, Action, &StateList);
669 if (ACPI_FAILURE (Status))
670 {
671 goto ErrorExit;
672 }
673 break;
674
676 /*
677 * The target of an Index (a package, string, or buffer) or a named
678 * reference must track changes to the ref count of the index or
679 * target object.
680 */
681 if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
682 (Object->Reference.Class== ACPI_REFCLASS_NAME))
683 {
684 NextObject = Object->Reference.Object;
685 }
686 break;
687
689 case ACPI_TYPE_REGION:
690 default:
691
692 break; /* No subobjects for all other types */
693 }
694
695 /*
696 * Now we can update the count in the main object. This can only
697 * happen after we update the sub-objects in case this causes the
698 * main object to be deleted.
699 */
701 Object = NULL;
702
703 /* Move on to the next object to be updated */
704
705 if (NextObject)
706 {
707 Object = NextObject;
708 NextObject = NULL;
709 }
710 else if (StateList)
711 {
712 State = AcpiUtPopGenericState (&StateList);
713 Object = State->Update.Object;
715 }
716 }
717
718 return (AE_OK);
719
720
722
724 "Could not update object reference count"));
725
726 /* Free any stacked Update State objects */
727
728 while (StateList)
729 {
730 State = AcpiUtPopGenericState (&StateList);
732 }
733
734 return (Status);
735}
unsigned int UINT32
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_OK
Definition: acexcep.h:97
@ ACPI_REFCLASS_NAME
Definition: acobject.h:464
@ ACPI_REFCLASS_INDEX
Definition: acobject.h:462
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
#define ACPI_TYPE_LOCAL_REFERENCE
Definition: actypes.h:719
#define ACPI_TYPE_INTEGER
Definition: actypes.h:688
#define ACPI_TYPE_LOCAL_REGION_FIELD
Definition: actypes.h:716
#define ACPI_TYPE_POWER
Definition: actypes.h:698
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_NUM_NOTIFY_TYPES
Definition: actypes.h:848
#define ACPI_TYPE_LOCAL_INDEX_FIELD
Definition: actypes.h:718
ACPI_GENERIC_STATE * AcpiUtPopGenericState(ACPI_GENERIC_STATE **ListHead)
Definition: utstate.c:93
ACPI_STATUS AcpiUtCreateUpdateStateAndPush(ACPI_OPERAND_OBJECT *Object, UINT16 Action, ACPI_GENERIC_STATE **StateList)
Definition: utmisc.c:219
void AcpiUtDeleteGenericState(ACPI_GENERIC_STATE *State)
Definition: utstate.c:340
Status
Definition: gdiplustypes.h:25
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
union acpi_operand_object * BankObj
Definition: acobject.h:359
union acpi_operand_object * BufferObj
Definition: acobject.h:386
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object * IndexObj
Definition: acobject.h:373
union acpi_operand_object * Next[2]
Definition: acobject.h:404
union acpi_operand_object ** Elements
Definition: acobject.h:161
static VOID ErrorExit(LPTSTR lpszMessage)
Definition: telnetd.c:647
ACPI_OBJECT_NOTIFY_HANDLER Notify
Definition: acobject.h:538
ACPI_OBJECT_BANK_FIELD BankField
Definition: acobject.h:536
ACPI_OBJECT_BUFFER_FIELD BufferField
Definition: acobject.h:535
ACPI_OBJECT_REFERENCE Reference
Definition: acobject.h:540
ACPI_OBJECT_INDEX_FIELD IndexField
Definition: acobject.h:537
ACPI_OBJECT_COMMON Common
Definition: acobject.h:519
ACPI_OBJECT_PACKAGE Package
Definition: acobject.h:523
static void AcpiUtUpdateRefCount(ACPI_OPERAND_OBJECT *Object, UINT32 Action)
Definition: utdelete.c:421
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:510

Referenced by AcpiPsUpdateParameterList(), AcpiUtAddReference(), and AcpiUtRemoveReference().

◆ AcpiUtUpdateRefCount()

static void AcpiUtUpdateRefCount ( ACPI_OPERAND_OBJECT Object,
UINT32  Action 
)
static

Definition at line 421 of file utdelete.c.

424{
425 UINT16 OriginalCount;
426 UINT16 NewCount = 0;
427 ACPI_CPU_FLAGS LockFlags;
428 char *Message;
429
430
431 ACPI_FUNCTION_NAME (UtUpdateRefCount);
432
433
434 if (!Object)
435 {
436 return;
437 }
438
439 /*
440 * Always get the reference count lock. Note: Interpreter and/or
441 * Namespace is not always locked when this function is called.
442 */
443 LockFlags = AcpiOsAcquireLock (AcpiGbl_ReferenceCountLock);
444 OriginalCount = Object->Common.ReferenceCount;
445
446 /* Perform the reference count action (increment, decrement) */
447
448 switch (Action)
449 {
450 case REF_INCREMENT:
451
452 NewCount = OriginalCount + 1;
453 Object->Common.ReferenceCount = NewCount;
454 AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
455
456 /* The current reference count should never be zero here */
457
458 if (!OriginalCount)
459 {
461 "Obj %p, Reference Count was zero before increment\n",
462 Object));
463 }
464
466 "Obj %p Type %.2X [%s] Refs %.2X [Incremented]\n",
467 Object, Object->Common.Type,
468 AcpiUtGetObjectTypeName (Object), NewCount));
469 Message = "Incremement";
470 break;
471
472 case REF_DECREMENT:
473
474 /* The current reference count must be non-zero */
475
476 if (OriginalCount)
477 {
478 NewCount = OriginalCount - 1;
479 Object->Common.ReferenceCount = NewCount;
480 }
481
482 AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
483
484 if (!OriginalCount)
485 {
487 "Obj %p, Reference Count is already zero, cannot decrement\n",
488 Object));
489 return;
490 }
491
493 "%s: Obj %p Type %.2X Refs %.2X [Decremented]\n",
494 ACPI_GET_FUNCTION_NAME, Object, Object->Common.Type, NewCount));
495
496 /* Actually delete the object on a reference count of zero */
497
498 if (NewCount == 0)
499 {
501 }
502 Message = "Decrement";
503 break;
504
505 default:
506
507 AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
508 ACPI_ERROR ((AE_INFO, "Unknown Reference Count action (0x%X)",
509 Action));
510 return;
511 }
512
513 /*
514 * Sanity check the reference count, for debug purposes only.
515 * (A deleted object will have a huge reference count)
516 */
517 if (NewCount > ACPI_MAX_REFERENCE_COUNT)
518 {
520 "Large Reference Count (0x%X) in object %p, Type=0x%.2X Operation=%s",
521 NewCount, Object, Object->Common.Type, Message));
522 }
523}
unsigned short UINT16
#define ACPI_WARNING(plist)
Definition: acoutput.h:238
void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
Definition: osl.c:516
ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
Definition: osl.c:498
#define ACPI_CPU_FLAGS
Definition: actypes.h:252
static const WCHAR Message[]
Definition: register.c:74
#define ACPI_MAX_REFERENCE_COUNT
Definition: acconfig.h:128
static void AcpiUtDeleteInternalObj(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:80

Referenced by AcpiUtUpdateObjectReference().