1 /****************************************************************************** 2 * 3 * Module Name: nsdump - table dumping routines for debug 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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/acpi.h> 45 #include "accommon.h" 46 #include "acnamesp.h" 47 #include <acpi/acoutput.h> 48 49 #define _COMPONENT ACPI_NAMESPACE 50 ACPI_MODULE_NAME("nsdump") 51 52 /* Local prototypes */ 53 #ifdef ACPI_OBSOLETE_FUNCTIONS 54 void acpi_ns_dump_root_devices(void); 55 56 static acpi_status 57 acpi_ns_dump_one_device(acpi_handle obj_handle, 58 u32 level, void *context, void **return_value); 59 #endif 60 61 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 62 63 #ifdef ACPI_FUTURE_USAGE 64 static acpi_status 65 acpi_ns_dump_one_object_path(acpi_handle obj_handle, 66 u32 level, void *context, void **return_value); 67 68 static acpi_status 69 acpi_ns_get_max_depth(acpi_handle obj_handle, 70 u32 level, void *context, void **return_value); 71 #endif /* ACPI_FUTURE_USAGE */ 72 73 /******************************************************************************* 74 * 75 * FUNCTION: acpi_ns_print_pathname 76 * 77 * PARAMETERS: num_segments - Number of ACPI name segments 78 * pathname - The compressed (internal) path 79 * 80 * RETURN: None 81 * 82 * DESCRIPTION: Print an object's full namespace pathname 83 * 84 ******************************************************************************/ 85 86 void acpi_ns_print_pathname(u32 num_segments, char *pathname) 87 { 88 u32 i; 89 90 ACPI_FUNCTION_NAME(ns_print_pathname); 91 92 /* Check if debug output enabled */ 93 94 if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_NAMES, ACPI_NAMESPACE)) { 95 return; 96 } 97 98 /* Print the entire name */ 99 100 ACPI_DEBUG_PRINT((ACPI_DB_NAMES, "[")); 101 102 while (num_segments) { 103 for (i = 0; i < 4; i++) { 104 ACPI_IS_PRINT(pathname[i]) ? 105 acpi_os_printf("%c", pathname[i]) : 106 acpi_os_printf("?"); 107 } 108 109 pathname += ACPI_NAME_SIZE; 110 num_segments--; 111 if (num_segments) { 112 acpi_os_printf("."); 113 } 114 } 115 116 acpi_os_printf("]\n"); 117 } 118 119 /******************************************************************************* 120 * 121 * FUNCTION: acpi_ns_dump_pathname 122 * 123 * PARAMETERS: handle - Object 124 * msg - Prefix message 125 * level - Desired debug level 126 * component - Caller's component ID 127 * 128 * RETURN: None 129 * 130 * DESCRIPTION: Print an object's full namespace pathname 131 * Manages allocation/freeing of a pathname buffer 132 * 133 ******************************************************************************/ 134 135 void 136 acpi_ns_dump_pathname(acpi_handle handle, char *msg, u32 level, u32 component) 137 { 138 139 ACPI_FUNCTION_TRACE(ns_dump_pathname); 140 141 /* Do this only if the requested debug level and component are enabled */ 142 143 if (!ACPI_IS_DEBUG_ENABLED(level, component)) { 144 return_VOID; 145 } 146 147 /* Convert handle to a full pathname and print it (with supplied message) */ 148 149 acpi_ns_print_node_pathname(handle, msg); 150 acpi_os_printf("\n"); 151 return_VOID; 152 } 153 154 /******************************************************************************* 155 * 156 * FUNCTION: acpi_ns_dump_one_object 157 * 158 * PARAMETERS: obj_handle - Node to be dumped 159 * level - Nesting level of the handle 160 * context - Passed into walk_namespace 161 * return_value - Not used 162 * 163 * RETURN: Status 164 * 165 * DESCRIPTION: Dump a single Node 166 * This procedure is a user_function called by acpi_ns_walk_namespace. 167 * 168 ******************************************************************************/ 169 170 acpi_status 171 acpi_ns_dump_one_object(acpi_handle obj_handle, 172 u32 level, void *context, void **return_value) 173 { 174 struct acpi_walk_info *info = (struct acpi_walk_info *)context; 175 struct acpi_namespace_node *this_node; 176 union acpi_operand_object *obj_desc = NULL; 177 acpi_object_type obj_type; 178 acpi_object_type type; 179 u32 bytes_to_dump; 180 u32 dbg_level; 181 u32 i; 182 183 ACPI_FUNCTION_NAME(ns_dump_one_object); 184 185 /* Is output enabled? */ 186 187 if (!(acpi_dbg_level & info->debug_level)) { 188 return (AE_OK); 189 } 190 191 if (!obj_handle) { 192 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Null object handle\n")); 193 return (AE_OK); 194 } 195 196 this_node = acpi_ns_validate_handle(obj_handle); 197 if (!this_node) { 198 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Invalid object handle %p\n", 199 obj_handle)); 200 return (AE_OK); 201 } 202 203 type = this_node->type; 204 205 /* Check if the owner matches */ 206 207 if ((info->owner_id != ACPI_OWNER_ID_MAX) && 208 (info->owner_id != this_node->owner_id)) { 209 return (AE_OK); 210 } 211 212 if (!(info->display_type & ACPI_DISPLAY_SHORT)) { 213 214 /* Indent the object according to the level */ 215 216 acpi_os_printf("%2d%*s", (u32) level - 1, (int)level * 2, " "); 217 218 /* Check the node type and name */ 219 220 if (type > ACPI_TYPE_LOCAL_MAX) { 221 ACPI_WARNING((AE_INFO, 222 "Invalid ACPI Object Type 0x%08X", type)); 223 } 224 225 acpi_os_printf("%4.4s", acpi_ut_get_node_name(this_node)); 226 } 227 228 /* Now we can print out the pertinent information */ 229 230 acpi_os_printf(" %-12s %p %2.2X ", 231 acpi_ut_get_type_name(type), this_node, 232 this_node->owner_id); 233 234 dbg_level = acpi_dbg_level; 235 acpi_dbg_level = 0; 236 obj_desc = acpi_ns_get_attached_object(this_node); 237 acpi_dbg_level = dbg_level; 238 239 /* Temp nodes are those nodes created by a control method */ 240 241 if (this_node->flags & ANOBJ_TEMPORARY) { 242 acpi_os_printf("(T) "); 243 } 244 245 switch (info->display_type & ACPI_DISPLAY_MASK) { 246 case ACPI_DISPLAY_SUMMARY: 247 248 if (!obj_desc) { 249 250 /* No attached object. Some types should always have an object */ 251 252 switch (type) { 253 case ACPI_TYPE_INTEGER: 254 case ACPI_TYPE_PACKAGE: 255 case ACPI_TYPE_BUFFER: 256 case ACPI_TYPE_STRING: 257 case ACPI_TYPE_METHOD: 258 259 acpi_os_printf("<No attached object>"); 260 break; 261 262 default: 263 264 break; 265 } 266 267 acpi_os_printf("\n"); 268 return (AE_OK); 269 } 270 271 switch (type) { 272 case ACPI_TYPE_PROCESSOR: 273 274 acpi_os_printf("ID %02X Len %02X Addr %p\n", 275 obj_desc->processor.proc_id, 276 obj_desc->processor.length, 277 ACPI_CAST_PTR(void, 278 obj_desc->processor. 279 address)); 280 break; 281 282 case ACPI_TYPE_DEVICE: 283 284 acpi_os_printf("Notify Object: %p\n", obj_desc); 285 break; 286 287 case ACPI_TYPE_METHOD: 288 289 acpi_os_printf("Args %X Len %.4X Aml %p\n", 290 (u32) obj_desc->method.param_count, 291 obj_desc->method.aml_length, 292 obj_desc->method.aml_start); 293 break; 294 295 case ACPI_TYPE_INTEGER: 296 297 acpi_os_printf("= %8.8X%8.8X\n", 298 ACPI_FORMAT_UINT64(obj_desc->integer. 299 value)); 300 break; 301 302 case ACPI_TYPE_PACKAGE: 303 304 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) { 305 acpi_os_printf("Elements %.2X\n", 306 obj_desc->package.count); 307 } else { 308 acpi_os_printf("[Length not yet evaluated]\n"); 309 } 310 break; 311 312 case ACPI_TYPE_BUFFER: 313 314 if (obj_desc->common.flags & AOPOBJ_DATA_VALID) { 315 acpi_os_printf("Len %.2X", 316 obj_desc->buffer.length); 317 318 /* Dump some of the buffer */ 319 320 if (obj_desc->buffer.length > 0) { 321 acpi_os_printf(" ="); 322 for (i = 0; 323 (i < obj_desc->buffer.length 324 && i < 12); i++) { 325 acpi_os_printf(" %.2hX", 326 obj_desc->buffer. 327 pointer[i]); 328 } 329 } 330 acpi_os_printf("\n"); 331 } else { 332 acpi_os_printf("[Length not yet evaluated]\n"); 333 } 334 break; 335 336 case ACPI_TYPE_STRING: 337 338 acpi_os_printf("Len %.2X ", obj_desc->string.length); 339 acpi_ut_print_string(obj_desc->string.pointer, 32); 340 acpi_os_printf("\n"); 341 break; 342 343 case ACPI_TYPE_REGION: 344 345 acpi_os_printf("[%s]", 346 acpi_ut_get_region_name(obj_desc->region. 347 space_id)); 348 if (obj_desc->region.flags & AOPOBJ_DATA_VALID) { 349 acpi_os_printf(" Addr %8.8X%8.8X Len %.4X\n", 350 ACPI_FORMAT_NATIVE_UINT 351 (obj_desc->region.address), 352 obj_desc->region.length); 353 } else { 354 acpi_os_printf 355 (" [Address/Length not yet evaluated]\n"); 356 } 357 break; 358 359 case ACPI_TYPE_LOCAL_REFERENCE: 360 361 acpi_os_printf("[%s]\n", 362 acpi_ut_get_reference_name(obj_desc)); 363 break; 364 365 case ACPI_TYPE_BUFFER_FIELD: 366 367 if (obj_desc->buffer_field.buffer_obj && 368 obj_desc->buffer_field.buffer_obj->buffer.node) { 369 acpi_os_printf("Buf [%4.4s]", 370 acpi_ut_get_node_name(obj_desc-> 371 buffer_field. 372 buffer_obj-> 373 buffer. 374 node)); 375 } 376 break; 377 378 case ACPI_TYPE_LOCAL_REGION_FIELD: 379 380 acpi_os_printf("Rgn [%4.4s]", 381 acpi_ut_get_node_name(obj_desc-> 382 common_field. 383 region_obj->region. 384 node)); 385 break; 386 387 case ACPI_TYPE_LOCAL_BANK_FIELD: 388 389 acpi_os_printf("Rgn [%4.4s] Bnk [%4.4s]", 390 acpi_ut_get_node_name(obj_desc-> 391 common_field. 392 region_obj->region. 393 node), 394 acpi_ut_get_node_name(obj_desc-> 395 bank_field. 396 bank_obj-> 397 common_field. 398 node)); 399 break; 400 401 case ACPI_TYPE_LOCAL_INDEX_FIELD: 402 403 acpi_os_printf("Idx [%4.4s] Dat [%4.4s]", 404 acpi_ut_get_node_name(obj_desc-> 405 index_field. 406 index_obj-> 407 common_field.node), 408 acpi_ut_get_node_name(obj_desc-> 409 index_field. 410 data_obj-> 411 common_field. 412 node)); 413 break; 414 415 case ACPI_TYPE_LOCAL_ALIAS: 416 case ACPI_TYPE_LOCAL_METHOD_ALIAS: 417 418 acpi_os_printf("Target %4.4s (%p)\n", 419 acpi_ut_get_node_name(obj_desc), 420 obj_desc); 421 break; 422 423 default: 424 425 acpi_os_printf("Object %p\n", obj_desc); 426 break; 427 } 428 429 /* Common field handling */ 430 431 switch (type) { 432 case ACPI_TYPE_BUFFER_FIELD: 433 case ACPI_TYPE_LOCAL_REGION_FIELD: 434 case ACPI_TYPE_LOCAL_BANK_FIELD: 435 case ACPI_TYPE_LOCAL_INDEX_FIELD: 436 437 acpi_os_printf(" Off %.3X Len %.2X Acc %.2hd\n", 438 (obj_desc->common_field. 439 base_byte_offset * 8) 440 + 441 obj_desc->common_field. 442 start_field_bit_offset, 443 obj_desc->common_field.bit_length, 444 obj_desc->common_field. 445 access_byte_width); 446 break; 447 448 default: 449 450 break; 451 } 452 break; 453 454 case ACPI_DISPLAY_OBJECTS: 455 456 acpi_os_printf("O:%p", obj_desc); 457 if (!obj_desc) { 458 459 /* No attached object, we are done */ 460 461 acpi_os_printf("\n"); 462 return (AE_OK); 463 } 464 465 acpi_os_printf("(R%u)", obj_desc->common.reference_count); 466 467 switch (type) { 468 case ACPI_TYPE_METHOD: 469 470 /* Name is a Method and its AML offset/length are set */ 471 472 acpi_os_printf(" M:%p-%X\n", obj_desc->method.aml_start, 473 obj_desc->method.aml_length); 474 break; 475 476 case ACPI_TYPE_INTEGER: 477 478 acpi_os_printf(" I:%8.8X8.8%X\n", 479 ACPI_FORMAT_UINT64(obj_desc->integer. 480 value)); 481 break; 482 483 case ACPI_TYPE_STRING: 484 485 acpi_os_printf(" S:%p-%X\n", obj_desc->string.pointer, 486 obj_desc->string.length); 487 break; 488 489 case ACPI_TYPE_BUFFER: 490 491 acpi_os_printf(" B:%p-%X\n", obj_desc->buffer.pointer, 492 obj_desc->buffer.length); 493 break; 494 495 default: 496 497 acpi_os_printf("\n"); 498 break; 499 } 500 break; 501 502 default: 503 acpi_os_printf("\n"); 504 break; 505 } 506 507 /* If debug turned off, done */ 508 509 if (!(acpi_dbg_level & ACPI_LV_VALUES)) { 510 return (AE_OK); 511 } 512 513 /* If there is an attached object, display it */ 514 515 dbg_level = acpi_dbg_level; 516 acpi_dbg_level = 0; 517 obj_desc = acpi_ns_get_attached_object(this_node); 518 acpi_dbg_level = dbg_level; 519 520 /* Dump attached objects */ 521 522 while (obj_desc) { 523 obj_type = ACPI_TYPE_INVALID; 524 acpi_os_printf("Attached Object %p: ", obj_desc); 525 526 /* Decode the type of attached object and dump the contents */ 527 528 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) { 529 case ACPI_DESC_TYPE_NAMED: 530 531 acpi_os_printf("(Ptr to Node)\n"); 532 bytes_to_dump = sizeof(struct acpi_namespace_node); 533 ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump); 534 break; 535 536 case ACPI_DESC_TYPE_OPERAND: 537 538 obj_type = obj_desc->common.type; 539 540 if (obj_type > ACPI_TYPE_LOCAL_MAX) { 541 acpi_os_printf 542 ("(Pointer to ACPI Object type %.2X [UNKNOWN])\n", 543 obj_type); 544 bytes_to_dump = 32; 545 } else { 546 acpi_os_printf 547 ("(Pointer to ACPI Object type %.2X [%s])\n", 548 obj_type, acpi_ut_get_type_name(obj_type)); 549 bytes_to_dump = 550 sizeof(union acpi_operand_object); 551 } 552 553 ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump); 554 break; 555 556 default: 557 558 break; 559 } 560 561 /* If value is NOT an internal object, we are done */ 562 563 if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != 564 ACPI_DESC_TYPE_OPERAND) { 565 goto cleanup; 566 } 567 568 /* Valid object, get the pointer to next level, if any */ 569 570 switch (obj_type) { 571 case ACPI_TYPE_BUFFER: 572 case ACPI_TYPE_STRING: 573 /* 574 * NOTE: takes advantage of common fields between string/buffer 575 */ 576 bytes_to_dump = obj_desc->string.length; 577 obj_desc = (void *)obj_desc->string.pointer; 578 acpi_os_printf("(Buffer/String pointer %p length %X)\n", 579 obj_desc, bytes_to_dump); 580 ACPI_DUMP_BUFFER(obj_desc, bytes_to_dump); 581 goto cleanup; 582 583 case ACPI_TYPE_BUFFER_FIELD: 584 585 obj_desc = 586 (union acpi_operand_object *)obj_desc->buffer_field. 587 buffer_obj; 588 break; 589 590 case ACPI_TYPE_PACKAGE: 591 592 obj_desc = (void *)obj_desc->package.elements; 593 break; 594 595 case ACPI_TYPE_METHOD: 596 597 obj_desc = (void *)obj_desc->method.aml_start; 598 break; 599 600 case ACPI_TYPE_LOCAL_REGION_FIELD: 601 602 obj_desc = (void *)obj_desc->field.region_obj; 603 break; 604 605 case ACPI_TYPE_LOCAL_BANK_FIELD: 606 607 obj_desc = (void *)obj_desc->bank_field.region_obj; 608 break; 609 610 case ACPI_TYPE_LOCAL_INDEX_FIELD: 611 612 obj_desc = (void *)obj_desc->index_field.index_obj; 613 break; 614 615 default: 616 617 goto cleanup; 618 } 619 620 obj_type = ACPI_TYPE_INVALID; /* Terminate loop after next pass */ 621 } 622 623 cleanup: 624 acpi_os_printf("\n"); 625 return (AE_OK); 626 } 627 628 #ifdef ACPI_FUTURE_USAGE 629 /******************************************************************************* 630 * 631 * FUNCTION: acpi_ns_dump_objects 632 * 633 * PARAMETERS: type - Object type to be dumped 634 * display_type - 0 or ACPI_DISPLAY_SUMMARY 635 * max_depth - Maximum depth of dump. Use ACPI_UINT32_MAX 636 * for an effectively unlimited depth. 637 * owner_id - Dump only objects owned by this ID. Use 638 * ACPI_UINT32_MAX to match all owners. 639 * start_handle - Where in namespace to start/end search 640 * 641 * RETURN: None 642 * 643 * DESCRIPTION: Dump typed objects within the loaded namespace. Uses 644 * acpi_ns_walk_namespace in conjunction with acpi_ns_dump_one_object. 645 * 646 ******************************************************************************/ 647 648 void 649 acpi_ns_dump_objects(acpi_object_type type, 650 u8 display_type, 651 u32 max_depth, 652 acpi_owner_id owner_id, acpi_handle start_handle) 653 { 654 struct acpi_walk_info info; 655 acpi_status status; 656 657 ACPI_FUNCTION_ENTRY(); 658 659 /* 660 * Just lock the entire namespace for the duration of the dump. 661 * We don't want any changes to the namespace during this time, 662 * especially the temporary nodes since we are going to display 663 * them also. 664 */ 665 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 666 if (ACPI_FAILURE(status)) { 667 acpi_os_printf("Could not acquire namespace mutex\n"); 668 return; 669 } 670 671 info.debug_level = ACPI_LV_TABLES; 672 info.owner_id = owner_id; 673 info.display_type = display_type; 674 675 (void)acpi_ns_walk_namespace(type, start_handle, max_depth, 676 ACPI_NS_WALK_NO_UNLOCK | 677 ACPI_NS_WALK_TEMP_NODES, 678 acpi_ns_dump_one_object, NULL, 679 (void *)&info, NULL); 680 681 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 682 } 683 #endif /* ACPI_FUTURE_USAGE */ 684 685 #ifdef ACPI_FUTURE_USAGE 686 /******************************************************************************* 687 * 688 * FUNCTION: acpi_ns_dump_one_object_path, acpi_ns_get_max_depth 689 * 690 * PARAMETERS: obj_handle - Node to be dumped 691 * level - Nesting level of the handle 692 * context - Passed into walk_namespace 693 * return_value - Not used 694 * 695 * RETURN: Status 696 * 697 * DESCRIPTION: Dump the full pathname to a namespace object. acp_ns_get_max_depth 698 * computes the maximum nesting depth in the namespace tree, in 699 * order to simplify formatting in acpi_ns_dump_one_object_path. 700 * These procedures are user_functions called by acpi_ns_walk_namespace. 701 * 702 ******************************************************************************/ 703 704 static acpi_status 705 acpi_ns_dump_one_object_path(acpi_handle obj_handle, 706 u32 level, void *context, void **return_value) 707 { 708 u32 max_level = *((u32 *)context); 709 char *pathname; 710 struct acpi_namespace_node *node; 711 int path_indent; 712 713 if (!obj_handle) { 714 return (AE_OK); 715 } 716 717 node = acpi_ns_validate_handle(obj_handle); 718 if (!node) { 719 720 /* Ignore bad node during namespace walk */ 721 722 return (AE_OK); 723 } 724 725 pathname = acpi_ns_get_external_pathname(node); 726 727 path_indent = 1; 728 if (level <= max_level) { 729 path_indent = max_level - level + 1; 730 } 731 732 acpi_os_printf("%2d%*s%-12s%*s", 733 level, level, " ", acpi_ut_get_type_name(node->type), 734 path_indent, " "); 735 736 acpi_os_printf("%s\n", &pathname[1]); 737 ACPI_FREE(pathname); 738 return (AE_OK); 739 } 740 741 static acpi_status 742 acpi_ns_get_max_depth(acpi_handle obj_handle, 743 u32 level, void *context, void **return_value) 744 { 745 u32 *max_level = (u32 *)context; 746 747 if (level > *max_level) { 748 *max_level = level; 749 } 750 return (AE_OK); 751 } 752 753 /******************************************************************************* 754 * 755 * FUNCTION: acpi_ns_dump_object_paths 756 * 757 * PARAMETERS: type - Object type to be dumped 758 * display_type - 0 or ACPI_DISPLAY_SUMMARY 759 * max_depth - Maximum depth of dump. Use ACPI_UINT32_MAX 760 * for an effectively unlimited depth. 761 * owner_id - Dump only objects owned by this ID. Use 762 * ACPI_UINT32_MAX to match all owners. 763 * start_handle - Where in namespace to start/end search 764 * 765 * RETURN: None 766 * 767 * DESCRIPTION: Dump full object pathnames within the loaded namespace. Uses 768 * acpi_ns_walk_namespace in conjunction with acpi_ns_dump_one_object_path. 769 * 770 ******************************************************************************/ 771 772 void 773 acpi_ns_dump_object_paths(acpi_object_type type, 774 u8 display_type, 775 u32 max_depth, 776 acpi_owner_id owner_id, acpi_handle start_handle) 777 { 778 acpi_status status; 779 u32 max_level = 0; 780 781 ACPI_FUNCTION_ENTRY(); 782 783 /* 784 * Just lock the entire namespace for the duration of the dump. 785 * We don't want any changes to the namespace during this time, 786 * especially the temporary nodes since we are going to display 787 * them also. 788 */ 789 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 790 if (ACPI_FAILURE(status)) { 791 acpi_os_printf("Could not acquire namespace mutex\n"); 792 return; 793 } 794 795 /* Get the max depth of the namespace tree, for formatting later */ 796 797 (void)acpi_ns_walk_namespace(type, start_handle, max_depth, 798 ACPI_NS_WALK_NO_UNLOCK | 799 ACPI_NS_WALK_TEMP_NODES, 800 acpi_ns_get_max_depth, NULL, 801 (void *)&max_level, NULL); 802 803 /* Now dump the entire namespace */ 804 805 (void)acpi_ns_walk_namespace(type, start_handle, max_depth, 806 ACPI_NS_WALK_NO_UNLOCK | 807 ACPI_NS_WALK_TEMP_NODES, 808 acpi_ns_dump_one_object_path, NULL, 809 (void *)&max_level, NULL); 810 811 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 812 } 813 #endif /* ACPI_FUTURE_USAGE */ 814 815 /******************************************************************************* 816 * 817 * FUNCTION: acpi_ns_dump_entry 818 * 819 * PARAMETERS: handle - Node to be dumped 820 * debug_level - Output level 821 * 822 * RETURN: None 823 * 824 * DESCRIPTION: Dump a single Node 825 * 826 ******************************************************************************/ 827 828 void acpi_ns_dump_entry(acpi_handle handle, u32 debug_level) 829 { 830 struct acpi_walk_info info; 831 832 ACPI_FUNCTION_ENTRY(); 833 834 info.debug_level = debug_level; 835 info.owner_id = ACPI_OWNER_ID_MAX; 836 info.display_type = ACPI_DISPLAY_SUMMARY; 837 838 (void)acpi_ns_dump_one_object(handle, 1, &info, NULL); 839 } 840 841 #ifdef ACPI_ASL_COMPILER 842 /******************************************************************************* 843 * 844 * FUNCTION: acpi_ns_dump_tables 845 * 846 * PARAMETERS: search_base - Root of subtree to be dumped, or 847 * NS_ALL to dump the entire namespace 848 * max_depth - Maximum depth of dump. Use INT_MAX 849 * for an effectively unlimited depth. 850 * 851 * RETURN: None 852 * 853 * DESCRIPTION: Dump the name space, or a portion of it. 854 * 855 ******************************************************************************/ 856 857 void acpi_ns_dump_tables(acpi_handle search_base, u32 max_depth) 858 { 859 acpi_handle search_handle = search_base; 860 861 ACPI_FUNCTION_TRACE(ns_dump_tables); 862 863 if (!acpi_gbl_root_node) { 864 /* 865 * If the name space has not been initialized, 866 * there is nothing to dump. 867 */ 868 ACPI_DEBUG_PRINT((ACPI_DB_TABLES, 869 "namespace not initialized!\n")); 870 return_VOID; 871 } 872 873 if (ACPI_NS_ALL == search_base) { 874 875 /* Entire namespace */ 876 877 search_handle = acpi_gbl_root_node; 878 ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "\\\n")); 879 } 880 881 acpi_ns_dump_objects(ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, max_depth, 882 ACPI_OWNER_ID_MAX, search_handle); 883 return_VOID; 884 } 885 #endif 886 #endif 887