1 /****************************************************************************** 2 * 3 * Module Name: nsdump - table dumping routines for debug 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2011, 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 "acpi.h" 47 #include "accommon.h" 48 #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, we are done */ 274 275 AcpiOsPrintf ("\n"); 276 return (AE_OK); 277 } 278 279 switch (Type) 280 { 281 case ACPI_TYPE_PROCESSOR: 282 283 AcpiOsPrintf ("ID %X Len %.4X Addr %p\n", 284 ObjDesc->Processor.ProcId, ObjDesc->Processor.Length, 285 ACPI_CAST_PTR (void, ObjDesc->Processor.Address)); 286 break; 287 288 289 case ACPI_TYPE_DEVICE: 290 291 AcpiOsPrintf ("Notify Object: %p\n", ObjDesc); 292 break; 293 294 295 case ACPI_TYPE_METHOD: 296 297 AcpiOsPrintf ("Args %X Len %.4X Aml %p\n", 298 (UINT32) ObjDesc->Method.ParamCount, 299 ObjDesc->Method.AmlLength, ObjDesc->Method.AmlStart); 300 break; 301 302 303 case ACPI_TYPE_INTEGER: 304 305 AcpiOsPrintf ("= %8.8X%8.8X\n", 306 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 307 break; 308 309 310 case ACPI_TYPE_PACKAGE: 311 312 if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID) 313 { 314 AcpiOsPrintf ("Elements %.2X\n", 315 ObjDesc->Package.Count); 316 } 317 else 318 { 319 AcpiOsPrintf ("[Length not yet evaluated]\n"); 320 } 321 break; 322 323 324 case ACPI_TYPE_BUFFER: 325 326 if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID) 327 { 328 AcpiOsPrintf ("Len %.2X", 329 ObjDesc->Buffer.Length); 330 331 /* Dump some of the buffer */ 332 333 if (ObjDesc->Buffer.Length > 0) 334 { 335 AcpiOsPrintf (" ="); 336 for (i = 0; (i < ObjDesc->Buffer.Length && i < 12); i++) 337 { 338 AcpiOsPrintf (" %.2hX", ObjDesc->Buffer.Pointer[i]); 339 } 340 } 341 AcpiOsPrintf ("\n"); 342 } 343 else 344 { 345 AcpiOsPrintf ("[Length not yet evaluated]\n"); 346 } 347 break; 348 349 350 case ACPI_TYPE_STRING: 351 352 AcpiOsPrintf ("Len %.2X ", ObjDesc->String.Length); 353 AcpiUtPrintString (ObjDesc->String.Pointer, 32); 354 AcpiOsPrintf ("\n"); 355 break; 356 357 358 case ACPI_TYPE_REGION: 359 360 AcpiOsPrintf ("[%s]", 361 AcpiUtGetRegionName (ObjDesc->Region.SpaceId)); 362 if (ObjDesc->Region.Flags & AOPOBJ_DATA_VALID) 363 { 364 AcpiOsPrintf (" Addr %8.8X%8.8X Len %.4X\n", 365 ACPI_FORMAT_NATIVE_UINT (ObjDesc->Region.Address), 366 ObjDesc->Region.Length); 367 } 368 else 369 { 370 AcpiOsPrintf (" [Address/Length not yet evaluated]\n"); 371 } 372 break; 373 374 375 case ACPI_TYPE_LOCAL_REFERENCE: 376 377 AcpiOsPrintf ("[%s]\n", AcpiUtGetReferenceName (ObjDesc)); 378 break; 379 380 381 case ACPI_TYPE_BUFFER_FIELD: 382 383 if (ObjDesc->BufferField.BufferObj && 384 ObjDesc->BufferField.BufferObj->Buffer.Node) 385 { 386 AcpiOsPrintf ("Buf [%4.4s]", 387 AcpiUtGetNodeName ( 388 ObjDesc->BufferField.BufferObj->Buffer.Node)); 389 } 390 break; 391 392 393 case ACPI_TYPE_LOCAL_REGION_FIELD: 394 395 AcpiOsPrintf ("Rgn [%4.4s]", 396 AcpiUtGetNodeName ( 397 ObjDesc->CommonField.RegionObj->Region.Node)); 398 break; 399 400 401 case ACPI_TYPE_LOCAL_BANK_FIELD: 402 403 AcpiOsPrintf ("Rgn [%4.4s] Bnk [%4.4s]", 404 AcpiUtGetNodeName ( 405 ObjDesc->CommonField.RegionObj->Region.Node), 406 AcpiUtGetNodeName ( 407 ObjDesc->BankField.BankObj->CommonField.Node)); 408 break; 409 410 411 case ACPI_TYPE_LOCAL_INDEX_FIELD: 412 413 AcpiOsPrintf ("Idx [%4.4s] Dat [%4.4s]", 414 AcpiUtGetNodeName ( 415 ObjDesc->IndexField.IndexObj->CommonField.Node), 416 AcpiUtGetNodeName ( 417 ObjDesc->IndexField.DataObj->CommonField.Node)); 418 break; 419 420 421 case ACPI_TYPE_LOCAL_ALIAS: 422 case ACPI_TYPE_LOCAL_METHOD_ALIAS: 423 424 AcpiOsPrintf ("Target %4.4s (%p)\n", 425 AcpiUtGetNodeName (ObjDesc), ObjDesc); 426 break; 427 428 default: 429 430 AcpiOsPrintf ("Object %p\n", ObjDesc); 431 break; 432 } 433 434 /* Common field handling */ 435 436 switch (Type) 437 { 438 case ACPI_TYPE_BUFFER_FIELD: 439 case ACPI_TYPE_LOCAL_REGION_FIELD: 440 case ACPI_TYPE_LOCAL_BANK_FIELD: 441 case ACPI_TYPE_LOCAL_INDEX_FIELD: 442 443 AcpiOsPrintf (" Off %.3X Len %.2X Acc %.2hd\n", 444 (ObjDesc->CommonField.BaseByteOffset * 8) 445 + ObjDesc->CommonField.StartFieldBitOffset, 446 ObjDesc->CommonField.BitLength, 447 ObjDesc->CommonField.AccessByteWidth); 448 break; 449 450 default: 451 break; 452 } 453 break; 454 455 456 case ACPI_DISPLAY_OBJECTS: 457 458 AcpiOsPrintf ("O:%p", ObjDesc); 459 if (!ObjDesc) 460 { 461 /* No attached object, we are done */ 462 463 AcpiOsPrintf ("\n"); 464 return (AE_OK); 465 } 466 467 AcpiOsPrintf ("(R%u)", ObjDesc->Common.ReferenceCount); 468 469 switch (Type) 470 { 471 case ACPI_TYPE_METHOD: 472 473 /* Name is a Method and its AML offset/length are set */ 474 475 AcpiOsPrintf (" M:%p-%X\n", ObjDesc->Method.AmlStart, 476 ObjDesc->Method.AmlLength); 477 break; 478 479 case ACPI_TYPE_INTEGER: 480 481 AcpiOsPrintf (" I:%8.8X8.8%X\n", 482 ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value)); 483 break; 484 485 case ACPI_TYPE_STRING: 486 487 AcpiOsPrintf (" S:%p-%X\n", ObjDesc->String.Pointer, 488 ObjDesc->String.Length); 489 break; 490 491 case ACPI_TYPE_BUFFER: 492 493 AcpiOsPrintf (" B:%p-%X\n", ObjDesc->Buffer.Pointer, 494 ObjDesc->Buffer.Length); 495 break; 496 497 default: 498 499 AcpiOsPrintf ("\n"); 500 break; 501 } 502 break; 503 504 505 default: 506 AcpiOsPrintf ("\n"); 507 break; 508 } 509 510 /* If debug turned off, done */ 511 512 if (!(AcpiDbgLevel & ACPI_LV_VALUES)) 513 { 514 return (AE_OK); 515 } 516 517 /* If there is an attached object, display it */ 518 519 DbgLevel = AcpiDbgLevel; 520 AcpiDbgLevel = 0; 521 ObjDesc = AcpiNsGetAttachedObject (ThisNode); 522 AcpiDbgLevel = DbgLevel; 523 524 /* Dump attached objects */ 525 526 while (ObjDesc) 527 { 528 ObjType = ACPI_TYPE_INVALID; 529 AcpiOsPrintf ("Attached Object %p: ", ObjDesc); 530 531 /* Decode the type of attached object and dump the contents */ 532 533 switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc)) 534 { 535 case ACPI_DESC_TYPE_NAMED: 536 537 AcpiOsPrintf ("(Ptr to Node)\n"); 538 BytesToDump = sizeof (ACPI_NAMESPACE_NODE); 539 ACPI_DUMP_BUFFER (ObjDesc, BytesToDump); 540 break; 541 542 case ACPI_DESC_TYPE_OPERAND: 543 544 ObjType = ObjDesc->Common.Type; 545 546 if (ObjType > ACPI_TYPE_LOCAL_MAX) 547 { 548 AcpiOsPrintf ("(Pointer to ACPI Object type %.2X [UNKNOWN])\n", 549 ObjType); 550 BytesToDump = 32; 551 } 552 else 553 { 554 AcpiOsPrintf ("(Pointer to ACPI Object type %.2X [%s])\n", 555 ObjType, AcpiUtGetTypeName (ObjType)); 556 BytesToDump = sizeof (ACPI_OPERAND_OBJECT); 557 } 558 559 ACPI_DUMP_BUFFER (ObjDesc, BytesToDump); 560 break; 561 562 default: 563 564 break; 565 } 566 567 /* If value is NOT an internal object, we are done */ 568 569 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) 570 { 571 goto Cleanup; 572 } 573 574 /* Valid object, get the pointer to next level, if any */ 575 576 switch (ObjType) 577 { 578 case ACPI_TYPE_BUFFER: 579 case ACPI_TYPE_STRING: 580 /* 581 * NOTE: takes advantage of common fields between string/buffer 582 */ 583 BytesToDump = ObjDesc->String.Length; 584 ObjDesc = (void *) ObjDesc->String.Pointer; 585 AcpiOsPrintf ( "(Buffer/String pointer %p length %X)\n", 586 ObjDesc, BytesToDump); 587 ACPI_DUMP_BUFFER (ObjDesc, BytesToDump); 588 goto Cleanup; 589 590 case ACPI_TYPE_BUFFER_FIELD: 591 ObjDesc = (ACPI_OPERAND_OBJECT *) ObjDesc->BufferField.BufferObj; 592 break; 593 594 case ACPI_TYPE_PACKAGE: 595 ObjDesc = (void *) ObjDesc->Package.Elements; 596 break; 597 598 case ACPI_TYPE_METHOD: 599 ObjDesc = (void *) ObjDesc->Method.AmlStart; 600 break; 601 602 case ACPI_TYPE_LOCAL_REGION_FIELD: 603 ObjDesc = (void *) ObjDesc->Field.RegionObj; 604 break; 605 606 case ACPI_TYPE_LOCAL_BANK_FIELD: 607 ObjDesc = (void *) ObjDesc->BankField.RegionObj; 608 break; 609 610 case ACPI_TYPE_LOCAL_INDEX_FIELD: 611 ObjDesc = (void *) ObjDesc->IndexField.IndexObj; 612 break; 613 614 default: 615 goto Cleanup; 616 } 617 618 ObjType = ACPI_TYPE_INVALID; /* Terminate loop after next pass */ 619 } 620 621 Cleanup: 622 AcpiOsPrintf ("\n"); 623 return (AE_OK); 624 } 625 626 627 /******************************************************************************* 628 * 629 * FUNCTION: AcpiNsDumpObjects 630 * 631 * PARAMETERS: Type - Object type to be dumped 632 * DisplayType - 0 or ACPI_DISPLAY_SUMMARY 633 * MaxDepth - Maximum depth of dump. Use ACPI_UINT32_MAX 634 * for an effectively unlimited depth. 635 * OwnerId - Dump only objects owned by this ID. Use 636 * ACPI_UINT32_MAX to match all owners. 637 * StartHandle - Where in namespace to start/end search 638 * 639 * RETURN: None 640 * 641 * DESCRIPTION: Dump typed objects within the loaded namespace. Uses 642 * AcpiNsWalkNamespace in conjunction with AcpiNsDumpOneObject. 643 * 644 ******************************************************************************/ 645 646 void 647 AcpiNsDumpObjects ( 648 ACPI_OBJECT_TYPE Type, 649 UINT8 DisplayType, 650 UINT32 MaxDepth, 651 ACPI_OWNER_ID OwnerId, 652 ACPI_HANDLE StartHandle) 653 { 654 ACPI_WALK_INFO Info; 655 ACPI_STATUS Status; 656 657 658 ACPI_FUNCTION_ENTRY (); 659 660 661 /* 662 * Just lock the entire namespace for the duration of the dump. 663 * We don't want any changes to the namespace during this time, 664 * especially the temporary nodes since we are going to display 665 * them also. 666 */ 667 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 668 if (ACPI_FAILURE (Status)) 669 { 670 AcpiOsPrintf ("Could not acquire namespace mutex\n"); 671 return; 672 } 673 674 Info.DebugLevel = ACPI_LV_TABLES; 675 Info.OwnerId = OwnerId; 676 Info.DisplayType = DisplayType; 677 678 (void) AcpiNsWalkNamespace (Type, StartHandle, MaxDepth, 679 ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES, 680 AcpiNsDumpOneObject, NULL, (void *) &Info, NULL); 681 682 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 683 } 684 685 686 /******************************************************************************* 687 * 688 * FUNCTION: AcpiNsDumpEntry 689 * 690 * PARAMETERS: Handle - Node to be dumped 691 * DebugLevel - Output level 692 * 693 * RETURN: None 694 * 695 * DESCRIPTION: Dump a single Node 696 * 697 ******************************************************************************/ 698 699 void 700 AcpiNsDumpEntry ( 701 ACPI_HANDLE Handle, 702 UINT32 DebugLevel) 703 { 704 ACPI_WALK_INFO Info; 705 706 707 ACPI_FUNCTION_ENTRY (); 708 709 710 Info.DebugLevel = DebugLevel; 711 Info.OwnerId = ACPI_OWNER_ID_MAX; 712 Info.DisplayType = ACPI_DISPLAY_SUMMARY; 713 714 (void) AcpiNsDumpOneObject (Handle, 1, &Info, NULL); 715 } 716 717 718 #ifdef ACPI_ASL_COMPILER 719 /******************************************************************************* 720 * 721 * FUNCTION: AcpiNsDumpTables 722 * 723 * PARAMETERS: SearchBase - Root of subtree to be dumped, or 724 * NS_ALL to dump the entire namespace 725 * MaxDepth - Maximum depth of dump. Use INT_MAX 726 * for an effectively unlimited depth. 727 * 728 * RETURN: None 729 * 730 * DESCRIPTION: Dump the name space, or a portion of it. 731 * 732 ******************************************************************************/ 733 734 void 735 AcpiNsDumpTables ( 736 ACPI_HANDLE SearchBase, 737 UINT32 MaxDepth) 738 { 739 ACPI_HANDLE SearchHandle = SearchBase; 740 741 742 ACPI_FUNCTION_TRACE (NsDumpTables); 743 744 745 if (!AcpiGbl_RootNode) 746 { 747 /* 748 * If the name space has not been initialized, 749 * there is nothing to dump. 750 */ 751 ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "namespace not initialized!\n")); 752 return_VOID; 753 } 754 755 if (ACPI_NS_ALL == SearchBase) 756 { 757 /* Entire namespace */ 758 759 SearchHandle = AcpiGbl_RootNode; 760 ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "\\\n")); 761 } 762 763 AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, MaxDepth, 764 ACPI_OWNER_ID_MAX, SearchHandle); 765 return_VOID; 766 } 767 #endif 768 #endif 769 770