ReactOS 0.4.15-dev-8390-g075894b
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 - 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/*
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
67AcpiUtFindAllocation (
69
70static ACPI_STATUS
71AcpiUtTrackAllocation (
73 ACPI_SIZE Size,
74 UINT8 AllocType,
76 const char *Module,
77 UINT32 Line);
78
79static ACPI_STATUS
80AcpiUtRemoveAllocation (
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
102AcpiUtCreateList (
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
139void *
140AcpiUtAllocateAndTrack (
141 ACPI_SIZE Size,
143 const char *Module,
144 UINT32 Line)
145{
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
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 (
172 if (ACPI_FAILURE (Status))
173 {
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
208void *
209AcpiUtAllocateZeroedAndTrack (
210 ACPI_SIZE Size,
212 const char *Module,
213 UINT32 Line)
214{
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
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 {
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
277void
278AcpiUtFreeAndTrack (
279 void *Allocation,
281 const char *Module,
282 UINT32 Line)
283{
284 ACPI_DEBUG_MEM_BLOCK *DebugBlock;
286
287
289
290
291 if (NULL == Allocation)
292 {
293 ACPI_ERROR ((Module, Line,
294 "Attempt to delete a NULL address"));
295
297 }
298
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));
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
346AcpiUtFindAllocation (
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
403static ACPI_STATUS
404AcpiUtTrackAllocation (
406 ACPI_SIZE Size,
407 UINT8 AllocType,
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 =
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
485UnlockAndExit:
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
506static ACPI_STATUS
507AcpiUtRemoveAllocation (
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
582void
583AcpiUtDumpAllocationInfo (
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*/
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
643void
644AcpiUtDumpAllocations (
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 {
660 }
661
662 /*
663 * Walk the allocation list.
664 */
666 {
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",
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
783Exit:
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
799}
800
801#endif /* ACPI_DBG_TRACK_ALLOCATIONS */
unsigned short UINT16
unsigned char UINT8
unsigned int UINT32
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_NO_MEMORY
Definition: acexcep.h:112
#define AE_OK
Definition: acexcep.h:97
#define ACPI_MAX_MODULE_NAME
Definition: aclocal.h:1475
#define ACPI_MEM_MALLOC
Definition: aclocal.h:1473
#define ACPI_MTX_MEMORY
Definition: aclocal.h:89
#define ACPI_MEM_CALLOC
Definition: aclocal.h:1474
#define ACPI_GET_DESCRIPTOR_TYPE(d)
Definition: acmacros.h:414
#define ACPI_DESC_TYPE_OPERAND
Definition: acobject.h:576
#define ACPI_DESC_TYPE_NAMED
Definition: acobject.h:577
#define ACPI_DESC_TYPE_CACHED
Definition: acobject.h:563
#define ACPI_DESC_TYPE_PARSER
Definition: acobject.h:575
#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_TRACE_PTR(a, b)
Definition: acoutput.h:481
#define return_ACPI_STATUS(s)
Definition: acoutput.h:496
#define ACPI_FUNCTION_TRACE(a)
Definition: acoutput.h:480
#define ACPI_ERROR(plist)
Definition: acoutput.h:240
#define AE_INFO
Definition: acoutput.h:230
#define ACPI_INFO(plist)
Definition: acoutput.h:237
#define return_VOID
Definition: acoutput.h:495
#define ACPI_FUNCTION_NAME(a)
Definition: acoutput.h:479
void * AcpiOsAllocate(ACPI_SIZE Size)
Definition: osl.c:160
void * AcpiOsAllocateZeroed(ACPI_SIZE Size)
Definition: utalloc.c:68
void AcpiOsFree(void *Memory)
Definition: osl.c:167
void ACPI_INTERNAL_VAR_XFACE AcpiOsPrintf(const char *Format,...)
Definition: osl.c:851
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
const char * AcpiUtGetTypeName(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:250
ACPI_STATUS AcpiUtAcquireMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:256
const char * AcpiUtGetNodeName(void *Object)
Definition: utdecode.c:306
ACPI_STATUS AcpiUtReleaseMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:348
const char * AcpiUtGetDescriptorName(void *Object)
Definition: utdecode.c:382
void AcpiUtDumpBuffer(UINT8 *Buffer, UINT32 Count, UINT32 Display, UINT32 Offset)
Definition: utbuffer.c:71
#define DB_BYTE_DISPLAY
Definition: acutils.h:186
#define NULL
Definition: types.h:112
Status
Definition: gdiplustypes.h:25
static WCHAR Address[46]
Definition: ping.c:68
#define memset(x, y, z)
Definition: compat.h:39
static void Exit(void)
Definition: sock.c:1330
Definition: fatfs.h:173
Definition: ncftp.h:79
ACPI_COMMON_DEBUG_MEM_HEADER UINT64 UserSpace
Definition: aclocal.h:1495
void * ListHead
Definition: actypes.h:1389
_In_ ULONG _In_ PVOID _In_ LONG DescriptorType
Definition: usbdlib.h:160
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342
Allocation
Definition: exfuncs.h:598
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
_In_ ULONG Component
Definition: potypes.h:496
#define const
Definition: zconf.h:233