ReactOS 0.4.15-dev-7934-g1dc8d80
nsutils.c
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Module Name: nsutils - Utilities for accessing ACPI namespace, accessing
4 * parents and siblings and Scope manipulation
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2022, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45#include "acpi.h"
46#include "accommon.h"
47#include "acnamesp.h"
48#include "amlcode.h"
49
50#define _COMPONENT ACPI_NAMESPACE
51 ACPI_MODULE_NAME ("nsutils")
52
53/* Local prototypes */
54
55#ifdef ACPI_OBSOLETE_FUNCTIONS
57AcpiNsFindParentName (
58 ACPI_NAMESPACE_NODE *NodeToSearch);
59#endif
60
61
62/*******************************************************************************
63 *
64 * FUNCTION: AcpiNsPrintNodePathname
65 *
66 * PARAMETERS: Node - Object
67 * Message - Prefix message
68 *
69 * DESCRIPTION: Print an object's full namespace pathname
70 * Manages allocation/freeing of a pathname buffer
71 *
72 ******************************************************************************/
73
74void
77 const char *Message)
78{
81
82
83 if (!Node)
84 {
85 AcpiOsPrintf ("[NULL NAME]");
86 return;
87 }
88
89 /* Convert handle to full pathname and print it (with supplied message) */
90
92
94 if (ACPI_SUCCESS (Status))
95 {
96 if (Message)
97 {
98 AcpiOsPrintf ("%s ", Message);
99 }
100
101 AcpiOsPrintf ("%s", (char *) Buffer.Pointer);
102 ACPI_FREE (Buffer.Pointer);
103 }
104}
105
106
107/*******************************************************************************
108 *
109 * FUNCTION: AcpiNsGetType
110 *
111 * PARAMETERS: Node - Parent Node to be examined
112 *
113 * RETURN: Type field from Node whose handle is passed
114 *
115 * DESCRIPTION: Return the type of a Namespace node
116 *
117 ******************************************************************************/
118
122{
123 ACPI_FUNCTION_TRACE (NsGetType);
124
125
126 if (!Node)
127 {
128 ACPI_WARNING ((AE_INFO, "Null Node parameter"));
130 }
131
132 return_UINT8 (Node->Type);
133}
134
135
136/*******************************************************************************
137 *
138 * FUNCTION: AcpiNsLocal
139 *
140 * PARAMETERS: Type - A namespace object type
141 *
142 * RETURN: LOCAL if names must be found locally in objects of the
143 * passed type, 0 if enclosing scopes should be searched
144 *
145 * DESCRIPTION: Returns scope rule for the given object type.
146 *
147 ******************************************************************************/
148
149UINT32
152{
153 ACPI_FUNCTION_TRACE (NsLocal);
154
155
157 {
158 /* Type code out of range */
159
160 ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type));
162 }
163
165}
166
167
168/*******************************************************************************
169 *
170 * FUNCTION: AcpiNsGetInternalNameLength
171 *
172 * PARAMETERS: Info - Info struct initialized with the
173 * external name pointer.
174 *
175 * RETURN: None
176 *
177 * DESCRIPTION: Calculate the length of the internal (AML) namestring
178 * corresponding to the external (ASL) namestring.
179 *
180 ******************************************************************************/
181
182void
185{
186 const char *NextExternalChar;
187 UINT32 i;
188
189
191
192
193 NextExternalChar = Info->ExternalName;
194 Info->NumCarats = 0;
195 Info->NumSegments = 0;
196 Info->FullyQualified = FALSE;
197
198 /*
199 * For the internal name, the required length is 4 bytes per segment,
200 * plus 1 each for RootPrefix, MultiNamePrefixOp, segment count,
201 * trailing null (which is not really needed, but no there's harm in
202 * putting it there)
203 *
204 * strlen() + 1 covers the first NameSeg, which has no path separator
205 */
206 if (ACPI_IS_ROOT_PREFIX (*NextExternalChar))
207 {
208 Info->FullyQualified = TRUE;
209 NextExternalChar++;
210
211 /* Skip redundant RootPrefix, like \\_SB.PCI0.SBRG.EC0 */
212
213 while (ACPI_IS_ROOT_PREFIX (*NextExternalChar))
214 {
215 NextExternalChar++;
216 }
217 }
218 else
219 {
220 /* Handle Carat prefixes */
221
222 while (ACPI_IS_PARENT_PREFIX (*NextExternalChar))
223 {
224 Info->NumCarats++;
225 NextExternalChar++;
226 }
227 }
228
229 /*
230 * Determine the number of ACPI name "segments" by counting the number of
231 * path separators within the string. Start with one segment since the
232 * segment count is [(# separators) + 1], and zero separators is ok.
233 */
234 if (*NextExternalChar)
235 {
236 Info->NumSegments = 1;
237 for (i = 0; NextExternalChar[i]; i++)
238 {
239 if (ACPI_IS_PATH_SEPARATOR (NextExternalChar[i]))
240 {
241 Info->NumSegments++;
242 }
243 }
244 }
245
246 Info->Length = (ACPI_NAMESEG_SIZE * Info->NumSegments) +
247 4 + Info->NumCarats;
248
249 Info->NextExternalChar = NextExternalChar;
250}
251
252
253/*******************************************************************************
254 *
255 * FUNCTION: AcpiNsBuildInternalName
256 *
257 * PARAMETERS: Info - Info struct fully initialized
258 *
259 * RETURN: Status
260 *
261 * DESCRIPTION: Construct the internal (AML) namestring
262 * corresponding to the external (ASL) namestring.
263 *
264 ******************************************************************************/
265
269{
270 UINT32 NumSegments = Info->NumSegments;
271 char *InternalName = Info->InternalName;
272 const char *ExternalName = Info->NextExternalChar;
273 char *Result = NULL;
274 UINT32 i;
275
276
277 ACPI_FUNCTION_TRACE (NsBuildInternalName);
278
279
280 /* Setup the correct prefixes, counts, and pointers */
281
282 if (Info->FullyQualified)
283 {
284 InternalName[0] = AML_ROOT_PREFIX;
285
286 if (NumSegments <= 1)
287 {
288 Result = &InternalName[1];
289 }
290 else if (NumSegments == 2)
291 {
292 InternalName[1] = AML_DUAL_NAME_PREFIX;
293 Result = &InternalName[2];
294 }
295 else
296 {
297 InternalName[1] = AML_MULTI_NAME_PREFIX;
298 InternalName[2] = (char) NumSegments;
299 Result = &InternalName[3];
300 }
301 }
302 else
303 {
304 /*
305 * Not fully qualified.
306 * Handle Carats first, then append the name segments
307 */
308 i = 0;
309 if (Info->NumCarats)
310 {
311 for (i = 0; i < Info->NumCarats; i++)
312 {
313 InternalName[i] = AML_PARENT_PREFIX;
314 }
315 }
316
317 if (NumSegments <= 1)
318 {
319 Result = &InternalName[i];
320 }
321 else if (NumSegments == 2)
322 {
323 InternalName[i] = AML_DUAL_NAME_PREFIX;
324 Result = &InternalName[(ACPI_SIZE) i+1];
325 }
326 else
327 {
328 InternalName[i] = AML_MULTI_NAME_PREFIX;
329 InternalName[(ACPI_SIZE) i+1] = (char) NumSegments;
330 Result = &InternalName[(ACPI_SIZE) i+2];
331 }
332 }
333
334 /* Build the name (minus path separators) */
335
336 for (; NumSegments; NumSegments--)
337 {
338 for (i = 0; i < ACPI_NAMESEG_SIZE; i++)
339 {
340 if (ACPI_IS_PATH_SEPARATOR (*ExternalName) ||
341 (*ExternalName == 0))
342 {
343 /* Pad the segment with underscore(s) if segment is short */
344
345 Result[i] = '_';
346 }
347 else
348 {
349 /* Convert the character to uppercase and save it */
350
351 Result[i] = (char) toupper ((int) *ExternalName);
352 ExternalName++;
353 }
354 }
355
356 /* Now we must have a path separator, or the pathname is bad */
357
358 if (!ACPI_IS_PATH_SEPARATOR (*ExternalName) &&
359 (*ExternalName != 0))
360 {
362 }
363
364 /* Move on the next segment */
365
366 ExternalName++;
368 }
369
370 /* Terminate the string */
371
372 *Result = 0;
373
374 if (Info->FullyQualified)
375 {
376 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (abs) \"\\%s\"\n",
377 InternalName, InternalName));
378 }
379 else
380 {
381 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (rel) \"%s\"\n",
382 InternalName, InternalName));
383 }
384
386}
387
388
389/*******************************************************************************
390 *
391 * FUNCTION: AcpiNsInternalizeName
392 *
393 * PARAMETERS: *ExternalName - External representation of name
394 * **Converted Name - Where to return the resulting
395 * internal represention of the name
396 *
397 * RETURN: Status
398 *
399 * DESCRIPTION: Convert an external representation (e.g. "\_PR_.CPU0")
400 * to internal form (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
401 *
402 *******************************************************************************/
403
406 const char *ExternalName,
407 char **ConvertedName)
408{
409 char *InternalName;
412
413
414 ACPI_FUNCTION_TRACE (NsInternalizeName);
415
416
417 if ((!ExternalName) ||
418 (*ExternalName == 0) ||
419 (!ConvertedName))
420 {
422 }
423
424 /* Get the length of the new internal name */
425
426 Info.ExternalName = ExternalName;
428
429 /* We need a segment to store the internal name */
430
431 InternalName = ACPI_ALLOCATE_ZEROED (Info.Length);
432 if (!InternalName)
433 {
435 }
436
437 /* Build the name */
438
439 Info.InternalName = InternalName;
441 if (ACPI_FAILURE (Status))
442 {
443 ACPI_FREE (InternalName);
445 }
446
447 *ConvertedName = InternalName;
449}
450
451
452/*******************************************************************************
453 *
454 * FUNCTION: AcpiNsExternalizeName
455 *
456 * PARAMETERS: InternalNameLength - Length of the internal name below
457 * InternalName - Internal representation of name
458 * ConvertedNameLength - Where the length is returned
459 * ConvertedName - Where the resulting external name
460 * is returned
461 *
462 * RETURN: Status
463 *
464 * DESCRIPTION: Convert internal name (e.g. 5c 2f 02 5f 50 52 5f 43 50 55 30)
465 * to its external (printable) form (e.g. "\_PR_.CPU0")
466 *
467 ******************************************************************************/
468
471 UINT32 InternalNameLength,
472 const char *InternalName,
473 UINT32 *ConvertedNameLength,
474 char **ConvertedName)
475{
476 UINT32 NamesIndex = 0;
477 UINT32 NumSegments = 0;
479 UINT32 PrefixLength = 0;
480 UINT32 i = 0;
481 UINT32 j = 0;
482
483
484 ACPI_FUNCTION_TRACE (NsExternalizeName);
485
486
487 if (!InternalNameLength ||
488 !InternalName ||
489 !ConvertedName)
490 {
492 }
493
494 /* Check for a prefix (one '\' | one or more '^') */
495
496 switch (InternalName[0])
497 {
498 case AML_ROOT_PREFIX:
499
500 PrefixLength = 1;
501 break;
502
504
505 for (i = 0; i < InternalNameLength; i++)
506 {
507 if (ACPI_IS_PARENT_PREFIX (InternalName[i]))
508 {
509 PrefixLength = i + 1;
510 }
511 else
512 {
513 break;
514 }
515 }
516
517 if (i == InternalNameLength)
518 {
519 PrefixLength = i;
520 }
521
522 break;
523
524 default:
525
526 break;
527 }
528
529 /*
530 * Check for object names. Note that there could be 0-255 of these
531 * 4-byte elements.
532 */
533 if (PrefixLength < InternalNameLength)
534 {
535 switch (InternalName[PrefixLength])
536 {
538
539 /* <count> 4-byte names */
540
541 NamesIndex = PrefixLength + 2;
542 NumSegments = (UINT8)
543 InternalName[(ACPI_SIZE) PrefixLength + 1];
544 break;
545
547
548 /* Two 4-byte names */
549
550 NamesIndex = PrefixLength + 1;
551 NumSegments = 2;
552 break;
553
554 case 0:
555
556 /* NullName */
557
558 NamesIndex = 0;
559 NumSegments = 0;
560 break;
561
562 default:
563
564 /* one 4-byte name */
565
566 NamesIndex = PrefixLength;
567 NumSegments = 1;
568 break;
569 }
570 }
571
572 /*
573 * Calculate the length of ConvertedName, which equals the length
574 * of the prefix, length of all object names, length of any required
575 * punctuation ('.') between object names, plus the NULL terminator.
576 */
577 RequiredLength = PrefixLength + (4 * NumSegments) +
578 ((NumSegments > 0) ? (NumSegments - 1) : 0) + 1;
579
580 /*
581 * Check to see if we're still in bounds. If not, there's a problem
582 * with InternalName (invalid format).
583 */
584 if (RequiredLength > InternalNameLength)
585 {
586 ACPI_ERROR ((AE_INFO, "Invalid internal name"));
588 }
589
590 /* Build the ConvertedName */
591
592 *ConvertedName = ACPI_ALLOCATE_ZEROED (RequiredLength);
593 if (!(*ConvertedName))
594 {
596 }
597
598 j = 0;
599
600 for (i = 0; i < PrefixLength; i++)
601 {
602 (*ConvertedName)[j++] = InternalName[i];
603 }
604
605 if (NumSegments > 0)
606 {
607 for (i = 0; i < NumSegments; i++)
608 {
609 if (i > 0)
610 {
611 (*ConvertedName)[j++] = '.';
612 }
613
614 /* Copy and validate the 4-char name segment */
615
616 ACPI_COPY_NAMESEG (&(*ConvertedName)[j],
617 &InternalName[NamesIndex]);
618 AcpiUtRepairName (&(*ConvertedName)[j]);
619
621 NamesIndex += ACPI_NAMESEG_SIZE;
622 }
623 }
624
625 if (ConvertedNameLength)
626 {
627 *ConvertedNameLength = (UINT32) RequiredLength;
628 }
629
631}
632
633
634/*******************************************************************************
635 *
636 * FUNCTION: AcpiNsValidateHandle
637 *
638 * PARAMETERS: Handle - Handle to be validated and typecast to a
639 * namespace node.
640 *
641 * RETURN: A pointer to a namespace node
642 *
643 * DESCRIPTION: Convert a namespace handle to a namespace node. Handles special
644 * cases for the root node.
645 *
646 * NOTE: Real integer handles would allow for more verification
647 * and keep all pointers within this subsystem - however this introduces
648 * more overhead and has not been necessary to this point. Drivers
649 * holding handles are typically notified before a node becomes invalid
650 * due to a table unload.
651 *
652 ******************************************************************************/
653
657{
658
660
661
662 /* Parameter validation */
663
664 if ((!Handle) || (Handle == ACPI_ROOT_OBJECT))
665 {
666 return (AcpiGbl_RootNode);
667 }
668
669 /* We can at least attempt to verify the handle */
670
672 {
673 return (NULL);
674 }
675
677}
678
679
680/*******************************************************************************
681 *
682 * FUNCTION: AcpiNsTerminate
683 *
684 * PARAMETERS: none
685 *
686 * RETURN: none
687 *
688 * DESCRIPTION: free memory allocated for namespace and ACPI table storage.
689 *
690 ******************************************************************************/
691
692void
694 void)
695{
697
698
699 ACPI_FUNCTION_TRACE (NsTerminate);
700
701
702 /*
703 * Free the entire namespace -- all nodes and all objects
704 * attached to the nodes
705 */
706 AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
707
708 /* Delete any objects attached to the root node */
709
711 if (ACPI_FAILURE (Status))
712 {
714 }
715
716 AcpiNsDeleteNode (AcpiGbl_RootNode);
718
719 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Namespace freed\n"));
721}
722
723
724/*******************************************************************************
725 *
726 * FUNCTION: AcpiNsOpensScope
727 *
728 * PARAMETERS: Type - A valid namespace type
729 *
730 * RETURN: NEWSCOPE if the passed type "opens a name scope" according
731 * to the ACPI specification, else 0
732 *
733 ******************************************************************************/
734
735UINT32
738{
740
741
743 {
744 /* type code out of range */
745
746 ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type));
747 return (ACPI_NS_NORMAL);
748 }
749
751}
752
753
754/*******************************************************************************
755 *
756 * FUNCTION: AcpiNsGetNodeUnlocked
757 *
758 * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
759 * \ (backslash) and ^ (carat) prefixes, and the
760 * . (period) to separate segments are supported.
761 * PrefixNode - Root of subtree to be searched, or NS_ALL for the
762 * root of the name space. If Name is fully
763 * qualified (first INT8 is '\'), the passed value
764 * of Scope will not be accessed.
765 * Flags - Used to indicate whether to perform upsearch or
766 * not.
767 * ReturnNode - Where the Node is returned
768 *
769 * DESCRIPTION: Look up a name relative to a given scope and return the
770 * corresponding Node. NOTE: Scope can be null.
771 *
772 * MUTEX: Doesn't locks namespace
773 *
774 ******************************************************************************/
775
778 ACPI_NAMESPACE_NODE *PrefixNode,
779 const char *Pathname,
781 ACPI_NAMESPACE_NODE **ReturnNode)
782{
783 ACPI_GENERIC_STATE ScopeInfo;
785 char *InternalPath;
786
787
788 ACPI_FUNCTION_TRACE_PTR (NsGetNodeUnlocked, ACPI_CAST_PTR (char, Pathname));
789
790
791 /* Simplest case is a null pathname */
792
793 if (!Pathname)
794 {
795 *ReturnNode = PrefixNode;
796 if (!PrefixNode)
797 {
798 *ReturnNode = AcpiGbl_RootNode;
799 }
800
802 }
803
804 /* Quick check for a reference to the root */
805
806 if (ACPI_IS_ROOT_PREFIX (Pathname[0]) && (!Pathname[1]))
807 {
808 *ReturnNode = AcpiGbl_RootNode;
810 }
811
812 /* Convert path to internal representation */
813
815 if (ACPI_FAILURE (Status))
816 {
818 }
819
820 /* Setup lookup scope (search starting point) */
821
822 ScopeInfo.Scope.Node = PrefixNode;
823
824 /* Lookup the name in the namespace */
825
828 NULL, ReturnNode);
829 if (ACPI_FAILURE (Status))
830 {
831 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s, %s\n",
833 }
834
837}
838
839
840/*******************************************************************************
841 *
842 * FUNCTION: AcpiNsGetNode
843 *
844 * PARAMETERS: *Pathname - Name to be found, in external (ASL) format. The
845 * \ (backslash) and ^ (carat) prefixes, and the
846 * . (period) to separate segments are supported.
847 * PrefixNode - Root of subtree to be searched, or NS_ALL for the
848 * root of the name space. If Name is fully
849 * qualified (first INT8 is '\'), the passed value
850 * of Scope will not be accessed.
851 * Flags - Used to indicate whether to perform upsearch or
852 * not.
853 * ReturnNode - Where the Node is returned
854 *
855 * DESCRIPTION: Look up a name relative to a given scope and return the
856 * corresponding Node. NOTE: Scope can be null.
857 *
858 * MUTEX: Locks namespace
859 *
860 ******************************************************************************/
861
864 ACPI_NAMESPACE_NODE *PrefixNode,
865 const char *Pathname,
867 ACPI_NAMESPACE_NODE **ReturnNode)
868{
870
871
873
874
876 if (ACPI_FAILURE (Status))
877 {
879 }
880
882 Flags, ReturnNode);
883
886}
unsigned char UINT8
unsigned int UINT32
Type
Definition: Type.h:7
int toupper(int c)
Definition: utclib.c:881
#define AE_BAD_PATHNAME
Definition: acexcep.h:153
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
#define AE_BAD_PARAMETER
Definition: acexcep.h:151
#define AE_NO_MEMORY
Definition: acexcep.h:112
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
#define AE_OK
Definition: acexcep.h:97
const UINT8 AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES]
Definition: utdecode.c:57
@ ACPI_IMODE_EXECUTE
Definition: aclocal.h:169
#define ACPI_MTX_NAMESPACE
Definition: aclocal.h:85
#define ACPI_IS_PARENT_PREFIX(c)
Definition: acmacros.h:402
#define ACPI_IS_PATH_SEPARATOR(c)
Definition: acmacros.h:403
#define ACPI_GET_DESCRIPTOR_TYPE(d)
Definition: acmacros.h:414
#define ACPI_IS_ROOT_PREFIX(c)
Definition: acmacros.h:401
ACPI_STATUS AcpiNsLookup(ACPI_GENERIC_STATE *ScopeInfo, char *Name, ACPI_OBJECT_TYPE Type, ACPI_INTERPRETER_MODE InterpreterMode, UINT32 Flags, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE **RetNode)
Definition: nsaccess.c:328
void AcpiNsDeleteNamespaceSubtree(ACPI_NAMESPACE_NODE *ParentHandle)
Definition: nsalloc.c:399
void AcpiNsDeleteNode(ACPI_NAMESPACE_NODE *Node)
Definition: nsalloc.c:117
#define ACPI_NS_NEWSCOPE
Definition: acnamesp.h:57
ACPI_STATUS AcpiNsHandleToPathname(ACPI_HANDLE TargetHandle, ACPI_BUFFER *Buffer, BOOLEAN NoTrailing)
Definition: nsnames.c:187
#define ACPI_NS_NORMAL
Definition: acnamesp.h:56
#define ACPI_NS_LOCAL
Definition: acnamesp.h:58
#define ACPI_NS_DONT_OPEN_SCOPE
Definition: acnamesp.h:64
#define ACPI_DESC_TYPE_NAMED
Definition: acobject.h:577
#define ACPI_DEBUG_PRINT(pl)
Definition: acoutput.h:475
#define return_UINT8(s)
Definition: acoutput.h:500
#define ACPI_MODULE_NAME(Name)
Definition: acoutput.h:216
#define ACPI_WARNING(plist)
Definition: acoutput.h:238
#define ACPI_FUNCTION_ENTRY()
Definition: acoutput.h:484
#define ACPI_DB_EXEC
Definition: acoutput.h:165
#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 return_VOID
Definition: acoutput.h:495
#define ACPI_DB_INFO
Definition: acoutput.h:153
#define return_UINT32(s)
Definition: acoutput.h:501
void ACPI_INTERNAL_VAR_XFACE AcpiOsPrintf(const char *Format,...)
Definition: osl.c:851
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING Pathname
Definition: acpixf.h:704
#define ACPI_COPY_NAMESEG(dest, src)
Definition: actypes.h:565
UINT32 ACPI_OBJECT_TYPE
Definition: actypes.h:685
#define ACPI_FREE(a)
Definition: actypes.h:386
#define ACPI_TYPE_ANY
Definition: actypes.h:687
UINT32 ACPI_STATUS
Definition: actypes.h:460
#define ACPI_CAST_PTR(t, p)
Definition: actypes.h:544
#define ACPI_ALLOCATE_LOCAL_BUFFER
Definition: actypes.h:1047
#define ACPI_ALLOCATE_ZEROED(a)
Definition: actypes.h:385
UINT32 ACPI_NAME
Definition: actypes.h:461
#define ACPI_ROOT_OBJECT
Definition: actypes.h:500
#define ACPI_TYPE_LOCAL_MAX
Definition: actypes.h:738
#define ACPI_NAMESEG_SIZE
Definition: actypes.h:415
ACPI_STATUS AcpiUtAcquireMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:256
void AcpiUtRepairName(char *Name)
Definition: utstring.c:183
ACPI_STATUS AcpiUtReleaseMutex(ACPI_MUTEX_HANDLE MutexId)
Definition: utmutex.c:348
BOOLEAN AcpiUtValidObjectType(ACPI_OBJECT_TYPE Type)
Definition: utdecode.c:681
#define AML_PARENT_PREFIX
Definition: amlcode.h:70
#define AML_DUAL_NAME_PREFIX
Definition: amlcode.h:66
#define AML_MULTI_NAME_PREFIX
Definition: amlcode.h:67
#define AML_ROOT_PREFIX
Definition: amlcode.h:69
@ InternalPath
Definition: bl.h:284
Definition: bufpool.h:45
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
unsigned char
Definition: typeof.h:29
static const WCHAR Message[]
Definition: register.c:74
ULONG Handle
Definition: gdb_input.c:15
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
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 GLint GLint j
Definition: glfuncs.h:250
ACPI_STATUS AcpiNsInternalizeName(const char *ExternalName, char **ConvertedName)
Definition: nsutils.c:405
ACPI_NAMESPACE_NODE * AcpiNsValidateHandle(ACPI_HANDLE Handle)
Definition: nsutils.c:655
ACPI_OBJECT_TYPE AcpiNsGetType(ACPI_NAMESPACE_NODE *Node)
Definition: nsutils.c:120
void AcpiNsGetInternalNameLength(ACPI_NAMESTRING_INFO *Info)
Definition: nsutils.c:183
ACPI_STATUS AcpiNsGetNodeUnlocked(ACPI_NAMESPACE_NODE *PrefixNode, const char *Pathname, UINT32 Flags, ACPI_NAMESPACE_NODE **ReturnNode)
Definition: nsutils.c:777
ACPI_STATUS AcpiNsGetNode(ACPI_NAMESPACE_NODE *PrefixNode, const char *Pathname, UINT32 Flags, ACPI_NAMESPACE_NODE **ReturnNode)
Definition: nsutils.c:863
ACPI_STATUS AcpiNsExternalizeName(UINT32 InternalNameLength, const char *InternalName, UINT32 *ConvertedNameLength, char **ConvertedName)
Definition: nsutils.c:470
void AcpiNsPrintNodePathname(ACPI_NAMESPACE_NODE *Node, const char *Message)
Definition: nsutils.c:75
UINT32 AcpiNsLocal(ACPI_OBJECT_TYPE Type)
Definition: nsutils.c:150
void AcpiNsTerminate(void)
Definition: nsutils.c:693
ACPI_STATUS AcpiNsBuildInternalName(ACPI_NAMESTRING_INFO *Info)
Definition: nsutils.c:267
UINT32 AcpiNsOpensScope(ACPI_OBJECT_TYPE Type)
Definition: nsutils.c:736
ACPI_STATE_COMMON ACPI_NAMESPACE_NODE * Node
Definition: aclocal.h:740
ACPI_SCOPE_STATE Scope
Definition: aclocal.h:825
Definition: dlist.c:348
const char * AcpiFormatException(ACPI_STATUS Status)
Definition: utexcep.c:70
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
_In_ ULONG _Out_opt_ PULONG RequiredLength
Definition: wmifuncs.h:30
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170