ReactOS  0.4.14-dev-1112-g2b067d6
uttrack.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Module Name: uttrack - Memory allocation tracking routines (debug only)
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2020, 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 /*
45  * These procedures are used for tracking memory leaks in the subsystem, and
46  * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
47  *
48  * Each memory allocation is tracked via a doubly linked list. Each
49  * element contains the caller's component, module name, function name, and
50  * line number. AcpiUtAllocate and AcpiUtAllocateZeroed call
51  * AcpiUtTrackAllocation to add an element to the list; deletion
52  * occurs in the body of AcpiUtFree.
53  */
54 
55 #include "acpi.h"
56 #include "accommon.h"
57 
58 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
59 
60 #define _COMPONENT ACPI_UTILITIES
61  ACPI_MODULE_NAME ("uttrack")
62 
63 
64 /* Local prototypes */
65 
66 static ACPI_DEBUG_MEM_BLOCK *
67 AcpiUtFindAllocation (
68  ACPI_DEBUG_MEM_BLOCK *Allocation);
69 
70 static ACPI_STATUS
71 AcpiUtTrackAllocation (
73  ACPI_SIZE Size,
74  UINT8 AllocType,
75  UINT32 Component,
76  const char *Module,
77  UINT32 Line);
78 
79 static ACPI_STATUS
80 AcpiUtRemoveAllocation (
82  UINT32 Component,
83  const char *Module,
84  UINT32 Line);
85 
86 
87 /*******************************************************************************
88  *
89  * FUNCTION: AcpiUtCreateList
90  *
91  * PARAMETERS: CacheName - Ascii name for the cache
92  * ObjectSize - Size of each cached object
93  * ReturnCache - Where the new cache object is returned
94  *
95  * RETURN: Status
96  *
97  * DESCRIPTION: Create a local memory list for tracking purposed
98  *
99  ******************************************************************************/
100 
102 AcpiUtCreateList (
103  const char *ListName,
104  UINT16 ObjectSize,
105  ACPI_MEMORY_LIST **ReturnCache)
106 {
108 
109 
111  if (!Cache)
112  {
113  return (AE_NO_MEMORY);
114  }
115 
116  Cache->ListName = ListName;
117  Cache->ObjectSize = ObjectSize;
118 
119  *ReturnCache = Cache;
120  return (AE_OK);
121 }
122 
123 
124 /*******************************************************************************
125  *
126  * FUNCTION: AcpiUtAllocateAndTrack
127  *
128  * PARAMETERS: Size - Size of the allocation
129  * Component - Component type of caller
130  * Module - Source file name of caller
131  * Line - Line number of caller
132  *
133  * RETURN: Address of the allocated memory on success, NULL on failure.
134  *
135  * DESCRIPTION: The subsystem's equivalent of malloc.
136  *
137  ******************************************************************************/
138 
139 void *
140 AcpiUtAllocateAndTrack (
141  ACPI_SIZE Size,
142  UINT32 Component,
143  const char *Module,
144  UINT32 Line)
145 {
146  ACPI_DEBUG_MEM_BLOCK *Allocation;
148 
149 
150  /* Check for an inadvertent size of zero bytes */
151 
152  if (!Size)
153  {
154  ACPI_WARNING ((Module, Line,
155  "Attempt to allocate zero bytes, allocating 1 byte"));
156  Size = 1;
157  }
158 
159  Allocation = AcpiOsAllocate (Size + sizeof (ACPI_DEBUG_MEM_HEADER));
160  if (!Allocation)
161  {
162  /* Report allocation error */
163 
164  ACPI_WARNING ((Module, Line,
165  "Could not allocate size %u", (UINT32) Size));
166 
167  return (NULL);
168  }
169 
170  Status = AcpiUtTrackAllocation (
171  Allocation, Size, ACPI_MEM_MALLOC, Component, Module, Line);
172  if (ACPI_FAILURE (Status))
173  {
174  AcpiOsFree (Allocation);
175  return (NULL);
176  }
177 
178  AcpiGbl_GlobalList->TotalAllocated++;
179  AcpiGbl_GlobalList->TotalSize += (UINT32) Size;
180  AcpiGbl_GlobalList->CurrentTotalSize += (UINT32) Size;
181 
182  if (AcpiGbl_GlobalList->CurrentTotalSize >
183  AcpiGbl_GlobalList->MaxOccupied)
184  {
185  AcpiGbl_GlobalList->MaxOccupied =
186  AcpiGbl_GlobalList->CurrentTotalSize;
187  }
188 
189  return ((void *) &Allocation->UserSpace);
190 }
191 
192 
193 /*******************************************************************************
194  *
195  * FUNCTION: AcpiUtAllocateZeroedAndTrack
196  *
197  * PARAMETERS: Size - Size of the allocation
198  * Component - Component type of caller
199  * Module - Source file name of caller
200  * Line - Line number of caller
201  *
202  * RETURN: Address of the allocated memory on success, NULL on failure.
203  *
204  * DESCRIPTION: Subsystem equivalent of calloc.
205  *
206  ******************************************************************************/
207 
208 void *
209 AcpiUtAllocateZeroedAndTrack (
210  ACPI_SIZE Size,
211  UINT32 Component,
212  const char *Module,
213  UINT32 Line)
214 {
215  ACPI_DEBUG_MEM_BLOCK *Allocation;
217 
218 
219  /* Check for an inadvertent size of zero bytes */
220 
221  if (!Size)
222  {
223  ACPI_WARNING ((Module, Line,
224  "Attempt to allocate zero bytes, allocating 1 byte"));
225  Size = 1;
226  }
227 
228  Allocation = AcpiOsAllocateZeroed (
229  Size + sizeof (ACPI_DEBUG_MEM_HEADER));
230  if (!Allocation)
231  {
232  /* Report allocation error */
233 
234  ACPI_ERROR ((Module, Line,
235  "Could not allocate size %u", (UINT32) Size));
236  return (NULL);
237  }
238 
239  Status = AcpiUtTrackAllocation (Allocation, Size,
240  ACPI_MEM_CALLOC, Component, Module, Line);
241  if (ACPI_FAILURE (Status))
242  {
243  AcpiOsFree (Allocation);
244  return (NULL);
245  }
246 
247  AcpiGbl_GlobalList->TotalAllocated++;
248  AcpiGbl_GlobalList->TotalSize += (UINT32) Size;
249  AcpiGbl_GlobalList->CurrentTotalSize += (UINT32) Size;
250 
251  if (AcpiGbl_GlobalList->CurrentTotalSize >
252  AcpiGbl_GlobalList->MaxOccupied)
253  {
254  AcpiGbl_GlobalList->MaxOccupied =
255  AcpiGbl_GlobalList->CurrentTotalSize;
256  }
257 
258  return ((void *) &Allocation->UserSpace);
259 }
260 
261 
262 /*******************************************************************************
263  *
264  * FUNCTION: AcpiUtFreeAndTrack
265  *
266  * PARAMETERS: Allocation - Address of the memory to deallocate
267  * Component - Component type of caller
268  * Module - Source file name of caller
269  * Line - Line number of caller
270  *
271  * RETURN: None
272  *
273  * DESCRIPTION: Frees the memory at Allocation
274  *
275  ******************************************************************************/
276 
277 void
278 AcpiUtFreeAndTrack (
279  void *Allocation,
280  UINT32 Component,
281  const char *Module,
282  UINT32 Line)
283 {
284  ACPI_DEBUG_MEM_BLOCK *DebugBlock;
286 
287 
288  ACPI_FUNCTION_TRACE_PTR (UtFree, Allocation);
289 
290 
291  if (NULL == Allocation)
292  {
293  ACPI_ERROR ((Module, Line,
294  "Attempt to delete a NULL address"));
295 
296  return_VOID;
297  }
298 
299  DebugBlock = ACPI_CAST_PTR (ACPI_DEBUG_MEM_BLOCK,
300  (((char *) Allocation) - sizeof (ACPI_DEBUG_MEM_HEADER)));
301 
302  AcpiGbl_GlobalList->TotalFreed++;
303  AcpiGbl_GlobalList->CurrentTotalSize -= DebugBlock->Size;
304 
305  Status = AcpiUtRemoveAllocation (DebugBlock, Component, Module, Line);
306  if (ACPI_FAILURE (Status))
307  {
308  ACPI_EXCEPTION ((AE_INFO, Status, "Could not free memory"));
309  }
310 
311  AcpiOsFree (DebugBlock);
312  ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed (block %p)\n",
313  Allocation, DebugBlock));
314  return_VOID;
315 }
316 
317 
318 /*******************************************************************************
319  *
320  * FUNCTION: AcpiUtFindAllocation
321  *
322  * PARAMETERS: Allocation - Address of allocated memory
323  *
324  * RETURN: Three cases:
325  * 1) List is empty, NULL is returned.
326  * 2) Element was found. Returns Allocation parameter.
327  * 3) Element was not found. Returns position where it should be
328  * inserted into the list.
329  *
330  * DESCRIPTION: Searches for an element in the global allocation tracking list.
331  * If the element is not found, returns the location within the
332  * list where the element should be inserted.
333  *
334  * Note: The list is ordered by larger-to-smaller addresses.
335  *
336  * This global list is used to detect memory leaks in ACPICA as
337  * well as other issues such as an attempt to release the same
338  * internal object more than once. Although expensive as far
339  * as cpu time, this list is much more helpful for finding these
340  * types of issues than using memory leak detectors outside of
341  * the ACPICA code.
342  *
343  ******************************************************************************/
344 
345 static ACPI_DEBUG_MEM_BLOCK *
346 AcpiUtFindAllocation (
347  ACPI_DEBUG_MEM_BLOCK *Allocation)
348 {
349  ACPI_DEBUG_MEM_BLOCK *Element;
350 
351 
352  Element = AcpiGbl_GlobalList->ListHead;
353  if (!Element)
354  {
355  return (NULL);
356  }
357 
358  /*
359  * Search for the address.
360  *
361  * Note: List is ordered by larger-to-smaller addresses, on the
362  * assumption that a new allocation usually has a larger address
363  * than previous allocations.
364  */
365  while (Element > Allocation)
366  {
367  /* Check for end-of-list */
368 
369  if (!Element->Next)
370  {
371  return (Element);
372  }
373 
374  Element = Element->Next;
375  }
376 
377  if (Element == Allocation)
378  {
379  return (Element);
380  }
381 
382  return (Element->Previous);
383 }
384 
385 
386 /*******************************************************************************
387  *
388  * FUNCTION: AcpiUtTrackAllocation
389  *
390  * PARAMETERS: Allocation - Address of allocated memory
391  * Size - Size of the allocation
392  * AllocType - MEM_MALLOC or MEM_CALLOC
393  * Component - Component type of caller
394  * Module - Source file name of caller
395  * Line - Line number of caller
396  *
397  * RETURN: Status
398  *
399  * DESCRIPTION: Inserts an element into the global allocation tracking list.
400  *
401  ******************************************************************************/
402 
403 static ACPI_STATUS
404 AcpiUtTrackAllocation (
405  ACPI_DEBUG_MEM_BLOCK *Allocation,
406  ACPI_SIZE Size,
407  UINT8 AllocType,
408  UINT32 Component,
409  const char *Module,
410  UINT32 Line)
411 {
412  ACPI_MEMORY_LIST *MemList;
413  ACPI_DEBUG_MEM_BLOCK *Element;
415 
416 
417  ACPI_FUNCTION_TRACE_PTR (UtTrackAllocation, Allocation);
418 
419 
420  if (AcpiGbl_DisableMemTracking)
421  {
423  }
424 
425  MemList = AcpiGbl_GlobalList;
427  if (ACPI_FAILURE (Status))
428  {
430  }
431 
432  /*
433  * Search the global list for this address to make sure it is not
434  * already present. This will catch several kinds of problems.
435  */
436  Element = AcpiUtFindAllocation (Allocation);
437  if (Element == Allocation)
438  {
440  "UtTrackAllocation: Allocation (%p) already present in global list!",
441  Allocation));
442  goto UnlockAndExit;
443  }
444 
445  /* Fill in the instance data */
446 
447  Allocation->Size = (UINT32) Size;
448  Allocation->AllocType = AllocType;
449  Allocation->Component = Component;
450  Allocation->Line = Line;
451 
452  AcpiUtSafeStrncpy (Allocation->Module, (char *) Module, ACPI_MAX_MODULE_NAME);
453 
454  if (!Element)
455  {
456  /* Insert at list head */
457 
458  if (MemList->ListHead)
459  {
460  ((ACPI_DEBUG_MEM_BLOCK *)(MemList->ListHead))->Previous =
461  Allocation;
462  }
463 
464  Allocation->Next = MemList->ListHead;
465  Allocation->Previous = NULL;
466 
467  MemList->ListHead = Allocation;
468  }
469  else
470  {
471  /* Insert after element */
472 
473  Allocation->Next = Element->Next;
474  Allocation->Previous = Element;
475 
476  if (Element->Next)
477  {
478  (Element->Next)->Previous = Allocation;
479  }
480 
481  Element->Next = Allocation;
482  }
483 
484 
485 UnlockAndExit:
488 }
489 
490 
491 /*******************************************************************************
492  *
493  * FUNCTION: AcpiUtRemoveAllocation
494  *
495  * PARAMETERS: Allocation - Address of allocated memory
496  * Component - Component type of caller
497  * Module - Source file name of caller
498  * Line - Line number of caller
499  *
500  * RETURN: Status
501  *
502  * DESCRIPTION: Deletes an element from the global allocation tracking list.
503  *
504  ******************************************************************************/
505 
506 static ACPI_STATUS
507 AcpiUtRemoveAllocation (
508  ACPI_DEBUG_MEM_BLOCK *Allocation,
509  UINT32 Component,
510  const char *Module,
511  UINT32 Line)
512 {
513  ACPI_MEMORY_LIST *MemList;
515 
516 
517  ACPI_FUNCTION_NAME (UtRemoveAllocation);
518 
519 
520  if (AcpiGbl_DisableMemTracking)
521  {
522  return (AE_OK);
523  }
524 
525  MemList = AcpiGbl_GlobalList;
526  if (NULL == MemList->ListHead)
527  {
528  /* No allocations! */
529 
530  ACPI_ERROR ((Module, Line,
531  "Empty allocation list, nothing to free!"));
532 
533  return (AE_OK);
534  }
535 
537  if (ACPI_FAILURE (Status))
538  {
539  return (Status);
540  }
541 
542  /* Unlink */
543 
544  if (Allocation->Previous)
545  {
546  (Allocation->Previous)->Next = Allocation->Next;
547  }
548  else
549  {
550  MemList->ListHead = Allocation->Next;
551  }
552 
553  if (Allocation->Next)
554  {
555  (Allocation->Next)->Previous = Allocation->Previous;
556  }
557 
558  ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing %p, size 0%X\n",
559  &Allocation->UserSpace, Allocation->Size));
560 
561  /* Mark the segment as deleted */
562 
563  memset (&Allocation->UserSpace, 0xEA, Allocation->Size);
564 
566  return (Status);
567 }
568 
569 
570 /*******************************************************************************
571  *
572  * FUNCTION: AcpiUtDumpAllocationInfo
573  *
574  * PARAMETERS: None
575  *
576  * RETURN: None
577  *
578  * DESCRIPTION: Print some info about the outstanding allocations.
579  *
580  ******************************************************************************/
581 
582 void
583 AcpiUtDumpAllocationInfo (
584  void)
585 {
586 /*
587  ACPI_MEMORY_LIST *MemList;
588 */
589 
590  ACPI_FUNCTION_TRACE (UtDumpAllocationInfo);
591 
592 /*
593  ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
594  ("%30s: %4d (%3d Kb)\n", "Current allocations",
595  MemList->CurrentCount,
596  ROUND_UP_TO_1K (MemList->CurrentSize)));
597 
598  ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
599  ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
600  MemList->MaxConcurrentCount,
601  ROUND_UP_TO_1K (MemList->MaxConcurrentSize)));
602 
603 
604  ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
605  ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
606  RunningObjectCount,
607  ROUND_UP_TO_1K (RunningObjectSize)));
608 
609  ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
610  ("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
611  RunningAllocCount,
612  ROUND_UP_TO_1K (RunningAllocSize)));
613 
614 
615  ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
616  ("%30s: %4d (%3d Kb)\n", "Current Nodes",
617  AcpiGbl_CurrentNodeCount,
618  ROUND_UP_TO_1K (AcpiGbl_CurrentNodeSize)));
619 
620  ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
621  ("%30s: %4d (%3d Kb)\n", "Max Nodes",
622  AcpiGbl_MaxConcurrentNodeCount,
623  ROUND_UP_TO_1K ((AcpiGbl_MaxConcurrentNodeCount *
624  sizeof (ACPI_NAMESPACE_NODE)))));
625 */
626  return_VOID;
627 }
628 
629 
630 /*******************************************************************************
631  *
632  * FUNCTION: AcpiUtDumpAllocations
633  *
634  * PARAMETERS: Component - Component(s) to dump info for.
635  * Module - Module to dump info for. NULL means all.
636  *
637  * RETURN: None
638  *
639  * DESCRIPTION: Print a list of all outstanding allocations.
640  *
641  ******************************************************************************/
642 
643 void
644 AcpiUtDumpAllocations (
645  UINT32 Component,
646  const char *Module)
647 {
648  ACPI_DEBUG_MEM_BLOCK *Element;
650  UINT32 NumOutstanding = 0;
652 
653 
654  ACPI_FUNCTION_TRACE (UtDumpAllocations);
655 
656 
657  if (AcpiGbl_DisableMemTracking)
658  {
659  return_VOID;
660  }
661 
662  /*
663  * Walk the allocation list.
664  */
666  {
667  return_VOID;
668  }
669 
670  if (!AcpiGbl_GlobalList)
671  {
672  goto Exit;
673  }
674 
675  Element = AcpiGbl_GlobalList->ListHead;
676  while (Element)
677  {
678  if ((Element->Component & Component) &&
679  ((Module == NULL) || (0 == strcmp (Module, Element->Module))))
680  {
682  ACPI_DESCRIPTOR, &Element->UserSpace);
683 
684  if (Element->Size < sizeof (ACPI_COMMON_DESCRIPTOR))
685  {
686  AcpiOsPrintf ("%p Length 0x%04X %9.9s-%4.4u "
687  "[Not a Descriptor - too small]\n",
688  Descriptor, Element->Size, Element->Module,
689  Element->Line);
690  }
691  else
692  {
693  /* Ignore allocated objects that are in a cache */
694 
697  {
698  AcpiOsPrintf ("%p Length 0x%04X %9.9s-%4.4u [%s] ",
699  Descriptor, Element->Size, Element->Module,
700  Element->Line, AcpiUtGetDescriptorName (Descriptor));
701 
702  /* Optional object hex dump */
703 
704  if (AcpiGbl_VerboseLeakDump)
705  {
706  AcpiOsPrintf ("\n");
707  AcpiUtDumpBuffer ((UINT8 *) Descriptor, Element->Size,
708  DB_BYTE_DISPLAY, 0);
709  }
710 
711  /* Validate the descriptor type using Type field and length */
712 
713  DescriptorType = 0; /* Not a valid descriptor type */
714 
716  {
718 
719  if (Element->Size == sizeof (ACPI_OPERAND_OBJECT))
720  {
722  }
723  break;
724 
726 
727  if (Element->Size == sizeof (ACPI_PARSE_OBJECT))
728  {
730  }
731  break;
732 
734 
735  if (Element->Size == sizeof (ACPI_NAMESPACE_NODE))
736  {
738  }
739  break;
740 
741  default:
742 
743  break;
744  }
745 
746  /* Display additional info for the major descriptor types */
747 
748  switch (DescriptorType)
749  {
751 
752  AcpiOsPrintf ("%12.12s RefCount 0x%04X\n",
753  AcpiUtGetTypeName (Descriptor->Object.Common.Type),
754  Descriptor->Object.Common.ReferenceCount);
755  break;
756 
758 
759  AcpiOsPrintf ("AmlOpcode 0x%04X\n",
760  Descriptor->Op.Asl.AmlOpcode);
761  break;
762 
764 
765  AcpiOsPrintf ("%4.4s\n",
766  AcpiUtGetNodeName (&Descriptor->Node));
767  break;
768 
769  default:
770 
771  AcpiOsPrintf ( "\n");
772  break;
773  }
774  }
775  }
776 
777  NumOutstanding++;
778  }
779 
780  Element = Element->Next;
781  }
782 
783 Exit:
785 
786  /* Print summary */
787 
788  if (!NumOutstanding)
789  {
790  ACPI_INFO (("No outstanding allocations"));
791  }
792  else
793  {
794  ACPI_ERROR ((AE_INFO, "%u (0x%X) Outstanding cache allocations",
795  NumOutstanding, NumOutstanding));
796  }
797 
798  return_VOID;
799 }
800 
801 #endif /* ACPI_DBG_TRACK_ALLOCATIONS */
#define ACPI_EXCEPTION(plist)
Definition: acoutput.h:239
const char * AcpiUtGetDescriptorName(void *Object)
Definition: utdecode.c:381
void * AcpiOsAllocate(ACPI_SIZE Size)
Definition: osl.c:160
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define AE_NO_MEMORY
Definition: acexcep.h:112
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
Definition: fatfs.h:173
#define ACPI_WARNING(plist)
Definition: acoutput.h:238
#define ACPI_MEM_MALLOC
Definition: aclocal.h:1473
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_MEM_CALLOC
Definition: aclocal.h:1474
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define DB_BYTE_DISPLAY
Definition: acutils.h:185
ACPI_STATUS AcpiUtReleaseMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:348
#define ACPI_MTX_MEMORY
Definition: aclocal.h:89
ACPI_STATUS AcpiUtAcquireMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:256
unsigned int UINT32
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define AE_INFO
Definition: acoutput.h:230
smooth NULL
Definition: ftsmooth.c:416
static WCHAR Address[46]
Definition: ping.c:68
ACPI_COMMON_DEBUG_MEM_HEADER UINT64 UserSpace
Definition: aclocal.h:1495
#define ACPI_FUNCTION_TRACE_PTR(a, b)
Definition: acoutput.h:481
void * AcpiOsAllocateZeroed(ACPI_SIZE Size)
Definition: utalloc.c:68
#define ACPI_DESC_TYPE_OPERAND
Definition: acobject.h:574
static void Exit(void)
Definition: sock.c:1331
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
void * ListHead
Definition: actypes.h:1351
#define return_VOID
Definition: acoutput.h:495
void ACPI_INTERNAL_VAR_XFACE AcpiOsPrintf(const char *Format,...)
Definition: osl.c:851
Definition: ncftp.h:79
#define ACPI_MAX_MODULE_NAME
Definition: aclocal.h:1475
void AcpiUtDumpBuffer(UINT8 *Buffer, UINT32 Count, UINT32 Display, UINT32 Offset)
Definition: utbuffer.c:71
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define ACPI_DESC_TYPE_PARSER
Definition: acobject.h:573
#define ACPI_INFO(plist)
Definition: acoutput.h:237
Status
Definition: gdiplustypes.h:24
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
unsigned short UINT16
const char * AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:249
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:305
#define const
Definition: zconf.h:230
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
void AcpiOsFree(void *Memory)
Definition: osl.c:167
#define ACPI_DB_ALLOCATIONS
Definition: acoutput.h:175
#define ACPI_DESC_TYPE_NAMED
Definition: acobject.h:575
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
unsigned char UINT8
#define memset(x, y, z)
Definition: compat.h:39
_In_ ULONG _In_ PVOID _In_ LONG DescriptorType
Definition: usbdlib.h:145
#define AE_OK
Definition: acexcep.h:97
#define ACPI_DESC_TYPE_CACHED
Definition: acobject.h:561
struct Line Line
#define ACPI_GET_DESCRIPTOR_TYPE(d)
Definition: acmacros.h:414
_In_ PSTORAGE_PROPERTY_ID _Outptr_ PSTORAGE_DESCRIPTOR_HEADER * Descriptor
Definition: classpnp.h:966