sys/contrib/dev/acpica/components/debugger/dbnames.c

   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 - 2018, 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
 158
 159 #define _COMPONENT          ACPI_CA_DEBUGGER
 160         ACPI_MODULE_NAME    ("dbnames")
 161
 162
 163 /* Local prototypes */
 164
 165 static ACPI_STATUS
 166 AcpiDbWalkAndMatchName (
 167     ACPI_HANDLE             ObjHandle,
 168     UINT32                  NestingLevel,
 169     void                    *Context,
 170     void                    **ReturnValue);
 171
 172 static ACPI_STATUS
 173 AcpiDbWalkForPredefinedNames (
 174     ACPI_HANDLE             ObjHandle,
 175     UINT32                  NestingLevel,
 176     void                    *Context,
 177     void                    **ReturnValue);
 178
 179 static ACPI_STATUS
 180 AcpiDbWalkForSpecificObjects (
 181     ACPI_HANDLE             ObjHandle,
 182     UINT32                  NestingLevel,
 183     void                    *Context,
 184     void                    **ReturnValue);
 185
 186 static ACPI_STATUS
 187 AcpiDbWalkForObjectCounts (
 188     ACPI_HANDLE             ObjHandle,
 189     UINT32                  NestingLevel,
 190     void                    *Context,
 191     void                    **ReturnValue);
 192
 193 static ACPI_STATUS
 194 AcpiDbIntegrityWalk (
 195     ACPI_HANDLE             ObjHandle,
 196     UINT32                  NestingLevel,
 197     void                    *Context,
 198     void                    **ReturnValue);
 199
 200 static ACPI_STATUS
 201 AcpiDbWalkForReferences (
 202     ACPI_HANDLE             ObjHandle,
 203     UINT32                  NestingLevel,
 204     void                    *Context,
 205     void                    **ReturnValue);
 206
 207 static ACPI_STATUS
 208 AcpiDbBusWalk (
 209     ACPI_HANDLE             ObjHandle,
 210     UINT32                  NestingLevel,
 211     void                    *Context,
 212     void                    **ReturnValue);
 213
 214 /*
 215  * Arguments for the Objects command
 216  * These object types map directly to the ACPI_TYPES
 217  */
 218 static ACPI_DB_ARGUMENT_INFO    AcpiDbObjectTypes [] =
 219 {
 220     {"ANY"},
 221     {"INTEGERS"},
 222     {"STRINGS"},
 223     {"BUFFERS"},
 224     {"PACKAGES"},
 225     {"FIELDS"},
 226     {"DEVICES"},
 227     {"EVENTS"},
 228     {"METHODS"},
 229     {"MUTEXES"},
 230     {"REGIONS"},
 231     {"POWERRESOURCES"},
 232     {"PROCESSORS"},
 233     {"THERMALZONES"},
 234     {"BUFFERFIELDS"},
 235     {"DDBHANDLES"},
 236     {"DEBUG"},
 237     {"REGIONFIELDS"},
 238     {"BANKFIELDS"},
 239     {"INDEXFIELDS"},
 240     {"REFERENCES"},
 241     {"ALIASES"},
 242     {"METHODALIASES"},
 243     {"NOTIFY"},
 244     {"ADDRESSHANDLER"},
 245     {"RESOURCE"},
 246     {"RESOURCEFIELD"},
 247     {"SCOPES"},
 248     {NULL}           /* Must be null terminated */
 249 };
 250
 251
 252 /*******************************************************************************
 253  *
 254  * FUNCTION:    AcpiDbSetScope
 255  *
 256  * PARAMETERS:  Name                - New scope path
 257  *
 258  * RETURN:      Status
 259  *
 260  * DESCRIPTION: Set the "current scope" as maintained by this utility.
 261  *              The scope is used as a prefix to ACPI paths.
 262  *
 263  ******************************************************************************/
 264
 265 void
 266 AcpiDbSetScope (
 267     char                    *Name)
 268 {
 269     ACPI_STATUS             Status;
 270     ACPI_NAMESPACE_NODE     *Node;
 271
 272
 273     if (!Name || Name[0] == 0)
 274     {
 275         AcpiOsPrintf ("Current scope: %s\n", AcpiGbl_DbScopeBuf);
 276         return;
 277     }
 278
 279     AcpiDbPrepNamestring (Name);
 280
 281     if (ACPI_IS_ROOT_PREFIX (Name[0]))
 282     {
 283         /* Validate new scope from the root */
 284
 285         Status = AcpiNsGetNode (AcpiGbl_RootNode, Name,
 286             ACPI_NS_NO_UPSEARCH, &Node);
 287         if (ACPI_FAILURE (Status))
 288         {
 289             goto ErrorExit;
 290         }
 291
 292         AcpiGbl_DbScopeBuf[0] = 0;
 293     }
 294     else
 295     {
 296         /* Validate new scope relative to old scope */
 297
 298         Status = AcpiNsGetNode (AcpiGbl_DbScopeNode, Name,
 299             ACPI_NS_NO_UPSEARCH, &Node);
 300         if (ACPI_FAILURE (Status))
 301         {
 302             goto ErrorExit;
 303         }
 304     }
 305
 306     /* Build the final pathname */
 307
 308     if (AcpiUtSafeStrcat (AcpiGbl_DbScopeBuf, sizeof (AcpiGbl_DbScopeBuf),
 309         Name))
 310     {
 311         Status = AE_BUFFER_OVERFLOW;
 312         goto ErrorExit;
 313     }
 314
 315     if (AcpiUtSafeStrcat (AcpiGbl_DbScopeBuf, sizeof (AcpiGbl_DbScopeBuf),
 316             "\\"))
 317     {
 318         Status = AE_BUFFER_OVERFLOW;
 319         goto ErrorExit;
 320     }
 321
 322     AcpiGbl_DbScopeNode = Node;
 323     AcpiOsPrintf ("New scope: %s\n", AcpiGbl_DbScopeBuf);
 324     return;
 325
 326 ErrorExit:
 327
 328     AcpiOsPrintf ("Could not attach scope: %s, %s\n",
 329         Name, AcpiFormatException (Status));
 330 }
 331
 332
 333 /*******************************************************************************
 334  *
 335  * FUNCTION:    AcpiDbDumpNamespace
 336  *
 337  * PARAMETERS:  StartArg        - Node to begin namespace dump
 338  *              DepthArg        - Maximum tree depth to be dumped
 339  *
 340  * RETURN:      None
 341  *
 342  * DESCRIPTION: Dump entire namespace or a subtree. Each node is displayed
 343  *              with type and other information.
 344  *
 345  ******************************************************************************/
 346
 347 void
 348 AcpiDbDumpNamespace (
 349     char                    *StartArg,
 350     char                    *DepthArg)
 351 {
 352     ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
 353     UINT32                  MaxDepth = ACPI_UINT32_MAX;
 354
 355
 356     /* No argument given, just start at the root and dump entire namespace */
 357
 358     if (StartArg)
 359     {
 360         SubtreeEntry = AcpiDbConvertToNode (StartArg);
 361         if (!SubtreeEntry)
 362         {
 363             return;
 364         }
 365
 366         /* Now we can check for the depth argument */
 367
 368         if (DepthArg)
 369         {
 370             MaxDepth = strtoul (DepthArg, NULL, 0);
 371         }
 372     }
 373
 374     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 375     AcpiOsPrintf ("ACPI Namespace (from %4.4s (%p) subtree):\n",
 376         ((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Name.Ascii, SubtreeEntry);
 377
 378     /* Display the subtree */
 379
 380     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 381     AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,
 382         ACPI_OWNER_ID_MAX, SubtreeEntry);
 383     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 384 }
 385
 386
 387 /*******************************************************************************
 388  *
 389  * FUNCTION:    AcpiDbDumpNamespacePaths
 390  *
 391  * PARAMETERS:  None
 392  *
 393  * RETURN:      None
 394  *
 395  * DESCRIPTION: Dump entire namespace with full object pathnames and object
 396  *              type information. Alternative to "namespace" command.
 397  *
 398  ******************************************************************************/
 399
 400 void
 401 AcpiDbDumpNamespacePaths (
 402     void)
 403 {
 404
 405     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 406     AcpiOsPrintf ("ACPI Namespace (from root):\n");
 407
 408     /* Display the entire namespace */
 409
 410     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 411     AcpiNsDumpObjectPaths (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY,
 412         ACPI_UINT32_MAX, ACPI_OWNER_ID_MAX, AcpiGbl_RootNode);
 413
 414     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 415 }
 416
 417
 418 /*******************************************************************************
 419  *
 420  * FUNCTION:    AcpiDbDumpNamespaceByOwner
 421  *
 422  * PARAMETERS:  OwnerArg        - Owner ID whose nodes will be displayed
 423  *              DepthArg        - Maximum tree depth to be dumped
 424  *
 425  * RETURN:      None
 426  *
 427  * DESCRIPTION: Dump elements of the namespace that are owned by the OwnerId.
 428  *
 429  ******************************************************************************/
 430
 431 void
 432 AcpiDbDumpNamespaceByOwner (
 433     char                    *OwnerArg,
 434     char                    *DepthArg)
 435 {
 436     ACPI_HANDLE             SubtreeEntry = AcpiGbl_RootNode;
 437     UINT32                  MaxDepth = ACPI_UINT32_MAX;
 438     ACPI_OWNER_ID           OwnerId;
 439
 440
 441     OwnerId = (ACPI_OWNER_ID) strtoul (OwnerArg, NULL, 0);
 442
 443     /* Now we can check for the depth argument */
 444
 445     if (DepthArg)
 446     {
 447         MaxDepth = strtoul (DepthArg, NULL, 0);
 448     }
 449
 450     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 451     AcpiOsPrintf ("ACPI Namespace by owner %X:\n", OwnerId);
 452
 453     /* Display the subtree */
 454
 455     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 456     AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,
 457         OwnerId, SubtreeEntry);
 458     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 459 }
 460
 461
 462 /*******************************************************************************
 463  *
 464  * FUNCTION:    AcpiDbWalkAndMatchName
 465  *
 466  * PARAMETERS:  Callback from WalkNamespace
 467  *
 468  * RETURN:      Status
 469  *
 470  * DESCRIPTION: Find a particular name/names within the namespace. Wildcards
 471  *              are supported -- '?' matches any character.
 472  *
 473  ******************************************************************************/
 474
 475 static ACPI_STATUS
 476 AcpiDbWalkAndMatchName (
 477     ACPI_HANDLE             ObjHandle,
 478     UINT32                  NestingLevel,
 479     void                    *Context,
 480     void                    **ReturnValue)
 481 {
 482     ACPI_STATUS             Status;
 483     char                    *RequestedName = (char *) Context;
 484     UINT32                  i;
 485     ACPI_BUFFER             Buffer;
 486     ACPI_WALK_INFO          Info;
 487
 488
 489     /* Check for a name match */
 490
 491     for (i = 0; i < 4; i++)
 492     {
 493         /* Wildcard support */
 494
 495         if ((RequestedName[i] != '?') &&
 496             (RequestedName[i] != ((ACPI_NAMESPACE_NODE *)
 497                 ObjHandle)->Name.Ascii[i]))
 498         {
 499             /* No match, just exit */
 500
 501             return (AE_OK);
 502         }
 503     }
 504
 505     /* Get the full pathname to this object */
 506
 507     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 508     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, TRUE);
 509     if (ACPI_FAILURE (Status))
 510     {
 511         AcpiOsPrintf ("Could Not get pathname for object %p\n",
 512             ObjHandle);
 513     }
 514     else
 515     {
 516         Info.OwnerId = ACPI_OWNER_ID_MAX;
 517         Info.DebugLevel = ACPI_UINT32_MAX;
 518         Info.DisplayType = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT;
 519
 520         AcpiOsPrintf ("%32s", (char *) Buffer.Pointer);
 521         (void) AcpiNsDumpOneObject (ObjHandle, NestingLevel, &Info, NULL);
 522         ACPI_FREE (Buffer.Pointer);
 523     }
 524
 525     return (AE_OK);
 526 }
 527
 528
 529 /*******************************************************************************
 530  *
 531  * FUNCTION:    AcpiDbFindNameInNamespace
 532  *
 533  * PARAMETERS:  NameArg         - The 4-character ACPI name to find.
 534  *                                wildcards are supported.
 535  *
 536  * RETURN:      None
 537  *
 538  * DESCRIPTION: Search the namespace for a given name (with wildcards)
 539  *
 540  ******************************************************************************/
 541
 542 ACPI_STATUS
 543 AcpiDbFindNameInNamespace (
 544     char                    *NameArg)
 545 {
 546     char                    AcpiName[5] = "____";
 547     char                    *AcpiNamePtr = AcpiName;
 548
 549
 550     if (strlen (NameArg) > ACPI_NAME_SIZE)
 551     {
 552         AcpiOsPrintf ("Name must be no longer than 4 characters\n");
 553         return (AE_OK);
 554     }
 555
 556     /* Pad out name with underscores as necessary to create a 4-char name */
 557
 558     AcpiUtStrupr (NameArg);
 559     while (*NameArg)
 560     {
 561         *AcpiNamePtr = *NameArg;
 562         AcpiNamePtr++;
 563         NameArg++;
 564     }
 565
 566     /* Walk the namespace from the root */
 567
 568     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 569         ACPI_UINT32_MAX, AcpiDbWalkAndMatchName, NULL, AcpiName, NULL);
 570
 571     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 572     return (AE_OK);
 573 }
 574
 575
 576 /*******************************************************************************
 577  *
 578  * FUNCTION:    AcpiDbWalkForPredefinedNames
 579  *
 580  * PARAMETERS:  Callback from WalkNamespace
 581  *
 582  * RETURN:      Status
 583  *
 584  * DESCRIPTION: Detect and display predefined ACPI names (names that start with
 585  *              an underscore)
 586  *
 587  ******************************************************************************/
 588
 589 static ACPI_STATUS
 590 AcpiDbWalkForPredefinedNames (
 591     ACPI_HANDLE             ObjHandle,
 592     UINT32                  NestingLevel,
 593     void                    *Context,
 594     void                    **ReturnValue)
 595 {
 596     ACPI_NAMESPACE_NODE         *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 597     UINT32                      *Count = (UINT32 *) Context;
 598     const ACPI_PREDEFINED_INFO  *Predefined;
 599     const ACPI_PREDEFINED_INFO  *Package = NULL;
 600     char                        *Pathname;
 601     char                        StringBuffer[48];
 602
 603
 604     Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii);
 605     if (!Predefined)
 606     {
 607         return (AE_OK);
 608     }
 609
 610     Pathname = AcpiNsGetNormalizedPathname (Node, TRUE);
 611     if (!Pathname)
 612     {
 613         return (AE_OK);
 614     }
 615
 616     /* If method returns a package, the info is in the next table entry */
 617
 618     if (Predefined->Info.ExpectedBtypes & ACPI_RTYPE_PACKAGE)
 619     {
 620         Package = Predefined + 1;
 621     }
 622
 623     AcpiUtGetExpectedReturnTypes (StringBuffer,
 624         Predefined->Info.ExpectedBtypes);
 625
 626     AcpiOsPrintf ("%-32s Arguments %X, Return Types: %s", Pathname,
 627         METHOD_GET_ARG_COUNT (Predefined->Info.ArgumentList),
 628         StringBuffer);
 629
 630     if (Package)
 631     {
 632         AcpiOsPrintf (" (PkgType %2.2X, ObjType %2.2X, Count %2.2X)",
 633             Package->RetInfo.Type, Package->RetInfo.ObjectType1,
 634             Package->RetInfo.Count1);
 635     }
 636
 637     AcpiOsPrintf("\n");
 638
 639     /* Check that the declared argument count matches the ACPI spec */
 640
 641     AcpiNsCheckAcpiCompliance (Pathname, Node, Predefined);
 642
 643     ACPI_FREE (Pathname);
 644     (*Count)++;
 645     return (AE_OK);
 646 }
 647
 648
 649 /*******************************************************************************
 650  *
 651  * FUNCTION:    AcpiDbCheckPredefinedNames
 652  *
 653  * PARAMETERS:  None
 654  *
 655  * RETURN:      None
 656  *
 657  * DESCRIPTION: Validate all predefined names in the namespace
 658  *
 659  ******************************************************************************/
 660
 661 void
 662 AcpiDbCheckPredefinedNames (
 663     void)
 664 {
 665     UINT32                  Count = 0;
 666
 667
 668     /* Search all nodes in namespace */
 669
 670     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 671         ACPI_UINT32_MAX, AcpiDbWalkForPredefinedNames,
 672         NULL, (void *) &Count, NULL);
 673
 674     AcpiOsPrintf ("Found %u predefined names in the namespace\n", Count);
 675 }
 676
 677
 678 /*******************************************************************************
 679  *
 680  * FUNCTION:    AcpiDbWalkForObjectCounts
 681  *
 682  * PARAMETERS:  Callback from WalkNamespace
 683  *
 684  * RETURN:      Status
 685  *
 686  * DESCRIPTION: Display short info about objects in the namespace
 687  *
 688  ******************************************************************************/
 689
 690 static ACPI_STATUS
 691 AcpiDbWalkForObjectCounts (
 692     ACPI_HANDLE             ObjHandle,
 693     UINT32                  NestingLevel,
 694     void                    *Context,
 695     void                    **ReturnValue)
 696 {
 697     ACPI_OBJECT_INFO        *Info = (ACPI_OBJECT_INFO *) Context;
 698     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 699
 700
 701     if (Node->Type > ACPI_TYPE_NS_NODE_MAX)
 702     {
 703         AcpiOsPrintf ("[%4.4s]: Unknown object type %X\n",
 704             Node->Name.Ascii, Node->Type);
 705     }
 706     else
 707     {
 708         Info->Types[Node->Type]++;
 709     }
 710
 711     return (AE_OK);
 712 }
 713
 714
 715 /*******************************************************************************
 716  *
 717  * FUNCTION:    AcpiDbWalkForSpecificObjects
 718  *
 719  * PARAMETERS:  Callback from WalkNamespace
 720  *
 721  * RETURN:      Status
 722  *
 723  * DESCRIPTION: Display short info about objects in the namespace
 724  *
 725  ******************************************************************************/
 726
 727 static ACPI_STATUS
 728 AcpiDbWalkForSpecificObjects (
 729     ACPI_HANDLE             ObjHandle,
 730     UINT32                  NestingLevel,
 731     void                    *Context,
 732     void                    **ReturnValue)
 733 {
 734     ACPI_WALK_INFO          *Info = (ACPI_WALK_INFO *) Context;
 735     ACPI_BUFFER             Buffer;
 736     ACPI_STATUS             Status;
 737
 738
 739     Info->Count++;
 740
 741     /* Get and display the full pathname to this object */
 742
 743     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 744     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, TRUE);
 745     if (ACPI_FAILURE (Status))
 746     {
 747         AcpiOsPrintf ("Could Not get pathname for object %p\n", ObjHandle);
 748         return (AE_OK);
 749     }
 750
 751     AcpiOsPrintf ("%32s", (char *) Buffer.Pointer);
 752     ACPI_FREE (Buffer.Pointer);
 753
 754     /* Dump short info about the object */
 755
 756     (void) AcpiNsDumpOneObject (ObjHandle, NestingLevel, Info, NULL);
 757     return (AE_OK);
 758 }
 759
 760
 761 /*******************************************************************************
 762  *
 763  * FUNCTION:    AcpiDbDisplayObjects
 764  *
 765  * PARAMETERS:  ObjTypeArg          - Type of object to display
 766  *              DisplayCountArg     - Max depth to display
 767  *
 768  * RETURN:      None
 769  *
 770  * DESCRIPTION: Display objects in the namespace of the requested type
 771  *
 772  ******************************************************************************/
 773
 774 ACPI_STATUS
 775 AcpiDbDisplayObjects (
 776     char                    *ObjTypeArg,
 777     char                    *DisplayCountArg)
 778 {
 779     ACPI_WALK_INFO          Info;
 780     ACPI_OBJECT_TYPE        Type;
 781     ACPI_OBJECT_INFO        *ObjectInfo;
 782     UINT32                  i;
 783     UINT32                  TotalObjects = 0;
 784
 785
 786     /* No argument means display summary/count of all object types */
 787
 788     if (!ObjTypeArg)
 789     {
 790         ObjectInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_OBJECT_INFO));
 791
 792         /* Walk the namespace from the root */
 793
 794         (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 795             ACPI_UINT32_MAX, AcpiDbWalkForObjectCounts, NULL,
 796             (void *) ObjectInfo, NULL);
 797
 798         AcpiOsPrintf ("\nSummary of namespace objects:\n\n");
 799
 800         for (i = 0; i < ACPI_TOTAL_TYPES; i++)
 801         {
 802             AcpiOsPrintf ("%8u   %s\n", ObjectInfo->Types[i],
 803                 AcpiUtGetTypeName (i));
 804
 805             TotalObjects += ObjectInfo->Types[i];
 806         }
 807
 808         AcpiOsPrintf ("\n%8u   Total namespace objects\n\n",
 809             TotalObjects);
 810
 811         ACPI_FREE (ObjectInfo);
 812         return (AE_OK);
 813     }
 814
 815     /* Get the object type */
 816
 817     Type = AcpiDbMatchArgument (ObjTypeArg, AcpiDbObjectTypes);
 818     if (Type == ACPI_TYPE_NOT_FOUND)
 819     {
 820         AcpiOsPrintf ("Invalid or unsupported argument\n");
 821         return (AE_OK);
 822     }
 823
 824     AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
 825     AcpiOsPrintf (
 826         "Objects of type [%s] defined in the current ACPI Namespace:\n",
 827         AcpiUtGetTypeName (Type));
 828
 829     AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
 830
 831     Info.Count = 0;
 832     Info.OwnerId = ACPI_OWNER_ID_MAX;
 833     Info.DebugLevel = ACPI_UINT32_MAX;
 834     Info.DisplayType = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT;
 835
 836     /* Walk the namespace from the root */
 837
 838     (void) AcpiWalkNamespace (Type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 839         AcpiDbWalkForSpecificObjects, NULL, (void *) &Info, NULL);
 840
 841     AcpiOsPrintf (
 842         "\nFound %u objects of type [%s] in the current ACPI Namespace\n",
 843         Info.Count, AcpiUtGetTypeName (Type));
 844
 845     AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
 846     return (AE_OK);
 847 }
 848
 849
 850 /*******************************************************************************
 851  *
 852  * FUNCTION:    AcpiDbIntegrityWalk
 853  *
 854  * PARAMETERS:  Callback from WalkNamespace
 855  *
 856  * RETURN:      Status
 857  *
 858  * DESCRIPTION: Examine one NS node for valid values.
 859  *
 860  ******************************************************************************/
 861
 862 static ACPI_STATUS
 863 AcpiDbIntegrityWalk (
 864     ACPI_HANDLE             ObjHandle,
 865     UINT32                  NestingLevel,
 866     void                    *Context,
 867     void                    **ReturnValue)
 868 {
 869     ACPI_INTEGRITY_INFO     *Info = (ACPI_INTEGRITY_INFO *) Context;
 870     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 871     ACPI_OPERAND_OBJECT     *Object;
 872     BOOLEAN                 Alias = TRUE;
 873
 874
 875     Info->Nodes++;
 876
 877     /* Verify the NS node, and dereference aliases */
 878
 879     while (Alias)
 880     {
 881         if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
 882         {
 883             AcpiOsPrintf (
 884                 "Invalid Descriptor Type for Node %p [%s] - "
 885                 "is %2.2X should be %2.2X\n",
 886                 Node, AcpiUtGetDescriptorName (Node),
 887                 ACPI_GET_DESCRIPTOR_TYPE (Node), ACPI_DESC_TYPE_NAMED);
 888             return (AE_OK);
 889         }
 890
 891         if ((Node->Type == ACPI_TYPE_LOCAL_ALIAS)  ||
 892             (Node->Type == ACPI_TYPE_LOCAL_METHOD_ALIAS))
 893         {
 894             Node = (ACPI_NAMESPACE_NODE *) Node->Object;
 895         }
 896         else
 897         {
 898             Alias = FALSE;
 899         }
 900     }
 901
 902     if (Node->Type > ACPI_TYPE_LOCAL_MAX)
 903     {
 904         AcpiOsPrintf ("Invalid Object Type for Node %p, Type = %X\n",
 905             Node, Node->Type);
 906         return (AE_OK);
 907     }
 908
 909     if (!AcpiUtValidNameseg (Node->Name.Ascii))
 910     {
 911         AcpiOsPrintf ("Invalid AcpiName for Node %p\n", Node);
 912         return (AE_OK);
 913     }
 914
 915     Object = AcpiNsGetAttachedObject (Node);
 916     if (Object)
 917     {
 918         Info->Objects++;
 919         if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
 920         {
 921             AcpiOsPrintf ("Invalid Descriptor Type for Object %p [%s]\n",
 922                 Object, AcpiUtGetDescriptorName (Object));
 923         }
 924     }
 925
 926     return (AE_OK);
 927 }
 928
 929
 930 /*******************************************************************************
 931  *
 932  * FUNCTION:    AcpiDbCheckIntegrity
 933  *
 934  * PARAMETERS:  None
 935  *
 936  * RETURN:      None
 937  *
 938  * DESCRIPTION: Check entire namespace for data structure integrity
 939  *
 940  ******************************************************************************/
 941
 942 void
 943 AcpiDbCheckIntegrity (
 944     void)
 945 {
 946     ACPI_INTEGRITY_INFO     Info = {0,0};
 947
 948     /* Search all nodes in namespace */
 949
 950     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
 951         ACPI_UINT32_MAX, AcpiDbIntegrityWalk, NULL, (void *) &Info, NULL);
 952
 953     AcpiOsPrintf ("Verified %u namespace nodes with %u Objects\n",
 954         Info.Nodes, Info.Objects);
 955 }
 956
 957
 958 /*******************************************************************************
 959  *
 960  * FUNCTION:    AcpiDbWalkForReferences
 961  *
 962  * PARAMETERS:  Callback from WalkNamespace
 963  *
 964  * RETURN:      Status
 965  *
 966  * DESCRIPTION: Check if this namespace object refers to the target object
 967  *              that is passed in as the context value.
 968  *
 969  * Note: Currently doesn't check subobjects within the Node's object
 970  *
 971  ******************************************************************************/
 972
 973 static ACPI_STATUS
 974 AcpiDbWalkForReferences (
 975     ACPI_HANDLE             ObjHandle,
 976     UINT32                  NestingLevel,
 977     void                    *Context,
 978     void                    **ReturnValue)
 979 {
 980     ACPI_OPERAND_OBJECT     *ObjDesc = (ACPI_OPERAND_OBJECT  *) Context;
 981     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 982
 983
 984     /* Check for match against the namespace node itself */
 985
 986     if (Node == (void *) ObjDesc)
 987     {
 988         AcpiOsPrintf ("Object is a Node [%4.4s]\n",
 989             AcpiUtGetNodeName (Node));
 990     }
 991
 992     /* Check for match against the object attached to the node */
 993
 994     if (AcpiNsGetAttachedObject (Node) == ObjDesc)
 995     {
 996         AcpiOsPrintf ("Reference at Node->Object %p [%4.4s]\n",
 997             Node, AcpiUtGetNodeName (Node));
 998     }
 999
1000     return (AE_OK);
1001 }
1002
1003
1004 /*******************************************************************************
1005  *
1006  * FUNCTION:    AcpiDbFindReferences
1007  *
1008  * PARAMETERS:  ObjectArg       - String with hex value of the object
1009  *
1010  * RETURN:      None
1011  *
1012  * DESCRIPTION: Search namespace for all references to the input object
1013  *
1014  ******************************************************************************/
1015
1016 void
1017 AcpiDbFindReferences (
1018     char                    *ObjectArg)
1019 {
1020     ACPI_OPERAND_OBJECT     *ObjDesc;
1021     ACPI_SIZE               Address;
1022
1023
1024     /* Convert string to object pointer */
1025
1026     Address = strtoul (ObjectArg, NULL, 16);
1027     ObjDesc = ACPI_TO_POINTER (Address);
1028
1029     /* Search all nodes in namespace */
1030
1031     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
1032         ACPI_UINT32_MAX, AcpiDbWalkForReferences, NULL,
1033         (void *) ObjDesc, NULL);
1034 }
1035
1036
1037 /*******************************************************************************
1038  *
1039  * FUNCTION:    AcpiDbBusWalk
1040  *
1041  * PARAMETERS:  Callback from WalkNamespace
1042  *
1043  * RETURN:      Status
1044  *
1045  * DESCRIPTION: Display info about device objects that have a corresponding
1046  *              _PRT method.
1047  *
1048  ******************************************************************************/
1049
1050 static ACPI_STATUS
1051 AcpiDbBusWalk (
1052     ACPI_HANDLE             ObjHandle,
1053     UINT32                  NestingLevel,
1054     void                    *Context,
1055     void                    **ReturnValue)
1056 {
1057     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
1058     ACPI_STATUS             Status;
1059     ACPI_BUFFER             Buffer;
1060     ACPI_NAMESPACE_NODE     *TempNode;
1061     ACPI_DEVICE_INFO        *Info;
1062     UINT32                  i;
1063
1064
1065     if ((Node->Type != ACPI_TYPE_DEVICE) &&
1066         (Node->Type != ACPI_TYPE_PROCESSOR))
1067     {
1068         return (AE_OK);
1069     }
1070
1071     /* Exit if there is no _PRT under this device */
1072
1073     Status = AcpiGetHandle (Node, METHOD_NAME__PRT,
1074         ACPI_CAST_PTR (ACPI_HANDLE, &TempNode));
1075     if (ACPI_FAILURE (Status))
1076     {
1077         return (AE_OK);
1078     }
1079
1080     /* Get the full path to this device object */
1081
1082     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
1083     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer, TRUE);
1084     if (ACPI_FAILURE (Status))
1085     {
1086         AcpiOsPrintf ("Could Not get pathname for object %p\n",
1087             ObjHandle);
1088         return (AE_OK);
1089     }
1090
1091     Status = AcpiGetObjectInfo (ObjHandle, &Info);
1092     if (ACPI_FAILURE (Status))
1093     {
1094         return (AE_OK);
1095     }
1096
1097     /* Display the full path */
1098
1099     AcpiOsPrintf ("%-32s Type %X", (char *) Buffer.Pointer, Node->Type);
1100     ACPI_FREE (Buffer.Pointer);
1101
1102     if (Info->Flags & ACPI_PCI_ROOT_BRIDGE)
1103     {
1104         AcpiOsPrintf ("  - Is PCI Root Bridge");
1105     }
1106     AcpiOsPrintf ("\n");
1107
1108     /* _PRT info */
1109
1110     AcpiOsPrintf ("_PRT: %p\n", TempNode);
1111
1112     /* Dump _ADR, _HID, _UID, _CID */
1113
1114     if (Info->Valid & ACPI_VALID_ADR)
1115     {
1116         AcpiOsPrintf ("_ADR: %8.8X%8.8X\n",
1117             ACPI_FORMAT_UINT64 (Info->Address));
1118     }
1119     else
1120     {
1121         AcpiOsPrintf ("_ADR: <Not Present>\n");
1122     }
1123
1124     if (Info->Valid & ACPI_VALID_HID)
1125     {
1126         AcpiOsPrintf ("_HID: %s\n", Info->HardwareId.String);
1127     }
1128     else
1129     {
1130         AcpiOsPrintf ("_HID: <Not Present>\n");
1131     }
1132
1133     if (Info->Valid & ACPI_VALID_UID)
1134     {
1135         AcpiOsPrintf ("_UID: %s\n", Info->UniqueId.String);
1136     }
1137     else
1138     {
1139         AcpiOsPrintf ("_UID: <Not Present>\n");
1140     }
1141
1142     if (Info->Valid & ACPI_VALID_CID)
1143     {
1144         for (i = 0; i < Info->CompatibleIdList.Count; i++)
1145         {
1146             AcpiOsPrintf ("_CID: %s\n",
1147                 Info->CompatibleIdList.Ids[i].String);
1148         }
1149     }
1150     else
1151     {
1152         AcpiOsPrintf ("_CID: <Not Present>\n");
1153     }
1154
1155     ACPI_FREE (Info);
1156     return (AE_OK);
1157 }
1158
1159
1160 /*******************************************************************************
1161  *
1162  * FUNCTION:    AcpiDbGetBusInfo
1163  *
1164  * PARAMETERS:  None
1165  *
1166  * RETURN:      None
1167  *
1168  * DESCRIPTION: Display info about system busses.
1169  *
1170  ******************************************************************************/
1171
1172 void
1173 AcpiDbGetBusInfo (
1174     void)
1175 {
1176     /* Search all nodes in namespace */
1177
1178     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
1179         ACPI_UINT32_MAX, AcpiDbBusWalk, NULL, NULL, NULL);
1180 }