drivers/bus/acpi/acpica/namespace/nsdump.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsdump - table dumping routines for debug
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2017, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include "acpi.h"
  45 #include "accommon.h"
  46 #include "acnamesp.h"
  47 #include "acoutput.h"
  48
  49
  50 #define _COMPONENT          ACPI_NAMESPACE
  51         ACPI_MODULE_NAME    ("nsdump")
  52
  53 /* Local prototypes */
  54
  55 #ifdef ACPI_OBSOLETE_FUNCTIONS
  56 void
  57 AcpiNsDumpRootDevices (
  58     void);
  59
  60 static ACPI_STATUS
  61 AcpiNsDumpOneDevice (
  62     ACPI_HANDLE             ObjHandle,
  63     UINT32                  Level,
  64     void                    *Context,
  65     void                    **ReturnValue);
  66 #endif
  67
  68
  69 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
  70
  71 static ACPI_STATUS
  72 AcpiNsDumpOneObjectPath (
  73     ACPI_HANDLE             ObjHandle,
  74     UINT32                  Level,
  75     void                    *Context,
  76     void                    **ReturnValue);
  77
  78 static ACPI_STATUS
  79 AcpiNsGetMaxDepth (
  80     ACPI_HANDLE             ObjHandle,
  81     UINT32                  Level,
  82     void                    *Context,
  83     void                    **ReturnValue);
  84
  85
  86 /*******************************************************************************
  87  *
  88  * FUNCTION:    AcpiNsPrintPathname
  89  *
  90  * PARAMETERS:  NumSegments         - Number of ACPI name segments
  91  *              Pathname            - The compressed (internal) path
  92  *
  93  * RETURN:      None
  94  *
  95  * DESCRIPTION: Print an object's full namespace pathname
  96  *
  97  ******************************************************************************/
  98
  99 void
 100 AcpiNsPrintPathname (
 101     UINT32                  NumSegments,
 102     const char              *Pathname)
 103 {
 104     UINT32                  i;
 105
 106
 107     ACPI_FUNCTION_NAME (NsPrintPathname);
 108
 109
 110     /* Check if debug output enabled */
 111
 112     if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_NAMES, ACPI_NAMESPACE))
 113     {
 114         return;
 115     }
 116
 117     /* Print the entire name */
 118
 119     ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "["));
 120
 121     while (NumSegments)
 122     {
 123         for (i = 0; i < 4; i++)
 124         {
 125             isprint ((int) Pathname[i]) ?
 126                 AcpiOsPrintf ("%c", Pathname[i]) :
 127                 AcpiOsPrintf ("?");
 128         }
 129
 130         Pathname += ACPI_NAME_SIZE;
 131         NumSegments--;
 132         if (NumSegments)
 133         {
 134             AcpiOsPrintf (".");
 135         }
 136     }
 137
 138     AcpiOsPrintf ("]\n");
 139 }
 140
 141
 142 #ifdef ACPI_OBSOLETE_FUNCTIONS
 143 /* Not used at this time, perhaps later */
 144
 145 /*******************************************************************************
 146  *
 147  * FUNCTION:    AcpiNsDumpPathname
 148  *
 149  * PARAMETERS:  Handle              - Object
 150  *              Msg                 - Prefix message
 151  *              Level               - Desired debug level
 152  *              Component           - Caller's component ID
 153  *
 154  * RETURN:      None
 155  *
 156  * DESCRIPTION: Print an object's full namespace pathname
 157  *              Manages allocation/freeing of a pathname buffer
 158  *
 159  ******************************************************************************/
 160
 161 void
 162 AcpiNsDumpPathname (
 163     ACPI_HANDLE             Handle,
 164     const char              *Msg,
 165     UINT32                  Level,
 166     UINT32                  Component)
 167 {
 168
 169     ACPI_FUNCTION_TRACE (NsDumpPathname);
 170
 171
 172     /* Do this only if the requested debug level and component are enabled */
 173
 174     if (!ACPI_IS_DEBUG_ENABLED (Level, Component))
 175     {
 176         return_VOID;
 177     }
 178
 179     /* Convert handle to a full pathname and print it (with supplied message) */
 180
 181     AcpiNsPrintNodePathname (Handle, Msg);
 182     AcpiOsPrintf ("\n");
 183     return_VOID;
 184 }
 185 #endif
 186
 187 /*******************************************************************************
 188  *
 189  * FUNCTION:    AcpiNsDumpOneObject
 190  *
 191  * PARAMETERS:  ObjHandle           - Node to be dumped
 192  *              Level               - Nesting level of the handle
 193  *              Context             - Passed into WalkNamespace
 194  *              ReturnValue         - Not used
 195  *
 196  * RETURN:      Status
 197  *
 198  * DESCRIPTION: Dump a single Node
 199  *              This procedure is a UserFunction called by AcpiNsWalkNamespace.
 200  *
 201  ******************************************************************************/
 202
 203 ACPI_STATUS
 204 AcpiNsDumpOneObject (
 205     ACPI_HANDLE             ObjHandle,
 206     UINT32                  Level,
 207     void                    *Context,
 208     void                    **ReturnValue)
 209 {
 210     ACPI_WALK_INFO          *Info = (ACPI_WALK_INFO *) Context;
 211     ACPI_NAMESPACE_NODE     *ThisNode;
 212     ACPI_OPERAND_OBJECT     *ObjDesc = NULL;
 213     ACPI_OBJECT_TYPE        ObjType;
 214     ACPI_OBJECT_TYPE        Type;
 215     UINT32                  BytesToDump;
 216     UINT32                  DbgLevel;
 217     UINT32                  i;
 218
 219
 220     ACPI_FUNCTION_NAME (NsDumpOneObject);
 221
 222
 223     /* Is output enabled? */
 224
 225     if (!(AcpiDbgLevel & Info->DebugLevel))
 226     {
 227         return (AE_OK);
 228     }
 229
 230     if (!ObjHandle)
 231     {
 232         ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null object handle\n"));
 233         return (AE_OK);
 234     }
 235
 236     ThisNode = AcpiNsValidateHandle (ObjHandle);
 237     if (!ThisNode)
 238     {
 239         ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Invalid object handle %p\n",
 240             ObjHandle));
 241         return (AE_OK);
 242     }
 243
 244     Type = ThisNode->Type;
 245
 246     /* Check if the owner matches */
 247
 248     if ((Info->OwnerId != ACPI_OWNER_ID_MAX) &&
 249         (Info->OwnerId != ThisNode->OwnerId))
 250     {
 251         return (AE_OK);
 252     }
 253
 254     if (!(Info->DisplayType & ACPI_DISPLAY_SHORT))
 255     {
 256         /* Indent the object according to the level */
 257
 258         AcpiOsPrintf ("%2d%*s", (UINT32) Level - 1, (int) Level * 2, " ");
 259
 260         /* Check the node type and name */
 261
 262         if (Type > ACPI_TYPE_LOCAL_MAX)
 263         {
 264             ACPI_WARNING ((AE_INFO,
 265                 "Invalid ACPI Object Type 0x%08X", Type));
 266         }
 267
 268         AcpiOsPrintf ("%4.4s", AcpiUtGetNodeName (ThisNode));
 269     }
 270
 271     /* Now we can print out the pertinent information */
 272
 273     AcpiOsPrintf (" %-12s %p %2.2X ",
 274         AcpiUtGetTypeName (Type), ThisNode, ThisNode->OwnerId);
 275
 276     DbgLevel = AcpiDbgLevel;
 277     AcpiDbgLevel = 0;
 278     ObjDesc = AcpiNsGetAttachedObject (ThisNode);
 279     AcpiDbgLevel = DbgLevel;
 280
 281     /* Temp nodes are those nodes created by a control method */
 282
 283     if (ThisNode->Flags & ANOBJ_TEMPORARY)
 284     {
 285         AcpiOsPrintf ("(T) ");
 286     }
 287
 288     switch (Info->DisplayType & ACPI_DISPLAY_MASK)
 289     {
 290     case ACPI_DISPLAY_SUMMARY:
 291
 292         if (!ObjDesc)
 293         {
 294             /* No attached object. Some types should always have an object */
 295
 296             switch (Type)
 297             {
 298             case ACPI_TYPE_INTEGER:
 299             case ACPI_TYPE_PACKAGE:
 300             case ACPI_TYPE_BUFFER:
 301             case ACPI_TYPE_STRING:
 302             case ACPI_TYPE_METHOD:
 303
 304                 AcpiOsPrintf ("<No attached object>");
 305                 break;
 306
 307             default:
 308
 309                 break;
 310             }
 311
 312             AcpiOsPrintf ("\n");
 313             return (AE_OK);
 314         }
 315
 316         switch (Type)
 317         {
 318         case ACPI_TYPE_PROCESSOR:
 319
 320             AcpiOsPrintf ("ID %02X Len %02X Addr %8.8X%8.8X\n",
 321                 ObjDesc->Processor.ProcId, ObjDesc->Processor.Length,
 322                 ACPI_FORMAT_UINT64 (ObjDesc->Processor.Address));
 323             break;
 324
 325         case ACPI_TYPE_DEVICE:
 326
 327             AcpiOsPrintf ("Notify Object: %p\n", ObjDesc);
 328             break;
 329
 330         case ACPI_TYPE_METHOD:
 331
 332             AcpiOsPrintf ("Args %X Len %.4X Aml %p\n",
 333                 (UINT32) ObjDesc->Method.ParamCount,
 334                 ObjDesc->Method.AmlLength, ObjDesc->Method.AmlStart);
 335             break;
 336
 337         case ACPI_TYPE_INTEGER:
 338
 339             AcpiOsPrintf ("= %8.8X%8.8X\n",
 340                 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
 341             break;
 342
 343         case ACPI_TYPE_PACKAGE:
 344
 345             if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
 346             {
 347                 AcpiOsPrintf ("Elements %.2X\n",
 348                     ObjDesc->Package.Count);
 349             }
 350             else
 351             {
 352                 AcpiOsPrintf ("[Length not yet evaluated]\n");
 353             }
 354             break;
 355
 356         case ACPI_TYPE_BUFFER:
 357
 358             if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
 359             {
 360                 AcpiOsPrintf ("Len %.2X",
 361                     ObjDesc->Buffer.Length);
 362
 363                 /* Dump some of the buffer */
 364
 365                 if (ObjDesc->Buffer.Length > 0)
 366                 {
 367                     AcpiOsPrintf (" =");
 368                     for (i = 0; (i < ObjDesc->Buffer.Length && i < 12); i++)
 369                     {
 370                         AcpiOsPrintf (" %.2hX", ObjDesc->Buffer.Pointer[i]);
 371                     }
 372                 }
 373                 AcpiOsPrintf ("\n");
 374             }
 375             else
 376             {
 377                 AcpiOsPrintf ("[Length not yet evaluated]\n");
 378             }
 379             break;
 380
 381         case ACPI_TYPE_STRING:
 382
 383             AcpiOsPrintf ("Len %.2X ", ObjDesc->String.Length);
 384             AcpiUtPrintString (ObjDesc->String.Pointer, 80);
 385             AcpiOsPrintf ("\n");
 386             break;
 387
 388         case ACPI_TYPE_REGION:
 389
 390             AcpiOsPrintf ("[%s]",
 391                 AcpiUtGetRegionName (ObjDesc->Region.SpaceId));
 392             if (ObjDesc->Region.Flags & AOPOBJ_DATA_VALID)
 393             {
 394                 AcpiOsPrintf (" Addr %8.8X%8.8X Len %.4X\n",
 395                     ACPI_FORMAT_UINT64 (ObjDesc->Region.Address),
 396                     ObjDesc->Region.Length);
 397             }
 398             else
 399             {
 400                 AcpiOsPrintf (" [Address/Length not yet evaluated]\n");
 401             }
 402             break;
 403
 404         case ACPI_TYPE_LOCAL_REFERENCE:
 405
 406             AcpiOsPrintf ("[%s]\n", AcpiUtGetReferenceName (ObjDesc));
 407             break;
 408
 409         case ACPI_TYPE_BUFFER_FIELD:
 410
 411             if (ObjDesc->BufferField.BufferObj &&
 412                 ObjDesc->BufferField.BufferObj->Buffer.Node)
 413             {
 414                 AcpiOsPrintf ("Buf [%4.4s]",
 415                     AcpiUtGetNodeName (
 416                         ObjDesc->BufferField.BufferObj->Buffer.Node));
 417             }
 418             break;
 419
 420         case ACPI_TYPE_LOCAL_REGION_FIELD:
 421
 422             AcpiOsPrintf ("Rgn [%4.4s]",
 423                 AcpiUtGetNodeName (
 424                     ObjDesc->CommonField.RegionObj->Region.Node));
 425             break;
 426
 427         case ACPI_TYPE_LOCAL_BANK_FIELD:
 428
 429             AcpiOsPrintf ("Rgn [%4.4s] Bnk [%4.4s]",
 430                 AcpiUtGetNodeName (
 431                     ObjDesc->CommonField.RegionObj->Region.Node),
 432                 AcpiUtGetNodeName (
 433                     ObjDesc->BankField.BankObj->CommonField.Node));
 434             break;
 435
 436         case ACPI_TYPE_LOCAL_INDEX_FIELD:
 437
 438             AcpiOsPrintf ("Idx [%4.4s] Dat [%4.4s]",
 439                 AcpiUtGetNodeName (
 440                     ObjDesc->IndexField.IndexObj->CommonField.Node),
 441                 AcpiUtGetNodeName (
 442                     ObjDesc->IndexField.DataObj->CommonField.Node));
 443             break;
 444
 445         case ACPI_TYPE_LOCAL_ALIAS:
 446         case ACPI_TYPE_LOCAL_METHOD_ALIAS:
 447
 448             AcpiOsPrintf ("Target %4.4s (%p)\n",
 449                 AcpiUtGetNodeName (ObjDesc), ObjDesc);
 450             break;
 451
 452         default:
 453
 454             AcpiOsPrintf ("Object %p\n", ObjDesc);
 455             break;
 456         }
 457
 458         /* Common field handling */
 459
 460         switch (Type)
 461         {
 462         case ACPI_TYPE_BUFFER_FIELD:
 463         case ACPI_TYPE_LOCAL_REGION_FIELD:
 464         case ACPI_TYPE_LOCAL_BANK_FIELD:
 465         case ACPI_TYPE_LOCAL_INDEX_FIELD:
 466
 467             AcpiOsPrintf (" Off %.3X Len %.2X Acc %.2hd\n",
 468                 (ObjDesc->CommonField.BaseByteOffset * 8)
 469                     + ObjDesc->CommonField.StartFieldBitOffset,
 470                 ObjDesc->CommonField.BitLength,
 471                 ObjDesc->CommonField.AccessByteWidth);
 472             break;
 473
 474         default:
 475
 476             break;
 477         }
 478         break;
 479
 480     case ACPI_DISPLAY_OBJECTS:
 481
 482         AcpiOsPrintf ("O:%p", ObjDesc);
 483         if (!ObjDesc)
 484         {
 485             /* No attached object, we are done */
 486
 487             AcpiOsPrintf ("\n");
 488             return (AE_OK);
 489         }
 490
 491         AcpiOsPrintf ("(R%u)", ObjDesc->Common.ReferenceCount);
 492
 493         switch (Type)
 494         {
 495         case ACPI_TYPE_METHOD:
 496
 497             /* Name is a Method and its AML offset/length are set */
 498
 499             AcpiOsPrintf (" M:%p-%X\n", ObjDesc->Method.AmlStart,
 500                 ObjDesc->Method.AmlLength);
 501             break;
 502
 503         case ACPI_TYPE_INTEGER:
 504
 505             AcpiOsPrintf (" I:%8.8X8.8%X\n",
 506                 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
 507             break;
 508
 509         case ACPI_TYPE_STRING:
 510
 511             AcpiOsPrintf (" S:%p-%X\n", ObjDesc->String.Pointer,
 512                 ObjDesc->String.Length);
 513             break;
 514
 515         case ACPI_TYPE_BUFFER:
 516
 517             AcpiOsPrintf (" B:%p-%X\n", ObjDesc->Buffer.Pointer,
 518                 ObjDesc->Buffer.Length);
 519             break;
 520
 521         default:
 522
 523             AcpiOsPrintf ("\n");
 524             break;
 525         }
 526         break;
 527
 528     default:
 529         AcpiOsPrintf ("\n");
 530         break;
 531     }
 532
 533     /* If debug turned off, done */
 534
 535     if (!(AcpiDbgLevel & ACPI_LV_VALUES))
 536     {
 537         return (AE_OK);
 538     }
 539
 540     /* If there is an attached object, display it */
 541
 542     DbgLevel = AcpiDbgLevel;
 543     AcpiDbgLevel = 0;
 544     ObjDesc = AcpiNsGetAttachedObject (ThisNode);
 545     AcpiDbgLevel = DbgLevel;
 546
 547     /* Dump attached objects */
 548
 549     while (ObjDesc)
 550     {
 551         ObjType = ACPI_TYPE_INVALID;
 552         AcpiOsPrintf ("Attached Object %p: ", ObjDesc);
 553
 554         /* Decode the type of attached object and dump the contents */
 555
 556         switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
 557         {
 558         case ACPI_DESC_TYPE_NAMED:
 559
 560             AcpiOsPrintf ("(Ptr to Node)\n");
 561             BytesToDump = sizeof (ACPI_NAMESPACE_NODE);
 562             ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
 563             break;
 564
 565         case ACPI_DESC_TYPE_OPERAND:
 566
 567             ObjType = ObjDesc->Common.Type;
 568
 569             if (ObjType > ACPI_TYPE_LOCAL_MAX)
 570             {
 571                 AcpiOsPrintf (
 572                     "(Pointer to ACPI Object type %.2X [UNKNOWN])\n",
 573                     ObjType);
 574
 575                 BytesToDump = 32;
 576             }
 577             else
 578             {
 579                 AcpiOsPrintf (
 580                     "(Pointer to ACPI Object type %.2X [%s])\n",
 581                     ObjType, AcpiUtGetTypeName (ObjType));
 582
 583                 BytesToDump = sizeof (ACPI_OPERAND_OBJECT);
 584             }
 585
 586             ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
 587             break;
 588
 589         default:
 590
 591             break;
 592         }
 593
 594         /* If value is NOT an internal object, we are done */
 595
 596         if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND)
 597         {
 598             goto Cleanup;
 599         }
 600
 601         /* Valid object, get the pointer to next level, if any */
 602
 603         switch (ObjType)
 604         {
 605         case ACPI_TYPE_BUFFER:
 606         case ACPI_TYPE_STRING:
 607             /*
 608              * NOTE: takes advantage of common fields between string/buffer
 609              */
 610             BytesToDump = ObjDesc->String.Length;
 611             ObjDesc = (void *) ObjDesc->String.Pointer;
 612
 613             AcpiOsPrintf ("(Buffer/String pointer %p length %X)\n",
 614                 ObjDesc, BytesToDump);
 615             ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
 616             goto Cleanup;
 617
 618         case ACPI_TYPE_BUFFER_FIELD:
 619
 620             ObjDesc = (ACPI_OPERAND_OBJECT *) ObjDesc->BufferField.BufferObj;
 621             break;
 622
 623         case ACPI_TYPE_PACKAGE:
 624
 625             ObjDesc = (void *) ObjDesc->Package.Elements;
 626             break;
 627
 628         case ACPI_TYPE_METHOD:
 629
 630             ObjDesc = (void *) ObjDesc->Method.AmlStart;
 631             break;
 632
 633         case ACPI_TYPE_LOCAL_REGION_FIELD:
 634
 635             ObjDesc = (void *) ObjDesc->Field.RegionObj;
 636             break;
 637
 638         case ACPI_TYPE_LOCAL_BANK_FIELD:
 639
 640             ObjDesc = (void *) ObjDesc->BankField.RegionObj;
 641             break;
 642
 643         case ACPI_TYPE_LOCAL_INDEX_FIELD:
 644
 645             ObjDesc = (void *) ObjDesc->IndexField.IndexObj;
 646             break;
 647
 648         default:
 649
 650             goto Cleanup;
 651         }
 652
 653         ObjType = ACPI_TYPE_INVALID;   /* Terminate loop after next pass */
 654     }
 655
 656 Cleanup:
 657     AcpiOsPrintf ("\n");
 658     return (AE_OK);
 659 }
 660
 661
 662 /*******************************************************************************
 663  *
 664  * FUNCTION:    AcpiNsDumpObjects
 665  *
 666  * PARAMETERS:  Type                - Object type to be dumped
 667  *              DisplayType         - 0 or ACPI_DISPLAY_SUMMARY
 668  *              MaxDepth            - Maximum depth of dump. Use ACPI_UINT32_MAX
 669  *                                    for an effectively unlimited depth.
 670  *              OwnerId             - Dump only objects owned by this ID. Use
 671  *                                    ACPI_UINT32_MAX to match all owners.
 672  *              StartHandle         - Where in namespace to start/end search
 673  *
 674  * RETURN:      None
 675  *
 676  * DESCRIPTION: Dump typed objects within the loaded namespace. Uses
 677  *              AcpiNsWalkNamespace in conjunction with AcpiNsDumpOneObject.
 678  *
 679  ******************************************************************************/
 680
 681 void
 682 AcpiNsDumpObjects (
 683     ACPI_OBJECT_TYPE        Type,
 684     UINT8                   DisplayType,
 685     UINT32                  MaxDepth,
 686     ACPI_OWNER_ID           OwnerId,
 687     ACPI_HANDLE             StartHandle)
 688 {
 689     ACPI_WALK_INFO          Info;
 690     ACPI_STATUS             Status;
 691
 692
 693     ACPI_FUNCTION_ENTRY ();
 694
 695
 696     /*
 697      * Just lock the entire namespace for the duration of the dump.
 698      * We don't want any changes to the namespace during this time,
 699      * especially the temporary nodes since we are going to display
 700      * them also.
 701      */
 702     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 703     if (ACPI_FAILURE (Status))
 704     {
 705         AcpiOsPrintf ("Could not acquire namespace mutex\n");
 706         return;
 707     }
 708
 709     Info.DebugLevel = ACPI_LV_TABLES;
 710     Info.OwnerId = OwnerId;
 711     Info.DisplayType = DisplayType;
 712
 713     (void) AcpiNsWalkNamespace (Type, StartHandle, MaxDepth,
 714         ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES,
 715         AcpiNsDumpOneObject, NULL, (void *) &Info, NULL);
 716
 717     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 718 }
 719
 720
 721 /*******************************************************************************
 722  *
 723  * FUNCTION:    AcpiNsDumpOneObjectPath, AcpiNsGetMaxDepth
 724  *
 725  * PARAMETERS:  ObjHandle           - Node to be dumped
 726  *              Level               - Nesting level of the handle
 727  *              Context             - Passed into WalkNamespace
 728  *              ReturnValue         - Not used
 729  *
 730  * RETURN:      Status
 731  *
 732  * DESCRIPTION: Dump the full pathname to a namespace object. AcpNsGetMaxDepth
 733  *              computes the maximum nesting depth in the namespace tree, in
 734  *              order to simplify formatting in AcpiNsDumpOneObjectPath.
 735  *              These procedures are UserFunctions called by AcpiNsWalkNamespace.
 736  *
 737  ******************************************************************************/
 738
 739 static ACPI_STATUS
 740 AcpiNsDumpOneObjectPath (
 741     ACPI_HANDLE             ObjHandle,
 742     UINT32                  Level,
 743     void                    *Context,
 744     void                    **ReturnValue)
 745 {
 746     UINT32                  MaxLevel = *((UINT32 *) Context);
 747     char                    *Pathname;
 748     ACPI_NAMESPACE_NODE     *Node;
 749     int                     PathIndent;
 750
 751
 752     if (!ObjHandle)
 753     {
 754         return (AE_OK);
 755     }
 756
 757     Node = AcpiNsValidateHandle (ObjHandle);
 758     if (!Node)
 759     {
 760         /* Ignore bad node during namespace walk */
 761
 762         return (AE_OK);
 763     }
 764
 765     Pathname = AcpiNsGetNormalizedPathname (Node, TRUE);
 766
 767     PathIndent = 1;
 768     if (Level <= MaxLevel)
 769     {
 770         PathIndent = MaxLevel - Level + 1;
 771     }
 772
 773     AcpiOsPrintf ("%2d%*s%-12s%*s",
 774         Level, Level, " ", AcpiUtGetTypeName (Node->Type),
 775         PathIndent, " ");
 776
 777     AcpiOsPrintf ("%s\n", &Pathname[1]);
 778     ACPI_FREE (Pathname);
 779     return (AE_OK);
 780 }
 781
 782
 783 static ACPI_STATUS
 784 AcpiNsGetMaxDepth (
 785     ACPI_HANDLE             ObjHandle,
 786     UINT32                  Level,
 787     void                    *Context,
 788     void                    **ReturnValue)
 789 {
 790     UINT32                  *MaxLevel = (UINT32 *) Context;
 791
 792
 793     if (Level > *MaxLevel)
 794     {
 795         *MaxLevel = Level;
 796     }
 797     return (AE_OK);
 798 }
 799
 800
 801 /*******************************************************************************
 802  *
 803  * FUNCTION:    AcpiNsDumpObjectPaths
 804  *
 805  * PARAMETERS:  Type                - Object type to be dumped
 806  *              DisplayType         - 0 or ACPI_DISPLAY_SUMMARY
 807  *              MaxDepth            - Maximum depth of dump. Use ACPI_UINT32_MAX
 808  *                                    for an effectively unlimited depth.
 809  *              OwnerId             - Dump only objects owned by this ID. Use
 810  *                                    ACPI_UINT32_MAX to match all owners.
 811  *              StartHandle         - Where in namespace to start/end search
 812  *
 813  * RETURN:      None
 814  *
 815  * DESCRIPTION: Dump full object pathnames within the loaded namespace. Uses
 816  *              AcpiNsWalkNamespace in conjunction with AcpiNsDumpOneObjectPath.
 817  *
 818  ******************************************************************************/
 819
 820 void
 821 AcpiNsDumpObjectPaths (
 822     ACPI_OBJECT_TYPE        Type,
 823     UINT8                   DisplayType,
 824     UINT32                  MaxDepth,
 825     ACPI_OWNER_ID           OwnerId,
 826     ACPI_HANDLE             StartHandle)
 827 {
 828     ACPI_STATUS             Status;
 829     UINT32                  MaxLevel = 0;
 830
 831
 832     ACPI_FUNCTION_ENTRY ();
 833
 834
 835     /*
 836      * Just lock the entire namespace for the duration of the dump.
 837      * We don't want any changes to the namespace during this time,
 838      * especially the temporary nodes since we are going to display
 839      * them also.
 840      */
 841     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 842     if (ACPI_FAILURE (Status))
 843     {
 844         AcpiOsPrintf ("Could not acquire namespace mutex\n");
 845         return;
 846     }
 847
 848     /* Get the max depth of the namespace tree, for formatting later */
 849
 850     (void) AcpiNsWalkNamespace (Type, StartHandle, MaxDepth,
 851         ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES,
 852         AcpiNsGetMaxDepth, NULL, (void *) &MaxLevel, NULL);
 853
 854     /* Now dump the entire namespace */
 855
 856     (void) AcpiNsWalkNamespace (Type, StartHandle, MaxDepth,
 857         ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES,
 858         AcpiNsDumpOneObjectPath, NULL, (void *) &MaxLevel, NULL);
 859
 860     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 861 }
 862
 863
 864 /*******************************************************************************
 865  *
 866  * FUNCTION:    AcpiNsDumpEntry
 867  *
 868  * PARAMETERS:  Handle              - Node to be dumped
 869  *              DebugLevel          - Output level
 870  *
 871  * RETURN:      None
 872  *
 873  * DESCRIPTION: Dump a single Node
 874  *
 875  ******************************************************************************/
 876
 877 void
 878 AcpiNsDumpEntry (
 879     ACPI_HANDLE             Handle,
 880     UINT32                  DebugLevel)
 881 {
 882     ACPI_WALK_INFO          Info;
 883
 884
 885     ACPI_FUNCTION_ENTRY ();
 886
 887
 888     Info.DebugLevel = DebugLevel;
 889     Info.OwnerId = ACPI_OWNER_ID_MAX;
 890     Info.DisplayType = ACPI_DISPLAY_SUMMARY;
 891
 892     (void) AcpiNsDumpOneObject (Handle, 1, &Info, NULL);
 893 }
 894
 895
 896 #ifdef ACPI_ASL_COMPILER
 897 /*******************************************************************************
 898  *
 899  * FUNCTION:    AcpiNsDumpTables
 900  *
 901  * PARAMETERS:  SearchBase          - Root of subtree to be dumped, or
 902  *                                    NS_ALL to dump the entire namespace
 903  *              MaxDepth            - Maximum depth of dump. Use INT_MAX
 904  *                                    for an effectively unlimited depth.
 905  *
 906  * RETURN:      None
 907  *
 908  * DESCRIPTION: Dump the name space, or a portion of it.
 909  *
 910  ******************************************************************************/
 911
 912 void
 913 AcpiNsDumpTables (
 914     ACPI_HANDLE             SearchBase,
 915     UINT32                  MaxDepth)
 916 {
 917     ACPI_HANDLE             SearchHandle = SearchBase;
 918
 919
 920     ACPI_FUNCTION_TRACE (NsDumpTables);
 921
 922
 923     if (!AcpiGbl_RootNode)
 924     {
 925         /*
 926          * If the name space has not been initialized,
 927          * there is nothing to dump.
 928          */
 929         ACPI_DEBUG_PRINT ((ACPI_DB_TABLES,
 930             "namespace not initialized!\n"));
 931         return_VOID;
 932     }
 933
 934     if (ACPI_NS_ALL == SearchBase)
 935     {
 936         /* Entire namespace */
 937
 938         SearchHandle = AcpiGbl_RootNode;
 939         ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "\\\n"));
 940     }
 941
 942     AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, MaxDepth,
 943         ACPI_OWNER_ID_MAX, SearchHandle);
 944     return_VOID;
 945 }
 946 #endif
 947 #endif