1 /****************************************************************************** 2 * 3 * Module Name: nsdump - table dumping routines for debug 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2012, 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 #define __NSDUMP_C__ 45 46 #include <contrib/dev/acpica/include/acpi.h> 47 #include <contrib/dev/acpica/include/accommon.h> 48 #include <contrib/dev/acpica/include/acnamesp.h> 49 50 51 #define _COMPONENT ACPI_NAMESPACE 52 ACPI_MODULE_NAME ("nsdump") 53 54 /* Local prototypes */ 55 56 #ifdef ACPI_OBSOLETE_FUNCTIONS 57 void 58 AcpiNsDumpRootDevices ( 59 void); 60 61 static ACPI_STATUS 62 AcpiNsDumpOneDevice ( 63 ACPI_HANDLE ObjHandle, 64 UINT32 Level, 65 void *Context, 66 void **ReturnValue); 67 #endif 68 69 70 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 71 /******************************************************************************* 72 * 73 * FUNCTION: AcpiNsPrintPathname 74 * 75 * PARAMETERS: NumSegments - Number of ACPI name segments 76 * Pathname - The compressed (internal) path 77 * 78 * RETURN: None 79 * 80 * DESCRIPTION: Print an object's full namespace pathname 81 * 82 ******************************************************************************/ 83 84 void 85 AcpiNsPrintPathname ( 86 UINT32 NumSegments, 87 char *Pathname) 88 { 89 UINT32 i; 90 91 92 ACPI_FUNCTION_NAME (NsPrintPathname); 93 94 95 if (!(AcpiDbgLevel & ACPI_LV_NAMES) || !(AcpiDbgLayer & ACPI_NAMESPACE)) 96 { 97 return; 98 } 99 100 /* Print the entire name */ 101 102 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "[")); 103 104 while (NumSegments) 105 { 106 for (i = 0; i < 4; i++) 107 { 108 ACPI_IS_PRINT (Pathname[i]) ? 109 AcpiOsPrintf ("%c", Pathname[i]) : 110 AcpiOsPrintf ("?"); 111 } 112 113 Pathname += ACPI_NAME_SIZE; 114 NumSegments--; 115 if (NumSegments) 116 { 117 AcpiOsPrintf ("."); 118 } 119 } 120 121 AcpiOsPrintf ("]\n"); 122 } 123 124 125 /******************************************************************************* 126 * 127 * FUNCTION: AcpiNsDumpPathname 128 * 129 * PARAMETERS: Handle - Object 130 * Msg - Prefix message 131 * Level - Desired debug level 132 * Component - Caller's component ID 133 * 134 * RETURN: None 135 * 136 * DESCRIPTION: Print an object's full namespace pathname 137 * Manages allocation/freeing of a pathname buffer 138 * 139 ******************************************************************************/ 140 141 void 142 AcpiNsDumpPathname ( 143 ACPI_HANDLE Handle, 144 char *Msg, 145 UINT32 Level, 146 UINT32 Component) 147 { 148 149 ACPI_FUNCTION_TRACE (NsDumpPathname); 150 151 152 /* Do this only if the requested debug level and component are enabled */ 153 154 if (!(AcpiDbgLevel & Level) || !(AcpiDbgLayer & Component)) 155 { 156 return_VOID; 157 } 158 159 /* Convert handle to a full pathname and print it (with supplied message) */ 160 161 AcpiNsPrintNodePathname (Handle, Msg); 162 AcpiOsPrintf ("\n"); 163 return_VOID; 164 } 165 166 167 /******************************************************************************* 168 * 169 * FUNCTION: AcpiNsDumpOneObject 170 * 171 * PARAMETERS: ObjHandle - Node to be dumped 172 * Level - Nesting level of the handle 173 * Context - Passed into WalkNamespace 174 * ReturnValue - Not used 175 * 176 * RETURN: Status 177 * 178 * DESCRIPTION: Dump a single Node 179 * This procedure is a UserFunction called by AcpiNsWalkNamespace. 180 * 181 ******************************************************************************/ 182 183 ACPI_STATUS 184 AcpiNsDumpOneObject ( 185 ACPI_HANDLE ObjHandle, 186 UINT32 Level, 187 void *Context, 188 void **ReturnValue) 189 { 190 ACPI_WALK_INFO *Info = (ACPI_WALK_INFO *) Context; 191 ACPI_NAMESPACE_NODE *ThisNode; 192 ACPI_OPERAND_OBJECT *ObjDesc = NULL; 193 ACPI_OBJECT_TYPE ObjType; 194 ACPI_OBJECT_TYPE Type; 195 UINT32 BytesToDump; 196 UINT32 DbgLevel; 197 UINT32 i; 198 199 200 ACPI_FUNCTION_NAME (NsDumpOneObject); 201 202 203 /* Is output enabled? */ 204 205 if (!(AcpiDbgLevel & Info->DebugLevel)) 206 { 207 return (AE_OK); 208 } 209 210 if (!ObjHandle) 211 { 212 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null object handle\n")); 213 return (AE_OK); 214 } 215 216 ThisNode = AcpiNsValidateHandle (ObjHandle); 217 if (!ThisNode) 218 { 219 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Invalid object handle %p\n", 220 ObjHandle)); 221 return (AE_OK); 222 } 223 224 Type = ThisNode->Type; 225 226 /* Check if the owner matches */ 227 228 if ((Info->OwnerId != ACPI_OWNER_ID_MAX) && 229 (Info->OwnerId != ThisNode->OwnerId)) 230 { 231 return (AE_OK); 232 } 233 234 if (!(Info->DisplayType & ACPI_DISPLAY_SHORT)) 235 { 236 /* Indent the object according to the level */ 237 238 AcpiOsPrintf ("%2d%*s", (UINT32) Level - 1, (int) Level * 2, " "); 239 240 /* Check the node type and name */ 241 242 if (Type > ACPI_TYPE_LOCAL_MAX) 243 { 244 ACPI_WARNING ((AE_INFO, "Invalid ACPI Object Type 0x%08X", Type)); 245 } 246 247 AcpiOsPrintf ("%4.4s", AcpiUtGetNodeName (ThisNode)); 248 } 249 250 /* Now we can print out the pertinent information */ 251 252 AcpiOsPrintf (" %-12s %p %2.2X ", 253 AcpiUtGetTypeName (Type), ThisNode, ThisNode->OwnerId); 254 255 DbgLevel = AcpiDbgLevel; 256 AcpiDbgLevel = 0; 257 ObjDesc = AcpiNsGetAttachedObject (ThisNode); 258 AcpiDbgLevel = DbgLevel; 259 260 /* Temp nodes are those nodes created by a control method */ 261 262 if (ThisNode->Flags & ANOBJ_TEMPORARY) 263 { 264 AcpiOsPrintf ("(T) "); 265 } 266 267 switch (Info->DisplayType & ACPI_DISPLAY_MASK) 268 { 269 case ACPI_DISPLAY_SUMMARY: 270 271 if (!ObjDesc) 272 { 273 /* No attached object. Some types should always have an object */ 274 275 switch (Type) 276 { 277 case ACPI_TYPE_INTEGER: 278 case ACPI_TYPE_PACKAGE: 279 case ACPI_TYPE_BUFFER: 280 case ACPI_TYPE_STRING: 281 case ACPI_TYPE_METHOD: 282 AcpiOsPrintf ("<No attached object>"); 283 break; 284 285 default: 286 break; 287 } 288 289 AcpiOsPrintf ("\n"); 290 return (AE_OK); 291 } 292 293 switch (Type) 294 { 295 case ACPI_TYPE_PROCESSOR: 296 297 AcpiOsPrintf ("ID %02X Len %02X Addr %p\n", 298 ObjDesc->Processor.ProcId, ObjDesc->Processor.Length, 299 ACPI_CAST_PTR (void, ObjDesc->Processor.Address)); 300 break; 301 302 303 case ACPI_TYPE_DEVICE: 304 305 AcpiOsPrintf ("Notify Object: %p\n", ObjDesc); 306 break; 307 308 309 case ACPI_TYPE_METHOD: 310 311 AcpiOsPrintf ("Args %X Len %.4X Aml %p\n", 312 (UINT32) ObjDesc->Method.ParamCount, 313 ObjDesc->Method.AmlLength, ObjDesc->Method.AmlStart); 314 break; 315 316 317 case ACPI_TYPE_INTEGER: 318 319 AcpiOsPrintf ("= %8.8X%8.8X\n", 320 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 321 break; 322 323 324 case ACPI_TYPE_PACKAGE: 325 326 if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID) 327 { 328 AcpiOsPrintf ("Elements %.2X\n", 329 ObjDesc->Package.Count); 330 } 331 else 332 { 333 AcpiOsPrintf ("[Length not yet evaluated]\n"); 334 } 335 break; 336 337 338 case ACPI_TYPE_BUFFER: 339 340 if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID) 341 { 342 AcpiOsPrintf ("Len %.2X", 343 ObjDesc->Buffer.Length); 344 345 /* Dump some of the buffer */ 346 347 if (ObjDesc->Buffer.Length > 0) 348 { 349 AcpiOsPrintf (" ="); 350 for (i = 0; (i < ObjDesc->Buffer.Length && i < 12); i++) 351 { 352 AcpiOsPrintf (" %.2hX", ObjDesc->Buffer.Pointer[i]); 353 } 354 } 355 AcpiOsPrintf ("\n"); 356 } 357 else 358 { 359 AcpiOsPrintf ("[Length not yet evaluated]\n"); 360 } 361 break; 362 363 364 case ACPI_TYPE_STRING: 365 366 AcpiOsPrintf ("Len %.2X ", ObjDesc->String.Length); 367 AcpiUtPrintString (ObjDesc->String.Pointer, 32); 368 AcpiOsPrintf ("\n"); 369 break; 370 371 372 case ACPI_TYPE_REGION: 373 374 AcpiOsPrintf ("[%s]", 375 AcpiUtGetRegionName (ObjDesc->Region.SpaceId)); 376 if (ObjDesc->Region.Flags & AOPOBJ_DATA_VALID) 377 { 378 AcpiOsPrintf (" Addr %8.8X%8.8X Len %.4X\n", 379 ACPI_FORMAT_NATIVE_UINT (ObjDesc->Region.Address), 380 ObjDesc->Region.Length); 381 } 382 else 383 { 384 AcpiOsPrintf (" [Address/Length not yet evaluated]\n"); 385 } 386 break; 387 388 389 case ACPI_TYPE_LOCAL_REFERENCE: 390 391 AcpiOsPrintf ("[%s]\n", AcpiUtGetReferenceName (ObjDesc)); 392 break; 393 394 395 case ACPI_TYPE_BUFFER_FIELD: 396 397 if (ObjDesc->BufferField.BufferObj && 398 ObjDesc->BufferField.BufferObj->Buffer.Node) 399 { 400 AcpiOsPrintf ("Buf [%4.4s]", 401 AcpiUtGetNodeName ( 402 ObjDesc->BufferField.BufferObj->Buffer.Node)); 403 } 404 break; 405 406 407 case ACPI_TYPE_LOCAL_REGION_FIELD: 408 409 AcpiOsPrintf ("Rgn [%4.4s]", 410 AcpiUtGetNodeName ( 411 ObjDesc->CommonField.RegionObj->Region.Node)); 412 break; 413 414 415 case ACPI_TYPE_LOCAL_BANK_FIELD: 416 417 AcpiOsPrintf ("Rgn [%4.4s] Bnk [%4.4s]", 418 AcpiUtGetNodeName ( 419 ObjDesc->CommonField.RegionObj->Region.Node), 420 AcpiUtGetNodeName ( 421 ObjDesc->BankField.BankObj->CommonField.Node)); 422 break; 423 424 425 case ACPI_TYPE_LOCAL_INDEX_FIELD: 426 427 AcpiOsPrintf ("Idx [%4.4s] Dat [%4.4s]", 428 AcpiUtGetNodeName ( 429 ObjDesc->IndexField.IndexObj->CommonField.Node), 430 AcpiUtGetNodeName ( 431 ObjDesc->IndexField.DataObj->CommonField.Node)); 432 break; 433 434 435 case ACPI_TYPE_LOCAL_ALIAS: 436 case ACPI_TYPE_LOCAL_METHOD_ALIAS: 437 438 AcpiOsPrintf ("Target %4.4s (%p)\n", 439 AcpiUtGetNodeName (ObjDesc), ObjDesc); 440 break; 441 442 default: 443 444 AcpiOsPrintf ("Object %p\n", ObjDesc); 445 break; 446 } 447 448 /* Common field handling */ 449 450 switch (Type) 451 { 452 case ACPI_TYPE_BUFFER_FIELD: 453 case ACPI_TYPE_LOCAL_REGION_FIELD: 454 case ACPI_TYPE_LOCAL_BANK_FIELD: 455 case ACPI_TYPE_LOCAL_INDEX_FIELD: 456 457 AcpiOsPrintf (" Off %.3X Len %.2X Acc %.2hd\n", 458 (ObjDesc->CommonField.BaseByteOffset * 8) 459 + ObjDesc->CommonField.StartFieldBitOffset, 460 ObjDesc->CommonField.BitLength, 461 ObjDesc->CommonField.AccessByteWidth); 462 break; 463 464 default: 465 break; 466 } 467 break; 468 469 470 case ACPI_DISPLAY_OBJECTS: 471 472 AcpiOsPrintf ("O:%p", ObjDesc); 473 if (!ObjDesc) 474 { 475 /* No attached object, we are done */ 476 477 AcpiOsPrintf ("\n"); 478 return (AE_OK); 479 } 480 481 AcpiOsPrintf ("(R%u)", ObjDesc->Common.ReferenceCount); 482 483 switch (Type) 484 { 485 case ACPI_TYPE_METHOD: 486 487 /* Name is a Method and its AML offset/length are set */ 488 489 AcpiOsPrintf (" M:%p-%X\n", ObjDesc->Method.AmlStart, 490 ObjDesc->Method.AmlLength); 491 break; 492 493 case ACPI_TYPE_INTEGER: 494 495 AcpiOsPrintf (" I:%8.8X8.8%X\n", 496 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 497 break; 498 499 case ACPI_TYPE_STRING: 500 501 AcpiOsPrintf (" S:%p-%X\n", ObjDesc->String.Pointer, 502 ObjDesc->String.Length); 503 break; 504 505 case ACPI_TYPE_BUFFER: 506 507 AcpiOsPrintf (" B:%p-%X\n", ObjDesc->Buffer.Pointer, 508 ObjDesc->Buffer.Length); 509 break; 510 511 default: 512 513 AcpiOsPrintf ("\n"); 514 break; 515 } 516 break; 517 518 519 default: 520 AcpiOsPrintf ("\n"); 521 break; 522 } 523 524 /* If debug turned off, done */ 525 526 if (!(AcpiDbgLevel & ACPI_LV_VALUES)) 527 { 528 return (AE_OK); 529 } 530 531 /* If there is an attached object, display it */ 532 533 DbgLevel = AcpiDbgLevel; 534 AcpiDbgLevel = 0; 535 ObjDesc = AcpiNsGetAttachedObject (ThisNode); 536 AcpiDbgLevel = DbgLevel; 537 538 /* Dump attached objects */ 539 540 while (ObjDesc) 541 { 542 ObjType = ACPI_TYPE_INVALID; 543 AcpiOsPrintf ("Attached Object %p: ", ObjDesc); 544 545 /* Decode the type of attached object and dump the contents */ 546 547 switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc)) 548 { 549 case ACPI_DESC_TYPE_NAMED: 550 551 AcpiOsPrintf ("(Ptr to Node)\n"); 552 BytesToDump = sizeof (ACPI_NAMESPACE_NODE); 553 ACPI_DUMP_BUFFER (ObjDesc, BytesToDump); 554 break; 555 556 case ACPI_DESC_TYPE_OPERAND: 557 558 ObjType = ObjDesc->Common.Type; 559 560 if (ObjType > ACPI_TYPE_LOCAL_MAX) 561 { 562 AcpiOsPrintf ("(Pointer to ACPI Object type %.2X [UNKNOWN])\n", 563 ObjType); 564 BytesToDump = 32; 565 } 566 else 567 { 568 AcpiOsPrintf ("(Pointer to ACPI Object type %.2X [%s])\n", 569 ObjType, AcpiUtGetTypeName (ObjType)); 570 BytesToDump = sizeof (ACPI_OPERAND_OBJECT); 571 } 572 573 ACPI_DUMP_BUFFER (ObjDesc, BytesToDump); 574 break; 575 576 default: 577 578 break; 579 } 580 581 /* If value is NOT an internal object, we are done */ 582 583 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) 584 { 585 goto Cleanup; 586 } 587 588 /* Valid object, get the pointer to next level, if any */ 589 590 switch (ObjType) 591 { 592 case ACPI_TYPE_BUFFER: 593 case ACPI_TYPE_STRING: 594 /* 595 * NOTE: takes advantage of common fields between string/buffer 596 */ 597 BytesToDump = ObjDesc->String.Length; 598 ObjDesc = (void *) ObjDesc->String.Pointer; 599 AcpiOsPrintf ( "(Buffer/String pointer %p length %X)\n", 600 ObjDesc, BytesToDump); 601 ACPI_DUMP_BUFFER (ObjDesc, BytesToDump); 602 goto Cleanup; 603 604 case ACPI_TYPE_BUFFER_FIELD: 605 ObjDesc = (ACPI_OPERAND_OBJECT *) ObjDesc->BufferField.BufferObj; 606 break; 607 608 case ACPI_TYPE_PACKAGE: 609 ObjDesc = (void *) ObjDesc->Package.Elements; 610 break; 611 612 case ACPI_TYPE_METHOD: 613 ObjDesc = (void *) ObjDesc->Method.AmlStart; 614 break; 615 616 case ACPI_TYPE_LOCAL_REGION_FIELD: 617 ObjDesc = (void *) ObjDesc->Field.RegionObj; 618 break; 619 620 case ACPI_TYPE_LOCAL_BANK_FIELD: 621 ObjDesc = (void *) ObjDesc->BankField.RegionObj; 622 break; 623 624 case ACPI_TYPE_LOCAL_INDEX_FIELD: 625 ObjDesc = (void *) ObjDesc->IndexField.IndexObj; 626 break; 627 628 default: 629 goto Cleanup; 630 } 631 632 ObjType = ACPI_TYPE_INVALID; /* Terminate loop after next pass */ 633 } 634 635 Cleanup: 636 AcpiOsPrintf ("\n"); 637 return (AE_OK); 638 } 639 640 641 /******************************************************************************* 642 * 643 * FUNCTION: AcpiNsDumpObjects 644 * 645 * PARAMETERS: Type - Object type to be dumped 646 * DisplayType - 0 or ACPI_DISPLAY_SUMMARY 647 * MaxDepth - Maximum depth of dump. Use ACPI_UINT32_MAX 648 * for an effectively unlimited depth. 649 * OwnerId - Dump only objects owned by this ID. Use 650 * ACPI_UINT32_MAX to match all owners. 651 * StartHandle - Where in namespace to start/end search 652 * 653 * RETURN: None 654 * 655 * DESCRIPTION: Dump typed objects within the loaded namespace. Uses 656 * AcpiNsWalkNamespace in conjunction with AcpiNsDumpOneObject. 657 * 658 ******************************************************************************/ 659 660 void 661 AcpiNsDumpObjects ( 662 ACPI_OBJECT_TYPE Type, 663 UINT8 DisplayType, 664 UINT32 MaxDepth, 665 ACPI_OWNER_ID OwnerId, 666 ACPI_HANDLE StartHandle) 667 { 668 ACPI_WALK_INFO Info; 669 ACPI_STATUS Status; 670 671 672 ACPI_FUNCTION_ENTRY (); 673 674 675 /* 676 * Just lock the entire namespace for the duration of the dump. 677 * We don't want any changes to the namespace during this time, 678 * especially the temporary nodes since we are going to display 679 * them also. 680 */ 681 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 682 if (ACPI_FAILURE (Status)) 683 { 684 AcpiOsPrintf ("Could not acquire namespace mutex\n"); 685 return; 686 } 687 688 Info.DebugLevel = ACPI_LV_TABLES; 689 Info.OwnerId = OwnerId; 690 Info.DisplayType = DisplayType; 691 692 (void) AcpiNsWalkNamespace (Type, StartHandle, MaxDepth, 693 ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES, 694 AcpiNsDumpOneObject, NULL, (void *) &Info, NULL); 695 696 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 697 } 698 699 700 /******************************************************************************* 701 * 702 * FUNCTION: AcpiNsDumpEntry 703 * 704 * PARAMETERS: Handle - Node to be dumped 705 * DebugLevel - Output level 706 * 707 * RETURN: None 708 * 709 * DESCRIPTION: Dump a single Node 710 * 711 ******************************************************************************/ 712 713 void 714 AcpiNsDumpEntry ( 715 ACPI_HANDLE Handle, 716 UINT32 DebugLevel) 717 { 718 ACPI_WALK_INFO Info; 719 720 721 ACPI_FUNCTION_ENTRY (); 722 723 724 Info.DebugLevel = DebugLevel; 725 Info.OwnerId = ACPI_OWNER_ID_MAX; 726 Info.DisplayType = ACPI_DISPLAY_SUMMARY; 727 728 (void) AcpiNsDumpOneObject (Handle, 1, &Info, NULL); 729 } 730 731 732 #ifdef ACPI_ASL_COMPILER 733 /******************************************************************************* 734 * 735 * FUNCTION: AcpiNsDumpTables 736 * 737 * PARAMETERS: SearchBase - Root of subtree to be dumped, or 738 * NS_ALL to dump the entire namespace 739 * MaxDepth - Maximum depth of dump. Use INT_MAX 740 * for an effectively unlimited depth. 741 * 742 * RETURN: None 743 * 744 * DESCRIPTION: Dump the name space, or a portion of it. 745 * 746 ******************************************************************************/ 747 748 void 749 AcpiNsDumpTables ( 750 ACPI_HANDLE SearchBase, 751 UINT32 MaxDepth) 752 { 753 ACPI_HANDLE SearchHandle = SearchBase; 754 755 756 ACPI_FUNCTION_TRACE (NsDumpTables); 757 758 759 if (!AcpiGbl_RootNode) 760 { 761 /* 762 * If the name space has not been initialized, 763 * there is nothing to dump. 764 */ 765 ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "namespace not initialized!\n")); 766 return_VOID; 767 } 768 769 if (ACPI_NS_ALL == SearchBase) 770 { 771 /* Entire namespace */ 772 773 SearchHandle = AcpiGbl_RootNode; 774 ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "\\\n")); 775 } 776 777 AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, MaxDepth, 778 ACPI_OWNER_ID_MAX, SearchHandle); 779 return_VOID; 780 } 781 #endif 782 #endif 783