ReactOS 0.4.15-dev-7924-g5949c20
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 - 2022, 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
56static void
59
60static void
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
79static 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
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}
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
383void
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
420static void
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}
524
525
526/*******************************************************************************
527 *
528 * FUNCTION: AcpiUtUpdateObjectReference
529 *
530 * PARAMETERS: Object - Increment or decrement the ref count for
531 * this object and all sub-objects
532 * Action - Either REF_INCREMENT or REF_DECREMENT
533 *
534 * RETURN: Status
535 *
536 * DESCRIPTION: Increment or decrement the object reference count
537 *
538 * Object references are incremented when:
539 * 1) An object is attached to a Node (namespace object)
540 * 2) An object is copied (all subobjects must be incremented)
541 *
542 * Object references are decremented when:
543 * 1) An object is detached from an Node
544 *
545 ******************************************************************************/
546
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}
736
737
738/*******************************************************************************
739 *
740 * FUNCTION: AcpiUtAddReference
741 *
742 * PARAMETERS: Object - Object whose reference count is to be
743 * incremented
744 *
745 * RETURN: None
746 *
747 * DESCRIPTION: Add one reference to an ACPI object
748 *
749 ******************************************************************************/
750
751void
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}
775
776
777/*******************************************************************************
778 *
779 * FUNCTION: AcpiUtRemoveReference
780 *
781 * PARAMETERS: Object - Object whose ref count will be decremented
782 *
783 * RETURN: None
784 *
785 * DESCRIPTION: Decrement the reference count of an ACPI internal object
786 *
787 ******************************************************************************/
788
789void
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}
unsigned short UINT16
unsigned int UINT32
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_OK
Definition: acexcep.h:97
#define ACPI_GET_FUNCTION_NAME
Definition: acgcc.h:67
#define ANOBJ_TEMPORARY
Definition: aclocal.h:216
#define ACPI_GET_DESCRIPTOR_TYPE(d)
Definition: acmacros.h:414
ACPI_OPERAND_OBJECT * AcpiNsGetSecondaryObject(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: nsobject.c:346
#define ACPI_DESC_TYPE_NAMED
Definition: acobject.h:577
@ ACPI_REFCLASS_NAME
Definition: acobject.h:464
@ ACPI_REFCLASS_INDEX
Definition: acobject.h:462
#define AOPOBJ_STATIC_POINTER
Definition: acobject.h:95
#define ACPI_ADDR_HANDLER_DEFAULT_INSTALLED
Definition: acobject.h:426
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define ACPI_DB_ALLOCATIONS
Definition: acoutput.h:175
#define ACPI_WARNING(plist)
Definition: acoutput.h:238
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484
#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
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
ACPI_STATUS AcpiOsDeleteSemaphore(ACPI_SEMAPHORE Handle)
Definition: osl.c:378
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_TYPE_LOCAL_REFERENCE
Definition: actypes.h:719
#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_CPU_FLAGS
Definition: actypes.h:252
#define ACPI_TYPE_REGION
Definition: actypes.h:697
#define ACPI_FREE(a)
Definition: actypes.h:386
#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_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_LOCAL_INDEX_FIELD
Definition: actypes.h:718
#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
ACPI_GENERIC_STATE * AcpiUtPopGenericState(ACPI_GENERIC_STATE **ListHead)
Definition: utstate.c:93
#define REF_DECREMENT
Definition: acutils.h:182
BOOLEAN AcpiUtValidInternalObject(void *Object)
Definition: utobject.c:376
#define REF_INCREMENT
Definition: acutils.h:181
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
void AcpiUtRemoveAddressRange(ACPI_ADR_SPACE_TYPE SpaceId, ACPI_NAMESPACE_NODE *RegionNode)
Definition: utaddress.c:139
#define NULL
Definition: types.h:112
static const WCHAR Message[]
Definition: register.c:74
#define ACPI_MAX_REFERENCE_COUNT
Definition: acconfig.h:128
ACPI_STATUS AcpiEvDeleteGpeBlock(ACPI_GPE_BLOCK_INFO *GpeBlock)
Definition: evgpeblk.c:148
void AcpiExUnlinkMutex(ACPI_OPERAND_OBJECT *ObjDesc)
Definition: exmutex.c:73
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 * RegionList
Definition: acobject.h:419
ACPI_ADR_SPACE_SETUP Setup
Definition: acobject.h:418
union acpi_operand_object * Next
Definition: acobject.h:420
union acpi_operand_object * BankObj
Definition: acobject.h:359
union acpi_operand_object * BufferObj
Definition: acobject.h:386
void * RegionContext
Definition: acobject.h:483
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
union acpi_operand_object * Handler
Definition: acobject.h:204
union acpi_operand_object * Next
Definition: acobject.h:205
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_ADDR_HANDLER AddressSpace
Definition: acobject.h:539
ACPI_OBJECT_NOTIFY_COMMON CommonNotify
Definition: acobject.h:528
ACPI_OBJECT_BUFFER_FIELD BufferField
Definition: acobject.h:535
ACPI_OBJECT_REGION Region
Definition: acobject.h:527
ACPI_OBJECT_EXTRA Extra
Definition: acobject.h:541
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
ACPI_STATUS AcpiUtUpdateObjectReference(ACPI_OPERAND_OBJECT *Object, UINT16 Action)
Definition: utdelete.c:548
static void AcpiUtDeleteInternalObj(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:80
void AcpiUtDeleteInternalObjectList(ACPI_OPERAND_OBJECT **ObjList)
Definition: utdelete.c:384
void AcpiUtRemoveReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:790
void AcpiUtAddReference(ACPI_OPERAND_OBJECT *Object)
Definition: utdelete.c:752
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:510