ReactOS  0.4.15-dev-3165-gdf6fff7
utdelete.c
Go to the documentation of this file.
1 /*******************************************************************************
2  *
3  * Module Name: utdelete - object deletion and reference count utilities
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2021, 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 MERCHANTABILITY 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
59 
60 static void
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
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 
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 
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 
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));
282  return_VOID;
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 
366  return_VOID;
367 }
368 
369 
370 /*******************************************************************************
371  *
372  * FUNCTION: AcpiUtDeleteInternalObjectList
373  *
374  * PARAMETERS: ObjList - Pointer to the list to be deleted
375  *
376  * RETURN: None
377  *
378  * DESCRIPTION: This function deletes an internal object list, including both
379  * simple objects and package objects
380  *
381  ******************************************************************************/
382 
383 void
385  ACPI_OPERAND_OBJECT **ObjList)
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 }
405 
406 
407 /*******************************************************************************
408  *
409  * FUNCTION: AcpiUtUpdateRefCount
410  *
411  * PARAMETERS: Object - Object whose ref count is to be updated
412  * Action - What to do (REF_INCREMENT or REF_DECREMENT)
413  *
414  * RETURN: None. Sets new reference count within the object
415  *
416  * DESCRIPTION: Modify the reference count for an internal acpi object
417  *
418  ******************************************************************************/
419 
420 static void
423  UINT32 Action)
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  }
490 
492  "%s: Obj %p Type %.2X Refs %.2X [Decremented]\n",
493  ACPI_GET_FUNCTION_NAME, Object, Object->Common.Type, NewCount));
494 
495  /* Actually delete the object on a reference count of zero */
496 
497  if (NewCount == 0)
498  {
500  }
501  Message = "Decrement";
502  break;
503 
504  default:
505 
506  AcpiOsReleaseLock (AcpiGbl_ReferenceCountLock, LockFlags);
507  ACPI_ERROR ((AE_INFO, "Unknown Reference Count action (0x%X)",
508  Action));
509  return;
510  }
511 
512  /*
513  * Sanity check the reference count, for debug purposes only.
514  * (A deleted object will have a huge reference count)
515  */
516  if (NewCount > ACPI_MAX_REFERENCE_COUNT)
517  {
519  "Large Reference Count (0x%X) in object %p, Type=0x%.2X Operation=%s",
520  NewCount, Object, Object->Common.Type, Message));
521  }
522 }
523 
524 
525 /*******************************************************************************
526  *
527  * FUNCTION: AcpiUtUpdateObjectReference
528  *
529  * PARAMETERS: Object - Increment or decrement the ref count for
530  * this object and all sub-objects
531  * Action - Either REF_INCREMENT or REF_DECREMENT
532  *
533  * RETURN: Status
534  *
535  * DESCRIPTION: Increment or decrement the object reference count
536  *
537  * Object references are incremented when:
538  * 1) An object is attached to a Node (namespace object)
539  * 2) An object is copied (all subobjects must be incremented)
540  *
541  * Object references are decremented when:
542  * 1) An object is detached from an Node
543  *
544  ******************************************************************************/
545 
549  UINT16 Action)
550 {
552  ACPI_GENERIC_STATE *StateList = NULL;
553  ACPI_OPERAND_OBJECT *NextObject = NULL;
554  ACPI_OPERAND_OBJECT *PrevObject;
556  UINT32 i;
557 
558 
559  ACPI_FUNCTION_NAME (UtUpdateObjectReference);
560 
561 
562  while (Object)
563  {
564  /* Make sure that this isn't a namespace handle */
565 
567  {
569  "Object %p is NS handle\n", Object));
570  return (AE_OK);
571  }
572 
573  /*
574  * All sub-objects must have their reference count updated
575  * also. Different object types have different subobjects.
576  */
577  switch (Object->Common.Type)
578  {
579  case ACPI_TYPE_DEVICE:
580  case ACPI_TYPE_PROCESSOR:
581  case ACPI_TYPE_POWER:
582  case ACPI_TYPE_THERMAL:
583  /*
584  * Update the notify objects for these types (if present)
585  * Two lists, system and device notify handlers.
586  */
587  for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
588  {
589  PrevObject = Object->CommonNotify.NotifyList[i];
590  while (PrevObject)
591  {
592  NextObject = PrevObject->Notify.Next[i];
593  AcpiUtUpdateRefCount (PrevObject, Action);
594  PrevObject = NextObject;
595  }
596  }
597  break;
598 
599  case ACPI_TYPE_PACKAGE:
600  /*
601  * We must update all the sub-objects of the package,
602  * each of whom may have their own sub-objects.
603  */
604  for (i = 0; i < Object->Package.Count; i++)
605  {
606  /*
607  * Null package elements are legal and can be simply
608  * ignored.
609  */
610  NextObject = Object->Package.Elements[i];
611  if (!NextObject)
612  {
613  continue;
614  }
615 
616  switch (NextObject->Common.Type)
617  {
618  case ACPI_TYPE_INTEGER:
619  case ACPI_TYPE_STRING:
620  case ACPI_TYPE_BUFFER:
621  /*
622  * For these very simple sub-objects, we can just
623  * update the reference count here and continue.
624  * Greatly increases performance of this operation.
625  */
626  AcpiUtUpdateRefCount (NextObject, Action);
627  break;
628 
629  default:
630  /*
631  * For complex sub-objects, push them onto the stack
632  * for later processing (this eliminates recursion.)
633  */
635  NextObject, Action, &StateList);
636  if (ACPI_FAILURE (Status))
637  {
638  goto ErrorExit;
639  }
640  break;
641  }
642  }
643 
644  NextObject = NULL;
645  break;
646 
648 
649  NextObject = Object->BufferField.BufferObj;
650  break;
651 
653 
654  NextObject = Object->BankField.BankObj;
656  Object->BankField.RegionObj, Action, &StateList);
657  if (ACPI_FAILURE (Status))
658  {
659  goto ErrorExit;
660  }
661  break;
662 
664 
665  NextObject = Object->IndexField.IndexObj;
667  Object->IndexField.DataObj, Action, &StateList);
668  if (ACPI_FAILURE (Status))
669  {
670  goto ErrorExit;
671  }
672  break;
673 
675  /*
676  * The target of an Index (a package, string, or buffer) or a named
677  * reference must track changes to the ref count of the index or
678  * target object.
679  */
680  if ((Object->Reference.Class == ACPI_REFCLASS_INDEX) ||
681  (Object->Reference.Class== ACPI_REFCLASS_NAME))
682  {
683  NextObject = Object->Reference.Object;
684  }
685  break;
686 
688  case ACPI_TYPE_REGION:
689  default:
690 
691  break; /* No subobjects for all other types */
692  }
693 
694  /*
695  * Now we can update the count in the main object. This can only
696  * happen after we update the sub-objects in case this causes the
697  * main object to be deleted.
698  */
700  Object = NULL;
701 
702  /* Move on to the next object to be updated */
703 
704  if (NextObject)
705  {
706  Object = NextObject;
707  NextObject = NULL;
708  }
709  else if (StateList)
710  {
711  State = AcpiUtPopGenericState (&StateList);
712  Object = State->Update.Object;
714  }
715  }
716 
717  return (AE_OK);
718 
719 
720 ErrorExit:
721 
723  "Could not update object reference count"));
724 
725  /* Free any stacked Update State objects */
726 
727  while (StateList)
728  {
729  State = AcpiUtPopGenericState (&StateList);
731  }
732 
733  return (Status);
734 }
735 
736 
737 /*******************************************************************************
738  *
739  * FUNCTION: AcpiUtAddReference
740  *
741  * PARAMETERS: Object - Object whose reference count is to be
742  * incremented
743  *
744  * RETURN: None
745  *
746  * DESCRIPTION: Add one reference to an ACPI object
747  *
748  ******************************************************************************/
749 
750 void
753 {
754 
755  ACPI_FUNCTION_NAME (UtAddReference);
756 
757 
758  /* Ensure that we have a valid object */
759 
761  {
762  return;
763  }
764 
766  "Obj %p Current Refs=%X [To Be Incremented]\n",
767  Object, Object->Common.ReferenceCount));
768 
769  /* Increment the reference count */
770 
772  return;
773 }
774 
775 
776 /*******************************************************************************
777  *
778  * FUNCTION: AcpiUtRemoveReference
779  *
780  * PARAMETERS: Object - Object whose ref count will be decremented
781  *
782  * RETURN: None
783  *
784  * DESCRIPTION: Decrement the reference count of an ACPI internal object
785  *
786  ******************************************************************************/
787 
788 void
791 {
792 
793  ACPI_FUNCTION_NAME (UtRemoveReference);
794 
795 
796  /*
797  * Allow a NULL pointer to be passed in, just ignore it. This saves
798  * each caller from having to check. Also, ignore NS nodes.
799  */
800  if (!Object ||
802 
803  {
804  return;
805  }
806 
807  /* Ensure that we have a valid object */
808 
810  {
811  return;
812  }
813 
815  "%s: Obj %p Current Refs=%X [To Be Decremented]\n",
816  ACPI_GET_FUNCTION_NAME, Object, Object->Common.ReferenceCount));
817 
818  /*
819  * Decrement the reference count, and only actually delete the object
820  * if the reference count becomes 0. (Must also decrement the ref count
821  * of all subobjects!)
822  */
824  return;
825 }
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
#define AOPOBJ_STATIC_POINTER
Definition: acobject.h:95
#define ACPI_DEBUG_PRINT_RAW(pl)
Definition: acoutput.h:476
#define ACPI_MAX_REFERENCE_COUNT
Definition: acconfig.h:128
#define ACPI_FREE(a)
Definition: actypes.h:386
static void AcpiUtUpdateRefCount(ACPI_OPERAND_OBJECT *Object, UINT32 Action)
Definition: utdelete.c:421
void AcpiUtDeleteGenericState(ACPI_GENERIC_STATE *State)
Definition: utstate.c:340
#define ACPI_TYPE_EVENT
Definition: actypes.h:686
union acpi_operand_object * Handler
Definition: acobject.h:204
union acpi_operand_object * Next
Definition: acobject.h:205
ACPI_CPU_FLAGS AcpiOsAcquireLock(ACPI_SPINLOCK Handle)
Definition: osl.c:498
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define ACPI_TYPE_THERMAL
Definition: actypes.h:692
#define ACPI_WARNING(plist)
Definition: acoutput.h:238
ACPI_OBJECT_PACKAGE Package
Definition: acobject.h:522
ACPI_STATUS AcpiUtUpdateObjectReference(ACPI_OPERAND_OBJECT *Object, UINT16 Action)
Definition: utdelete.c:547
#define ACPI_TYPE_BUFFER
Definition: actypes.h:682
#define ACPI_TYPE_INTEGER
Definition: actypes.h:680
#define ACPI_TYPE_POWER
Definition: actypes.h:690
_In_ ULONG _In_ ULONG State
Definition: potypes.h:516
#define ACPI_CPU_FLAGS
Definition: actypes.h:252
void AcpiUtDeleteObjectDesc(ACPI_OPERAND_OBJECT *Object)
Definition: utobject.c:473
#define ACPI_TYPE_LOCAL_REFERENCE
Definition: actypes.h:711
ACPI_ADR_SPACE_SETUP Setup
Definition: acobject.h:417
#define ACPI_REGION_DEACTIVATE
Definition: actypes.h:1223
union acpi_operand_object * RegionList
Definition: acobject.h:418
UINT32 ACPI_STATUS
Definition: actypes.h:460
union acpi_operand_object * BankObj
Definition: acobject.h:358
#define ACPI_TYPE_LOCAL_INDEX_FIELD
Definition: actypes.h:710
union acpi_operand_object * Next[2]
Definition: acobject.h:403
ACPI_GENERIC_STATE * AcpiUtPopGenericState(ACPI_GENERIC_STATE **ListHead)
Definition: utstate.c:93
#define ACPI_TYPE_PACKAGE
Definition: actypes.h:683
#define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED
Definition: acobject.h:425
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
ACPI_OBJECT_BANK_FIELD BankField
Definition: acobject.h:535
ACPI_OBJECT_EXTRA Extra
Definition: acobject.h:540
unsigned int UINT32
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
void AcpiExUnlinkMutex(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: exmutex.c:73
#define AE_INFO
Definition: acoutput.h:230
union acpi_operand_object * Next
Definition: acobject.h:419
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:789
#define ACPI_TYPE_LOCAL_ADDRESS_HANDLER
Definition: actypes.h:715
ACPI_OBJECT_REFERENCE Reference
Definition: acobject.h:539
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484
ACPI_OBJECT_REGION Region
Definition: acobject.h:526
#define ACPI_FUNCTION_TRACE_PTR(a, b)
Definition: acoutput.h:481
ACPI_STATUS AcpiUtCreateUpdateStateAndPush(ACPI_OPERAND_OBJECT *Object, UINT16 Action, ACPI_GENERIC_STATE **StateList)
Definition: utmisc.c:219
Status
Definition: gdiplustypes.h:24
#define ACPI_TYPE_METHOD
Definition: actypes.h:687
ACPI_STATUS AcpiEvDeleteGpeBlock(ACPI_GPE_BLOCK_INFO *GpeBlock)
Definition: evgpeblk.c:148
void AcpiUtAddReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:751
ACPI_STATUS AcpiOsDeleteSemaphore(ACPI_SEMAPHORE Handle)
Definition: osl.c:378
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
ACPI_OBJECT_NOTIFY_HANDLER Notify
Definition: acobject.h:537
#define return_VOID
Definition: acoutput.h:495
CHAR Message[80]
Definition: alive.c:5
ACPI_OBJECT_INDEX_FIELD IndexField
Definition: acobject.h:536
#define ACPI_TYPE_LOCAL_REGION_FIELD
Definition: actypes.h:708
ACPI_OBJECT_ADDR_HANDLER AddressSpace
Definition: acobject.h:538
#define ACPI_TYPE_DEVICE
Definition: actypes.h:685
union acpi_operand_object * BufferObj
Definition: acobject.h:385
#define ACPI_TYPE_PROCESSOR
Definition: actypes.h:691
#define ACPI_FALLTHROUGH
Definition: actypes.h:1435
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
#define ACPI_GET_FUNCTION_NAME
Definition: acgcc.h:67
BOOLEAN AcpiUtValidInternalObject(void *Object)
Definition: utobject.c:376
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
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:506
static VOID ErrorExit(LPTSTR lpszMessage)
Definition: telnetd.c:647
#define ACPI_TYPE_BUFFER_FIELD
Definition: actypes.h:693
ACPI_OBJECT_COMMON Common
Definition: acobject.h:518
unsigned short UINT16
#define NULL
Definition: types.h:112
static void AcpiUtDeleteInternalObj(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:80
ACPI_OBJECT_COMMON_HEADER ACPI_COMMON_FIELD_INFO union acpi_operand_object * IndexObj
Definition: acobject.h:372
#define ACPI_TYPE_MUTEX
Definition: actypes.h:688
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
ACPI_OBJECT_NOTIFY_COMMON CommonNotify
Definition: acobject.h:527
#define REF_DECREMENT
Definition: acutils.h:182
void AcpiOsReleaseLock(ACPI_SPINLOCK Handle, ACPI_CPU_FLAGS Flags)
Definition: osl.c:516
#define ACPI_TYPE_REGION
Definition: actypes.h:689
#define ACPI_TYPE_LOCAL_BANK_FIELD
Definition: actypes.h:709
void AcpiUtDeleteInternalObjectList(ACPI_OPERAND_OBJECT **ObjList)
Definition: utdelete.c:384
void * RegionContext
Definition: acobject.h:482
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
#define ACPI_TYPE_STRING
Definition: actypes.h:681
#define ACPI_DB_ALLOCATIONS
Definition: acoutput.h:175
ACPI_OBJECT_BUFFER_FIELD BufferField
Definition: acobject.h:534
#define ACPI_DESC_TYPE_NAMED
Definition: acobject.h:576
void AcpiOsDeleteMutex(ACPI_MUTEX Handle)
Definition: osl.c:293
void AcpiUtRemoveAddressRange(ACPI_ADR_SPACE_TYPE SpaceId, ACPI_NAMESPACE_NODE *RegionNode)
Definition: utaddress.c:139
const char * AcpiUtGetObjectTypeName(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: utdecode.c:264
#define AE_OK
Definition: acexcep.h:97
ACPI_OPERAND_OBJECT * AcpiNsGetSecondaryObject(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: nsobject.c:346
#define REF_INCREMENT
Definition: acutils.h:181
union acpi_operand_object ** Elements
Definition: acobject.h:161
#define ACPI_NUM_NOTIFY_TYPES
Definition: actypes.h:839
#define ANOBJ_TEMPORARY
Definition: aclocal.h:216
#define ACPI_GET_DESCRIPTOR_TYPE(d)
Definition: acmacros.h:414