xref: /freebsd/sys/contrib/dev/acpica/components/debugger/dbnames.c (revision 833a452e9f082a7982a31c21f0da437dbbe0a39d)
1 /*******************************************************************************
2  *
3  * Module Name: dbnames - Debugger commands for the acpi namespace
4  *
5  ******************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88  * PARTICULAR PURPOSE.
89  *
90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97  * LIMITED REMEDY.
98  *
99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
100  * software or system incorporating such software without first obtaining any
101  * required license or other approval from the U. S. Department of Commerce or
102  * any other agency or department of the United States Government. In the
103  * event Licensee exports any such software from the United States or
104  * re-exports any such software from a foreign destination, Licensee shall
105  * ensure that the distribution and export/re-export of the software is in
106  * compliance with all laws, regulations, orders, or other restrictions of the
107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108  * any of its subsidiaries will export/re-export any technical data, process,
109  * software, or service, directly or indirectly, to any country for which the
110  * United States government or any agency thereof requires an export license,
111  * other governmental approval, or letter of assurance, without first obtaining
112  * such license, approval or letter.
113  *
114  *****************************************************************************
115  *
116  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #include <contrib/dev/acpica/include/acpi.h>
153 #include <contrib/dev/acpica/include/accommon.h>
154 #include <contrib/dev/acpica/include/acnamesp.h>
155 #include <contrib/dev/acpica/include/acdebug.h>
156 #include <contrib/dev/acpica/include/acpredef.h>
157 #include <contrib/dev/acpica/include/acinterp.h>
158 
159 
160 #define _COMPONENT          ACPI_CA_DEBUGGER
161         ACPI_MODULE_NAME    ("dbnames")
162 
163 
164 /* Local prototypes */
165 
166 static ACPI_STATUS
167 AcpiDbWalkAndMatchName (
168     ACPI_HANDLE             ObjHandle,
169     UINT32                  NestingLevel,
170     void                    *Context,
171     void                    **ReturnValue);
172 
173 static ACPI_STATUS
174 AcpiDbWalkForPredefinedNames (
175     ACPI_HANDLE             ObjHandle,
176     UINT32                  NestingLevel,
177     void                    *Context,
178     void                    **ReturnValue);
179 
180 static ACPI_STATUS
181 AcpiDbWalkForSpecificObjects (
182     ACPI_HANDLE             ObjHandle,
183     UINT32                  NestingLevel,
184     void                    *Context,
185     void                    **ReturnValue);
186 
187 static ACPI_STATUS
188 AcpiDbWalkForObjectCounts (
189     ACPI_HANDLE             ObjHandle,
190     UINT32                  NestingLevel,
191     void                    *Context,
192     void                    **ReturnValue);
193 
194 static ACPI_STATUS
195 AcpiDbIntegrityWalk (
196     ACPI_HANDLE             ObjHandle,
197     UINT32                  NestingLevel,
198     void                    *Context,
199     void                    **ReturnValue);
200 
201 static ACPI_STATUS
202 AcpiDbWalkForReferences (
203     ACPI_HANDLE             ObjHandle,
204     UINT32                  NestingLevel,
205     void                    *Context,
206     void                    **ReturnValue);
207 
208 static ACPI_STATUS
209 AcpiDbBusWalk (
210     ACPI_HANDLE             ObjHandle,
211     UINT32                  NestingLevel,
212     void                    *Context,
213     void                    **ReturnValue);
214 
215 /*
216  * Arguments for the Objects command
217  * These object types map directly to the ACPI_TYPES
218  */
219 static ACPI_DB_ARGUMENT_INFO    AcpiDbObjectTypes [] =
220 {
221     {"ANY"},
222     {"INTEGERS"},
223     {"STRINGS"},
224     {"BUFFERS"},
225     {"PACKAGES"},
226     {"FIELDS"},
227     {"DEVICES"},
228     {"EVENTS"},
229     {"METHODS"},
230     {"MUTEXES"},
231     {"REGIONS"},
232     {"POWERRESOURCES"},
233     {"PROCESSORS"},
234     {"THERMALZONES"},
235     {"BUFFERFIELDS"},
236     {"DDBHANDLES"},
237     {"DEBUG"},
238     {"REGIONFIELDS"},
239     {"BANKFIELDS"},
240     {"INDEXFIELDS"},
241     {"REFERENCES"},
242     {"ALIASES"},
243     {"METHODALIASES"},
244     {"NOTIFY"},
245     {"ADDRESSHANDLER"},
246     {"RESOURCE"},
247     {"RESOURCEFIELD"},
248     {"SCOPES"},
249     {NULL}           /* Must be null terminated */
250 };
251 
252 
253 /*******************************************************************************
254  *
255  * FUNCTION:    AcpiDbSetScope
256  *
257  * PARAMETERS:  Name                - New scope path
258  *
259  * RETURN:      Status
260  *
261  * DESCRIPTION: Set the "current scope" as maintained by this utility.
262  *              The scope is used as a prefix to ACPI paths.
263  *
264  ******************************************************************************/
265 
266 void
267 AcpiDbSetScope (
268     char                    *Name)
269 {
270     ACPI_STATUS             Status;
271     ACPI_NAMESPACE_NODE     *Node;
272 
273 
274     if (!Name || Name[0] == 0)
275     {
276         AcpiOsPrintf ("Current scope: %s\n", AcpiGbl_DbScopeBuf);
277         return;
278     }
279 
280     AcpiDbPrepNamestring (Name);
281 
282     if (ACPI_IS_ROOT_PREFIX (Name[0]))
283     {
284         /* Validate new scope from the root */
285 
286         Status = AcpiNsGetNode (AcpiGbl_RootNode, Name,
287             ACPI_NS_NO_UPSEARCH, &Node);
288         if (ACPI_FAILURE (Status))
289         {
290             goto ErrorExit;
291         }
292 
293         AcpiGbl_DbScopeBuf[0] = 0;
294     }
295     else
296     {
297         /* Validate new scope relative to old scope */
298 
299         Status = AcpiNsGetNode (AcpiGbl_DbScopeNode, Name,
300             ACPI_NS_NO_UPSEARCH, &Node);
301         if (ACPI_FAILURE (Status))
302         {
303             goto ErrorExit;
304         }
305     }
306 
307     /* Build the final pathname */
308 
309     if (AcpiUtSafeStrcat (AcpiGbl_DbScopeBuf, sizeof (AcpiGbl_DbScopeBuf),
310         Name))
311     {
312         Status = AE_BUFFER_OVERFLOW;
313         goto ErrorExit;
314     }
315 
316     if (AcpiUtSafeStrcat (AcpiGbl_DbScopeBuf, sizeof (AcpiGbl_DbScopeBuf),
317             "\\"))
318     {
319         Status = AE_BUFFER_OVERFLOW;
320         goto ErrorExit;
321     }
322 
323     AcpiGbl_DbScopeNode = Node;
324     AcpiOsPrintf ("New scope: %s\n", AcpiGbl_DbScopeBuf);
325     return;
326 
327 ErrorExit:
328 
329     AcpiOsPrintf ("Could not attach scope: %s, %s\n",
330         Name, AcpiFormatException (Status));
331 }
332 
333 
334 /*******************************************************************************
335  *
336  * FUNCTION:    AcpiDbDumpNamespace
337  *
338  * PARAMETERS:  StartArg        - Node to begin namespace dump
339  *              DepthArg        - Maximum tree depth to be dumped
340  *
341  * RETURN:      None
342  *
343  * DESCRIPTION: Dump entire namespace or a subtree. Each node is displayed
344  *              with type and other information.
345  *
346  ******************************************************************************/
347 
348 void
349 AcpiDbDumpNamespace (
350     char                    *StartArg,
351     char                    *DepthArg)
352 {
353     ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
354     UINT32                  MaxDepth = ACPI_UINT32_MAX;
355 
356 
357     /* No argument given, just start at the root and dump entire namespace */
358 
359     if (StartArg)
360     {
361         SubtreeEntry = AcpiDbConvertToNode (StartArg);
362         if (!SubtreeEntry)
363         {
364             return;
365         }
366 
367         /* Now we can check for the depth argument */
368 
369         if (DepthArg)
370         {
371             MaxDepth = strtoul (DepthArg, NULL, 0);
372         }
373     }
374 
375     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
376 
377     if (((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Parent)
378     {
379         AcpiOsPrintf ("ACPI Namespace (from %4.4s (%p) subtree):\n",
380             ((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Name.Ascii, SubtreeEntry);
381     }
382     else
383     {
384         AcpiOsPrintf ("ACPI Namespace (from %s):\n",
385             ACPI_NAMESPACE_ROOT);
386     }
387 
388     /* Display the subtree */
389 
390     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
391     AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,
392         ACPI_OWNER_ID_MAX, SubtreeEntry);
393     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
394 }
395 
396 
397 /*******************************************************************************
398  *
399  * FUNCTION:    AcpiDbDumpNamespacePaths
400  *
401  * PARAMETERS:  None
402  *
403  * RETURN:      None
404  *
405  * DESCRIPTION: Dump entire namespace with full object pathnames and object
406  *              type information. Alternative to "namespace" command.
407  *
408  ******************************************************************************/
409 
410 void
411 AcpiDbDumpNamespacePaths (
412     void)
413 {
414 
415     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
416     AcpiOsPrintf ("ACPI Namespace (from root):\n");
417 
418     /* Display the entire namespace */
419 
420     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
421     AcpiNsDumpObjectPaths (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY,
422         ACPI_UINT32_MAX, ACPI_OWNER_ID_MAX, AcpiGbl_RootNode);
423 
424     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
425 }
426 
427 
428 /*******************************************************************************
429  *
430  * FUNCTION:    AcpiDbDumpNamespaceByOwner
431  *
432  * PARAMETERS:  OwnerArg        - Owner ID whose nodes will be displayed
433  *              DepthArg        - Maximum tree depth to be dumped
434  *
435  * RETURN:      None
436  *
437  * DESCRIPTION: Dump elements of the namespace that are owned by the OwnerId.
438  *
439  ******************************************************************************/
440 
441 void
442 AcpiDbDumpNamespaceByOwner (
443     char                    *OwnerArg,
444     char                    *DepthArg)
445 {
446     ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
447     UINT32                  MaxDepth = ACPI_UINT32_MAX;
448     ACPI_OWNER_ID           OwnerId;
449 
450 
451     OwnerId = (ACPI_OWNER_ID) strtoul (OwnerArg, NULL, 0);
452 
453     /* Now we can check for the depth argument */
454 
455     if (DepthArg)
456     {
457         MaxDepth = strtoul (DepthArg, NULL, 0);
458     }
459 
460     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
461     AcpiOsPrintf ("ACPI Namespace by owner %X:\n", OwnerId);
462 
463     /* Display the subtree */
464 
465     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
466     AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,
467         OwnerId, SubtreeEntry);
468     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
469 }
470 
471 
472 /*******************************************************************************
473  *
474  * FUNCTION:    AcpiDbWalkAndMatchName
475  *
476  * PARAMETERS:  Callback from WalkNamespace
477  *
478  * RETURN:      Status
479  *
480  * DESCRIPTION: Find a particular name/names within the namespace. Wildcards
481  *              are supported -- '?' matches any character.
482  *
483  ******************************************************************************/
484 
485 static ACPI_STATUS
486 AcpiDbWalkAndMatchName (
487     ACPI_HANDLE             ObjHandle,
488     UINT32                  NestingLevel,
489     void                    *Context,
490     void                    **ReturnValue)
491 {
492     ACPI_STATUS             Status;
493     char                    *RequestedName = (char *) Context;
494     UINT32                  i;
495     ACPI_BUFFER             Buffer;
496     ACPI_WALK_INFO          Info;
497 
498 
499     /* Check for a name match */
500 
501     for (i = 0; i < 4; i++)
502     {
503         /* Wildcard support */
504 
505         if ((RequestedName[i] != '?') &&
506             (RequestedName[i] != ((ACPI_NAMESPACE_NODE *)
507                 ObjHandle)->Name.Ascii[i]))
508         {
509             /* No match, just exit */
510 
511             return (AE_OK);
512         }
513     }
514 
515     /* Get the full pathname to this object */
516 
517     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
518     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, TRUE);
519     if (ACPI_FAILURE (Status))
520     {
521         AcpiOsPrintf ("Could Not get pathname for object %p\n",
522             ObjHandle);
523     }
524     else
525     {
526         Info.Count = 0;
527         Info.OwnerId = ACPI_OWNER_ID_MAX;
528         Info.DebugLevel = ACPI_UINT32_MAX;
529         Info.DisplayType = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT;
530 
531         AcpiOsPrintf ("%32s", (char *) Buffer.Pointer);
532         (void) AcpiNsDumpOneObject (ObjHandle, NestingLevel, &Info, NULL);
533         ACPI_FREE (Buffer.Pointer);
534     }
535 
536     return (AE_OK);
537 }
538 
539 
540 /*******************************************************************************
541  *
542  * FUNCTION:    AcpiDbFindNameInNamespace
543  *
544  * PARAMETERS:  NameArg         - The 4-character ACPI name to find.
545  *                                wildcards are supported.
546  *
547  * RETURN:      None
548  *
549  * DESCRIPTION: Search the namespace for a given name (with wildcards)
550  *
551  ******************************************************************************/
552 
553 ACPI_STATUS
554 AcpiDbFindNameInNamespace (
555     char                    *NameArg)
556 {
557     char                    AcpiName[5] = "____";
558     char                    *AcpiNamePtr = AcpiName;
559 
560 
561     if (strlen (NameArg) > ACPI_NAMESEG_SIZE)
562     {
563         AcpiOsPrintf ("Name must be no longer than 4 characters\n");
564         return (AE_OK);
565     }
566 
567     /* Pad out name with underscores as necessary to create a 4-char name */
568 
569     AcpiUtStrupr (NameArg);
570     while (*NameArg)
571     {
572         *AcpiNamePtr = *NameArg;
573         AcpiNamePtr++;
574         NameArg++;
575     }
576 
577     /* Walk the namespace from the root */
578 
579     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
580         ACPI_UINT32_MAX, AcpiDbWalkAndMatchName, NULL, AcpiName, NULL);
581 
582     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
583     return (AE_OK);
584 }
585 
586 
587 /*******************************************************************************
588  *
589  * FUNCTION:    AcpiDbWalkForPredefinedNames
590  *
591  * PARAMETERS:  Callback from WalkNamespace
592  *
593  * RETURN:      Status
594  *
595  * DESCRIPTION: Detect and display predefined ACPI names (names that start with
596  *              an underscore)
597  *
598  ******************************************************************************/
599 
600 static ACPI_STATUS
601 AcpiDbWalkForPredefinedNames (
602     ACPI_HANDLE             ObjHandle,
603     UINT32                  NestingLevel,
604     void                    *Context,
605     void                    **ReturnValue)
606 {
607     ACPI_NAMESPACE_NODE         *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
608     UINT32                      *Count = (UINT32 *) Context;
609     const ACPI_PREDEFINED_INFO  *Predefined;
610     const ACPI_PREDEFINED_INFO  *Package = NULL;
611     char                        *Pathname;
612     char                        StringBuffer[48];
613 
614 
615     Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii);
616     if (!Predefined)
617     {
618         return (AE_OK);
619     }
620 
621     Pathname = AcpiNsGetNormalizedPathname (Node, TRUE);
622     if (!Pathname)
623     {
624         return (AE_OK);
625     }
626 
627     /* If method returns a package, the info is in the next table entry */
628 
629     if (Predefined->Info.ExpectedBtypes & ACPI_RTYPE_PACKAGE)
630     {
631         Package = Predefined + 1;
632     }
633 
634     AcpiUtGetExpectedReturnTypes (StringBuffer,
635         Predefined->Info.ExpectedBtypes);
636 
637     AcpiOsPrintf ("%-32s Arguments %X, Return Types: %s", Pathname,
638         METHOD_GET_ARG_COUNT (Predefined->Info.ArgumentList),
639         StringBuffer);
640 
641     if (Package)
642     {
643         AcpiOsPrintf (" (PkgType %2.2X, ObjType %2.2X, Count %2.2X)",
644             Package->RetInfo.Type, Package->RetInfo.ObjectType1,
645             Package->RetInfo.Count1);
646     }
647 
648     AcpiOsPrintf("\n");
649 
650     /* Check that the declared argument count matches the ACPI spec */
651 
652     AcpiNsCheckAcpiCompliance (Pathname, Node, Predefined);
653 
654     ACPI_FREE (Pathname);
655     (*Count)++;
656     return (AE_OK);
657 }
658 
659 
660 /*******************************************************************************
661  *
662  * FUNCTION:    AcpiDbCheckPredefinedNames
663  *
664  * PARAMETERS:  None
665  *
666  * RETURN:      None
667  *
668  * DESCRIPTION: Validate all predefined names in the namespace
669  *
670  ******************************************************************************/
671 
672 void
673 AcpiDbCheckPredefinedNames (
674     void)
675 {
676     UINT32                  Count = 0;
677 
678 
679     /* Search all nodes in namespace */
680 
681     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
682         ACPI_UINT32_MAX, AcpiDbWalkForPredefinedNames,
683         NULL, (void *) &Count, NULL);
684 
685     AcpiOsPrintf ("Found %u predefined names in the namespace\n", Count);
686 }
687 
688 
689 /*******************************************************************************
690  *
691  * FUNCTION:    AcpiDbWalkForObjectCounts
692  *
693  * PARAMETERS:  Callback from WalkNamespace
694  *
695  * RETURN:      Status
696  *
697  * DESCRIPTION: Display short info about objects in the namespace
698  *
699  ******************************************************************************/
700 
701 static ACPI_STATUS
702 AcpiDbWalkForObjectCounts (
703     ACPI_HANDLE             ObjHandle,
704     UINT32                  NestingLevel,
705     void                    *Context,
706     void                    **ReturnValue)
707 {
708     ACPI_OBJECT_INFO        *Info = (ACPI_OBJECT_INFO *) Context;
709     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
710 
711 
712     if (Node->Type > ACPI_TYPE_NS_NODE_MAX)
713     {
714         AcpiOsPrintf ("[%4.4s]: Unknown object type %X\n",
715             Node->Name.Ascii, Node->Type);
716     }
717     else
718     {
719         Info->Types[Node->Type]++;
720     }
721 
722     return (AE_OK);
723 }
724 
725 
726 /*******************************************************************************
727  *
728  * FUNCTION:    AcpiDbWalkForFields
729  *
730  * PARAMETERS:  Callback from WalkNamespace
731  *
732  * RETURN:      Status
733  *
734  * DESCRIPTION: Display short info about objects in the namespace
735  *
736  ******************************************************************************/
737 
738 static ACPI_STATUS
739 AcpiDbWalkForFields (
740     ACPI_HANDLE             ObjHandle,
741     UINT32                  NestingLevel,
742     void                    *Context,
743     void                    **ReturnValue)
744 {
745     ACPI_OBJECT             *RetValue;
746     ACPI_REGION_WALK_INFO   *Info = (ACPI_REGION_WALK_INFO *) Context;
747     ACPI_BUFFER             Buffer;
748     ACPI_STATUS             Status;
749     ACPI_NAMESPACE_NODE     *Node = AcpiNsValidateHandle (ObjHandle);
750 
751 
752     if (!Node)
753     {
754        return (AE_OK);
755     }
756     if (Node->Object->Field.RegionObj->Region.SpaceId != Info->AddressSpaceId)
757     {
758        return (AE_OK);
759     }
760 
761     Info->Count++;
762 
763     /* Get and display the full pathname to this object */
764 
765     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
766     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, TRUE);
767     if (ACPI_FAILURE (Status))
768     {
769         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
770         return (AE_OK);
771     }
772 
773     AcpiOsPrintf ("%s ", (char *) Buffer.Pointer);
774     ACPI_FREE (Buffer.Pointer);
775 
776     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
777     AcpiEvaluateObject (ObjHandle, NULL, NULL, &Buffer);
778 
779     /*
780      * Since this is a field unit, surround the output in braces
781      */
782     AcpiOsPrintf ("{");
783 
784     RetValue = (ACPI_OBJECT *) Buffer.Pointer;
785     switch (RetValue->Type)
786     {
787         case ACPI_TYPE_INTEGER:
788 
789             AcpiOsPrintf ("%8.8X%8.8X", ACPI_FORMAT_UINT64 (RetValue->Integer.Value));
790             break;
791 
792         case ACPI_TYPE_BUFFER:
793 
794             AcpiUtDumpBuffer (RetValue->Buffer.Pointer,
795                 RetValue->Buffer.Length, DB_DISPLAY_DATA_ONLY | DB_BYTE_DISPLAY, 0);
796             break;
797 
798         default:
799 
800             break;
801     }
802 
803     AcpiOsPrintf ("}\n");
804 
805     ACPI_FREE (Buffer.Pointer);
806     return (AE_OK);
807 }
808 
809 
810 /*******************************************************************************
811  *
812  * FUNCTION:    AcpiDbWalkForSpecificObjects
813  *
814  * PARAMETERS:  Callback from WalkNamespace
815  *
816  * RETURN:      Status
817  *
818  * DESCRIPTION: Display short info about objects in the namespace
819  *
820  ******************************************************************************/
821 
822 static ACPI_STATUS
823 AcpiDbWalkForSpecificObjects (
824     ACPI_HANDLE             ObjHandle,
825     UINT32                  NestingLevel,
826     void                    *Context,
827     void                    **ReturnValue)
828 {
829     ACPI_WALK_INFO          *Info = (ACPI_WALK_INFO *) Context;
830     ACPI_BUFFER             Buffer;
831     ACPI_STATUS             Status;
832 
833 
834     Info->Count++;
835 
836     /* Get and display the full pathname to this object */
837 
838     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
839     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, TRUE);
840     if (ACPI_FAILURE (Status))
841     {
842         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
843         return (AE_OK);
844     }
845 
846     AcpiOsPrintf ("%32s", (char *) Buffer.Pointer);
847     ACPI_FREE (Buffer.Pointer);
848 
849     /* Dump short info about the object */
850 
851     (void) AcpiNsDumpOneObject (ObjHandle, NestingLevel, Info, NULL);
852     return (AE_OK);
853 }
854 
855 
856 /*******************************************************************************
857  *
858  * FUNCTION:    AcpiDbDisplayObjects
859  *
860  * PARAMETERS:  ObjTypeArg          - Type of object to display
861  *              DisplayCountArg     - Max depth to display
862  *
863  * RETURN:      None
864  *
865  * DESCRIPTION: Display objects in the namespace of the requested type
866  *
867  ******************************************************************************/
868 
869 ACPI_STATUS
870 AcpiDbDisplayObjects (
871     char                    *ObjTypeArg,
872     char                    *DisplayCountArg)
873 {
874     ACPI_WALK_INFO          Info;
875     ACPI_OBJECT_TYPE        Type;
876     ACPI_OBJECT_INFO        *ObjectInfo;
877     UINT32                  i;
878     UINT32                  TotalObjects = 0;
879 
880 
881     /* No argument means display summary/count of all object types */
882 
883     if (!ObjTypeArg)
884     {
885         ObjectInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_OBJECT_INFO));
886 
887         /* Walk the namespace from the root */
888 
889         (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
890             ACPI_UINT32_MAX, AcpiDbWalkForObjectCounts, NULL,
891             (void *) ObjectInfo, NULL);
892 
893         AcpiOsPrintf ("\nSummary of namespace objects:\n\n");
894 
895         for (i = 0; i < ACPI_TOTAL_TYPES; i++)
896         {
897             AcpiOsPrintf ("%8u   %s\n", ObjectInfo->Types[i],
898                 AcpiUtGetTypeName (i));
899 
900             TotalObjects += ObjectInfo->Types[i];
901         }
902 
903         AcpiOsPrintf ("\n%8u   Total namespace objects\n\n",
904             TotalObjects);
905 
906         ACPI_FREE (ObjectInfo);
907         return (AE_OK);
908     }
909 
910     /* Get the object type */
911 
912     Type = AcpiDbMatchArgument (ObjTypeArg, AcpiDbObjectTypes);
913     if (Type == ACPI_TYPE_NOT_FOUND)
914     {
915         AcpiOsPrintf ("Invalid or unsupported argument\n");
916         return (AE_OK);
917     }
918 
919     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
920     AcpiOsPrintf (
921         "Objects of type [%s] defined in the current ACPI Namespace:\n",
922         AcpiUtGetTypeName (Type));
923 
924     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
925 
926     Info.Count = 0;
927     Info.OwnerId = ACPI_OWNER_ID_MAX;
928     Info.DebugLevel = ACPI_UINT32_MAX;
929     Info.DisplayType = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT;
930 
931     /* Walk the namespace from the root */
932 
933     (void) AcpiWalkNamespace (Type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
934         AcpiDbWalkForSpecificObjects, NULL, (void *) &Info, NULL);
935 
936     AcpiOsPrintf (
937         "\nFound %u objects of type [%s] in the current ACPI Namespace\n",
938         Info.Count, AcpiUtGetTypeName (Type));
939 
940     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
941     return (AE_OK);
942 }
943 
944 
945 /*******************************************************************************
946  *
947  * FUNCTION:    AcpiDbDisplayFields
948  *
949  * PARAMETERS:  ObjTypeArg          - Type of object to display
950  *              DisplayCountArg     - Max depth to display
951  *
952  * RETURN:      None
953  *
954  * DESCRIPTION: Display objects in the namespace of the requested type
955  *
956  ******************************************************************************/
957 
958 ACPI_STATUS
959 AcpiDbDisplayFields (
960     UINT32                  AddressSpaceId)
961 {
962     ACPI_REGION_WALK_INFO  Info;
963 
964 
965     Info.Count = 0;
966     Info.OwnerId = ACPI_OWNER_ID_MAX;
967     Info.DebugLevel = ACPI_UINT32_MAX;
968     Info.DisplayType = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT;
969     Info.AddressSpaceId = AddressSpaceId;
970 
971     /* Walk the namespace from the root */
972 
973     (void) AcpiWalkNamespace (ACPI_TYPE_LOCAL_REGION_FIELD, ACPI_ROOT_OBJECT,
974           ACPI_UINT32_MAX, AcpiDbWalkForFields, NULL,
975           (void *) &Info, NULL);
976 
977     return (AE_OK);
978 }
979 
980 
981 /*******************************************************************************
982  *
983  * FUNCTION:    AcpiDbIntegrityWalk
984  *
985  * PARAMETERS:  Callback from WalkNamespace
986  *
987  * RETURN:      Status
988  *
989  * DESCRIPTION: Examine one NS node for valid values.
990  *
991  ******************************************************************************/
992 
993 static ACPI_STATUS
994 AcpiDbIntegrityWalk (
995     ACPI_HANDLE             ObjHandle,
996     UINT32                  NestingLevel,
997     void                    *Context,
998     void                    **ReturnValue)
999 {
1000     ACPI_INTEGRITY_INFO     *Info = (ACPI_INTEGRITY_INFO *) Context;
1001     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
1002     ACPI_OPERAND_OBJECT     *Object;
1003     BOOLEAN                 Alias = TRUE;
1004 
1005 
1006     Info->Nodes++;
1007 
1008     /* Verify the NS node, and dereference aliases */
1009 
1010     while (Alias)
1011     {
1012         if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
1013         {
1014             AcpiOsPrintf (
1015                 "Invalid Descriptor Type for Node %p [%s] - "
1016                 "is %2.2X should be %2.2X\n",
1017                 Node, AcpiUtGetDescriptorName (Node),
1018                 ACPI_GET_DESCRIPTOR_TYPE (Node), ACPI_DESC_TYPE_NAMED);
1019             return (AE_OK);
1020         }
1021 
1022         if ((Node->Type == ACPI_TYPE_LOCAL_ALIAS)  ||
1023             (Node->Type == ACPI_TYPE_LOCAL_METHOD_ALIAS))
1024         {
1025             Node = (ACPI_NAMESPACE_NODE *) Node->Object;
1026         }
1027         else
1028         {
1029             Alias = FALSE;
1030         }
1031     }
1032 
1033     if (Node->Type > ACPI_TYPE_LOCAL_MAX)
1034     {
1035         AcpiOsPrintf ("Invalid Object Type for Node %p, Type = %X\n",
1036             Node, Node->Type);
1037         return (AE_OK);
1038     }
1039 
1040     if (!AcpiUtValidNameseg (Node->Name.Ascii))
1041     {
1042         AcpiOsPrintf ("Invalid AcpiName for Node %p\n", Node);
1043         return (AE_OK);
1044     }
1045 
1046     Object = AcpiNsGetAttachedObject (Node);
1047     if (Object)
1048     {
1049         Info->Objects++;
1050         if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
1051         {
1052             AcpiOsPrintf ("Invalid Descriptor Type for Object %p [%s]\n",
1053                 Object, AcpiUtGetDescriptorName (Object));
1054         }
1055     }
1056 
1057     return (AE_OK);
1058 }
1059 
1060 
1061 /*******************************************************************************
1062  *
1063  * FUNCTION:    AcpiDbCheckIntegrity
1064  *
1065  * PARAMETERS:  None
1066  *
1067  * RETURN:      None
1068  *
1069  * DESCRIPTION: Check entire namespace for data structure integrity
1070  *
1071  ******************************************************************************/
1072 
1073 void
1074 AcpiDbCheckIntegrity (
1075     void)
1076 {
1077     ACPI_INTEGRITY_INFO     Info = {0,0};
1078 
1079     /* Search all nodes in namespace */
1080 
1081     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
1082         ACPI_UINT32_MAX, AcpiDbIntegrityWalk, NULL, (void *) &Info, NULL);
1083 
1084     AcpiOsPrintf ("Verified %u namespace nodes with %u Objects\n",
1085         Info.Nodes, Info.Objects);
1086 }
1087 
1088 
1089 /*******************************************************************************
1090  *
1091  * FUNCTION:    AcpiDbWalkForReferences
1092  *
1093  * PARAMETERS:  Callback from WalkNamespace
1094  *
1095  * RETURN:      Status
1096  *
1097  * DESCRIPTION: Check if this namespace object refers to the target object
1098  *              that is passed in as the context value.
1099  *
1100  * Note: Currently doesn't check subobjects within the Node's object
1101  *
1102  ******************************************************************************/
1103 
1104 static ACPI_STATUS
1105 AcpiDbWalkForReferences (
1106     ACPI_HANDLE             ObjHandle,
1107     UINT32                  NestingLevel,
1108     void                    *Context,
1109     void                    **ReturnValue)
1110 {
1111     ACPI_OPERAND_OBJECT     *ObjDesc = (ACPI_OPERAND_OBJECT  *) Context;
1112     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
1113 
1114 
1115     /* Check for match against the namespace node itself */
1116 
1117     if (Node == (void *) ObjDesc)
1118     {
1119         AcpiOsPrintf ("Object is a Node [%4.4s]\n",
1120             AcpiUtGetNodeName (Node));
1121     }
1122 
1123     /* Check for match against the object attached to the node */
1124 
1125     if (AcpiNsGetAttachedObject (Node) == ObjDesc)
1126     {
1127         AcpiOsPrintf ("Reference at Node->Object %p [%4.4s]\n",
1128             Node, AcpiUtGetNodeName (Node));
1129     }
1130 
1131     return (AE_OK);
1132 }
1133 
1134 
1135 /*******************************************************************************
1136  *
1137  * FUNCTION:    AcpiDbFindReferences
1138  *
1139  * PARAMETERS:  ObjectArg       - String with hex value of the object
1140  *
1141  * RETURN:      None
1142  *
1143  * DESCRIPTION: Search namespace for all references to the input object
1144  *
1145  ******************************************************************************/
1146 
1147 void
1148 AcpiDbFindReferences (
1149     char                    *ObjectArg)
1150 {
1151     ACPI_OPERAND_OBJECT     *ObjDesc;
1152     ACPI_SIZE               Address;
1153 
1154 
1155     /* Convert string to object pointer */
1156 
1157     Address = strtoul (ObjectArg, NULL, 16);
1158     ObjDesc = ACPI_TO_POINTER (Address);
1159 
1160     /* Search all nodes in namespace */
1161 
1162     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
1163         ACPI_UINT32_MAX, AcpiDbWalkForReferences, NULL,
1164         (void *) ObjDesc, NULL);
1165 }
1166 
1167 
1168 /*******************************************************************************
1169  *
1170  * FUNCTION:    AcpiDbBusWalk
1171  *
1172  * PARAMETERS:  Callback from WalkNamespace
1173  *
1174  * RETURN:      Status
1175  *
1176  * DESCRIPTION: Display info about device objects that have a corresponding
1177  *              _PRT method.
1178  *
1179  ******************************************************************************/
1180 
1181 static ACPI_STATUS
1182 AcpiDbBusWalk (
1183     ACPI_HANDLE             ObjHandle,
1184     UINT32                  NestingLevel,
1185     void                    *Context,
1186     void                    **ReturnValue)
1187 {
1188     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
1189     ACPI_STATUS             Status;
1190     ACPI_BUFFER             Buffer;
1191     ACPI_NAMESPACE_NODE     *TempNode;
1192     ACPI_DEVICE_INFO        *Info;
1193     UINT32                  i;
1194 
1195 
1196     if ((Node->Type != ACPI_TYPE_DEVICE) &&
1197         (Node->Type != ACPI_TYPE_PROCESSOR))
1198     {
1199         return (AE_OK);
1200     }
1201 
1202     /* Exit if there is no _PRT under this device */
1203 
1204     Status = AcpiGetHandle (Node, METHOD_NAME__PRT,
1205         ACPI_CAST_PTR (ACPI_HANDLE, &TempNode));
1206     if (ACPI_FAILURE (Status))
1207     {
1208         return (AE_OK);
1209     }
1210 
1211     /* Get the full path to this device object */
1212 
1213     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
1214     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, TRUE);
1215     if (ACPI_FAILURE (Status))
1216     {
1217         AcpiOsPrintf ("Could Not get pathname for object %p\n",
1218             ObjHandle);
1219         return (AE_OK);
1220     }
1221 
1222     Status = AcpiGetObjectInfo (ObjHandle, &Info);
1223     if (ACPI_FAILURE (Status))
1224     {
1225         return (AE_OK);
1226     }
1227 
1228     /* Display the full path */
1229 
1230     AcpiOsPrintf ("%-32s Type %X", (char *) Buffer.Pointer, Node->Type);
1231     ACPI_FREE (Buffer.Pointer);
1232 
1233     if (Info->Flags & ACPI_PCI_ROOT_BRIDGE)
1234     {
1235         AcpiOsPrintf ("  - Is PCI Root Bridge");
1236     }
1237     AcpiOsPrintf ("\n");
1238 
1239     /* _PRT info */
1240 
1241     AcpiOsPrintf ("_PRT: %p\n", TempNode);
1242 
1243     /* Dump _ADR, _HID, _UID, _CID */
1244 
1245     if (Info->Valid & ACPI_VALID_ADR)
1246     {
1247         AcpiOsPrintf ("_ADR: %8.8X%8.8X\n",
1248             ACPI_FORMAT_UINT64 (Info->Address));
1249     }
1250     else
1251     {
1252         AcpiOsPrintf ("_ADR: <Not Present>\n");
1253     }
1254 
1255     if (Info->Valid & ACPI_VALID_HID)
1256     {
1257         AcpiOsPrintf ("_HID: %s\n", Info->HardwareId.String);
1258     }
1259     else
1260     {
1261         AcpiOsPrintf ("_HID: <Not Present>\n");
1262     }
1263 
1264     if (Info->Valid & ACPI_VALID_UID)
1265     {
1266         AcpiOsPrintf ("_UID: %s\n", Info->UniqueId.String);
1267     }
1268     else
1269     {
1270         AcpiOsPrintf ("_UID: <Not Present>\n");
1271     }
1272 
1273     if (Info->Valid & ACPI_VALID_CID)
1274     {
1275         for (i = 0; i < Info->CompatibleIdList.Count; i++)
1276         {
1277             AcpiOsPrintf ("_CID: %s\n",
1278                 Info->CompatibleIdList.Ids[i].String);
1279         }
1280     }
1281     else
1282     {
1283         AcpiOsPrintf ("_CID: <Not Present>\n");
1284     }
1285 
1286     ACPI_FREE (Info);
1287     return (AE_OK);
1288 }
1289 
1290 
1291 /*******************************************************************************
1292  *
1293  * FUNCTION:    AcpiDbGetBusInfo
1294  *
1295  * PARAMETERS:  None
1296  *
1297  * RETURN:      None
1298  *
1299  * DESCRIPTION: Display info about system buses.
1300  *
1301  ******************************************************************************/
1302 
1303 void
1304 AcpiDbGetBusInfo (
1305     void)
1306 {
1307     /* Search all nodes in namespace */
1308 
1309     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
1310         ACPI_UINT32_MAX, AcpiDbBusWalk, NULL, NULL, NULL);
1311 }
1312