1 /******************************************************************************* 2 * 3 * Module Name: dbnames - Debugger commands for the acpi namespace 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 "acdebug.h" 48 #include "acpredef.h" 49 50 #define _COMPONENT ACPI_CA_DEBUGGER 51 ACPI_MODULE_NAME("dbnames") 52 53 /* Local prototypes */ 54 static acpi_status 55 acpi_db_walk_and_match_name(acpi_handle obj_handle, 56 u32 nesting_level, 57 void *context, void **return_value); 58 59 static acpi_status 60 acpi_db_walk_for_predefined_names(acpi_handle obj_handle, 61 u32 nesting_level, 62 void *context, void **return_value); 63 64 static acpi_status 65 acpi_db_walk_for_specific_objects(acpi_handle obj_handle, 66 u32 nesting_level, 67 void *context, void **return_value); 68 69 static acpi_status 70 acpi_db_walk_for_object_counts(acpi_handle obj_handle, 71 u32 nesting_level, 72 void *context, void **return_value); 73 74 static acpi_status 75 acpi_db_integrity_walk(acpi_handle obj_handle, 76 u32 nesting_level, void *context, void **return_value); 77 78 static acpi_status 79 acpi_db_walk_for_references(acpi_handle obj_handle, 80 u32 nesting_level, 81 void *context, void **return_value); 82 83 static acpi_status 84 acpi_db_bus_walk(acpi_handle obj_handle, 85 u32 nesting_level, void *context, void **return_value); 86 87 /* 88 * Arguments for the Objects command 89 * These object types map directly to the ACPI_TYPES 90 */ 91 static struct acpi_db_argument_info acpi_db_object_types[] = { 92 {"ANY"}, 93 {"INTEGERS"}, 94 {"STRINGS"}, 95 {"BUFFERS"}, 96 {"PACKAGES"}, 97 {"FIELDS"}, 98 {"DEVICES"}, 99 {"EVENTS"}, 100 {"METHODS"}, 101 {"MUTEXES"}, 102 {"REGIONS"}, 103 {"POWERRESOURCES"}, 104 {"PROCESSORS"}, 105 {"THERMALZONES"}, 106 {"BUFFERFIELDS"}, 107 {"DDBHANDLES"}, 108 {"DEBUG"}, 109 {"REGIONFIELDS"}, 110 {"BANKFIELDS"}, 111 {"INDEXFIELDS"}, 112 {"REFERENCES"}, 113 {"ALIASES"}, 114 {"METHODALIASES"}, 115 {"NOTIFY"}, 116 {"ADDRESSHANDLER"}, 117 {"RESOURCE"}, 118 {"RESOURCEFIELD"}, 119 {"SCOPES"}, 120 {NULL} /* Must be null terminated */ 121 }; 122 123 /******************************************************************************* 124 * 125 * FUNCTION: acpi_db_set_scope 126 * 127 * PARAMETERS: name - New scope path 128 * 129 * RETURN: Status 130 * 131 * DESCRIPTION: Set the "current scope" as maintained by this utility. 132 * The scope is used as a prefix to ACPI paths. 133 * 134 ******************************************************************************/ 135 136 void acpi_db_set_scope(char *name) 137 { 138 acpi_status status; 139 struct acpi_namespace_node *node; 140 141 if (!name || name[0] == 0) { 142 acpi_os_printf("Current scope: %s\n", acpi_gbl_db_scope_buf); 143 return; 144 } 145 146 acpi_db_prep_namestring(name); 147 148 if (ACPI_IS_ROOT_PREFIX(name[0])) { 149 150 /* Validate new scope from the root */ 151 152 status = acpi_ns_get_node(acpi_gbl_root_node, name, 153 ACPI_NS_NO_UPSEARCH, &node); 154 if (ACPI_FAILURE(status)) { 155 goto error_exit; 156 } 157 158 acpi_gbl_db_scope_buf[0] = 0; 159 } else { 160 /* Validate new scope relative to old scope */ 161 162 status = acpi_ns_get_node(acpi_gbl_db_scope_node, name, 163 ACPI_NS_NO_UPSEARCH, &node); 164 if (ACPI_FAILURE(status)) { 165 goto error_exit; 166 } 167 } 168 169 /* Build the final pathname */ 170 171 if (acpi_ut_safe_strcat 172 (acpi_gbl_db_scope_buf, sizeof(acpi_gbl_db_scope_buf), name)) { 173 status = AE_BUFFER_OVERFLOW; 174 goto error_exit; 175 } 176 177 if (acpi_ut_safe_strcat 178 (acpi_gbl_db_scope_buf, sizeof(acpi_gbl_db_scope_buf), "\\")) { 179 status = AE_BUFFER_OVERFLOW; 180 goto error_exit; 181 } 182 183 acpi_gbl_db_scope_node = node; 184 acpi_os_printf("New scope: %s\n", acpi_gbl_db_scope_buf); 185 return; 186 187 error_exit: 188 189 acpi_os_printf("Could not attach scope: %s, %s\n", 190 name, acpi_format_exception(status)); 191 } 192 193 /******************************************************************************* 194 * 195 * FUNCTION: acpi_db_dump_namespace 196 * 197 * PARAMETERS: start_arg - Node to begin namespace dump 198 * depth_arg - Maximum tree depth to be dumped 199 * 200 * RETURN: None 201 * 202 * DESCRIPTION: Dump entire namespace or a subtree. Each node is displayed 203 * with type and other information. 204 * 205 ******************************************************************************/ 206 207 void acpi_db_dump_namespace(char *start_arg, char *depth_arg) 208 { 209 acpi_handle subtree_entry = acpi_gbl_root_node; 210 u32 max_depth = ACPI_UINT32_MAX; 211 212 /* No argument given, just start at the root and dump entire namespace */ 213 214 if (start_arg) { 215 subtree_entry = acpi_db_convert_to_node(start_arg); 216 if (!subtree_entry) { 217 return; 218 } 219 220 /* Now we can check for the depth argument */ 221 222 if (depth_arg) { 223 max_depth = strtoul(depth_arg, NULL, 0); 224 } 225 } 226 227 acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT); 228 acpi_os_printf("ACPI Namespace (from %4.4s (%p) subtree):\n", 229 ((struct acpi_namespace_node *)subtree_entry)->name. 230 ascii, subtree_entry); 231 232 /* Display the subtree */ 233 234 acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT); 235 acpi_ns_dump_objects(ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, max_depth, 236 ACPI_OWNER_ID_MAX, subtree_entry); 237 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); 238 } 239 240 /******************************************************************************* 241 * 242 * FUNCTION: acpi_db_dump_namespace_paths 243 * 244 * PARAMETERS: None 245 * 246 * RETURN: None 247 * 248 * DESCRIPTION: Dump entire namespace with full object pathnames and object 249 * type information. Alternative to "namespace" command. 250 * 251 ******************************************************************************/ 252 253 void acpi_db_dump_namespace_paths(void) 254 { 255 256 acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT); 257 acpi_os_printf("ACPI Namespace (from root):\n"); 258 259 /* Display the entire namespace */ 260 261 acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT); 262 acpi_ns_dump_object_paths(ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, 263 ACPI_UINT32_MAX, ACPI_OWNER_ID_MAX, 264 acpi_gbl_root_node); 265 266 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); 267 } 268 269 /******************************************************************************* 270 * 271 * FUNCTION: acpi_db_dump_namespace_by_owner 272 * 273 * PARAMETERS: owner_arg - Owner ID whose nodes will be displayed 274 * depth_arg - Maximum tree depth to be dumped 275 * 276 * RETURN: None 277 * 278 * DESCRIPTION: Dump elements of the namespace that are owned by the owner_id. 279 * 280 ******************************************************************************/ 281 282 void acpi_db_dump_namespace_by_owner(char *owner_arg, char *depth_arg) 283 { 284 acpi_handle subtree_entry = acpi_gbl_root_node; 285 u32 max_depth = ACPI_UINT32_MAX; 286 acpi_owner_id owner_id; 287 288 owner_id = (acpi_owner_id)strtoul(owner_arg, NULL, 0); 289 290 /* Now we can check for the depth argument */ 291 292 if (depth_arg) { 293 max_depth = strtoul(depth_arg, NULL, 0); 294 } 295 296 acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT); 297 acpi_os_printf("ACPI Namespace by owner %X:\n", owner_id); 298 299 /* Display the subtree */ 300 301 acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT); 302 acpi_ns_dump_objects(ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, max_depth, 303 owner_id, subtree_entry); 304 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); 305 } 306 307 /******************************************************************************* 308 * 309 * FUNCTION: acpi_db_walk_and_match_name 310 * 311 * PARAMETERS: Callback from walk_namespace 312 * 313 * RETURN: Status 314 * 315 * DESCRIPTION: Find a particular name/names within the namespace. Wildcards 316 * are supported -- '?' matches any character. 317 * 318 ******************************************************************************/ 319 320 static acpi_status 321 acpi_db_walk_and_match_name(acpi_handle obj_handle, 322 u32 nesting_level, 323 void *context, void **return_value) 324 { 325 acpi_status status; 326 char *requested_name = (char *)context; 327 u32 i; 328 struct acpi_buffer buffer; 329 struct acpi_walk_info info; 330 331 /* Check for a name match */ 332 333 for (i = 0; i < 4; i++) { 334 335 /* Wildcard support */ 336 337 if ((requested_name[i] != '?') && 338 (requested_name[i] != ((struct acpi_namespace_node *) 339 obj_handle)->name.ascii[i])) { 340 341 /* No match, just exit */ 342 343 return (AE_OK); 344 } 345 } 346 347 /* Get the full pathname to this object */ 348 349 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; 350 status = acpi_ns_handle_to_pathname(obj_handle, &buffer, TRUE); 351 if (ACPI_FAILURE(status)) { 352 acpi_os_printf("Could Not get pathname for object %p\n", 353 obj_handle); 354 } else { 355 info.owner_id = ACPI_OWNER_ID_MAX; 356 info.debug_level = ACPI_UINT32_MAX; 357 info.display_type = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT; 358 359 acpi_os_printf("%32s", (char *)buffer.pointer); 360 (void)acpi_ns_dump_one_object(obj_handle, nesting_level, &info, 361 NULL); 362 ACPI_FREE(buffer.pointer); 363 } 364 365 return (AE_OK); 366 } 367 368 /******************************************************************************* 369 * 370 * FUNCTION: acpi_db_find_name_in_namespace 371 * 372 * PARAMETERS: name_arg - The 4-character ACPI name to find. 373 * wildcards are supported. 374 * 375 * RETURN: None 376 * 377 * DESCRIPTION: Search the namespace for a given name (with wildcards) 378 * 379 ******************************************************************************/ 380 381 acpi_status acpi_db_find_name_in_namespace(char *name_arg) 382 { 383 char acpi_name[5] = "____"; 384 char *acpi_name_ptr = acpi_name; 385 386 if (strlen(name_arg) > ACPI_NAME_SIZE) { 387 acpi_os_printf("Name must be no longer than 4 characters\n"); 388 return (AE_OK); 389 } 390 391 /* Pad out name with underscores as necessary to create a 4-char name */ 392 393 acpi_ut_strupr(name_arg); 394 while (*name_arg) { 395 *acpi_name_ptr = *name_arg; 396 acpi_name_ptr++; 397 name_arg++; 398 } 399 400 /* Walk the namespace from the root */ 401 402 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 403 ACPI_UINT32_MAX, acpi_db_walk_and_match_name, 404 NULL, acpi_name, NULL); 405 406 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); 407 return (AE_OK); 408 } 409 410 /******************************************************************************* 411 * 412 * FUNCTION: acpi_db_walk_for_predefined_names 413 * 414 * PARAMETERS: Callback from walk_namespace 415 * 416 * RETURN: Status 417 * 418 * DESCRIPTION: Detect and display predefined ACPI names (names that start with 419 * an underscore) 420 * 421 ******************************************************************************/ 422 423 static acpi_status 424 acpi_db_walk_for_predefined_names(acpi_handle obj_handle, 425 u32 nesting_level, 426 void *context, void **return_value) 427 { 428 struct acpi_namespace_node *node = 429 (struct acpi_namespace_node *)obj_handle; 430 u32 *count = (u32 *)context; 431 const union acpi_predefined_info *predefined; 432 const union acpi_predefined_info *package = NULL; 433 char *pathname; 434 char string_buffer[48]; 435 436 predefined = acpi_ut_match_predefined_method(node->name.ascii); 437 if (!predefined) { 438 return (AE_OK); 439 } 440 441 pathname = acpi_ns_get_normalized_pathname(node, TRUE); 442 if (!pathname) { 443 return (AE_OK); 444 } 445 446 /* If method returns a package, the info is in the next table entry */ 447 448 if (predefined->info.expected_btypes & ACPI_RTYPE_PACKAGE) { 449 package = predefined + 1; 450 } 451 452 acpi_ut_get_expected_return_types(string_buffer, 453 predefined->info.expected_btypes); 454 455 acpi_os_printf("%-32s Arguments %X, Return Types: %s", pathname, 456 METHOD_GET_ARG_COUNT(predefined->info.argument_list), 457 string_buffer); 458 459 if (package) { 460 acpi_os_printf(" (PkgType %2.2X, ObjType %2.2X, Count %2.2X)", 461 package->ret_info.type, 462 package->ret_info.object_type1, 463 package->ret_info.count1); 464 } 465 466 acpi_os_printf("\n"); 467 468 /* Check that the declared argument count matches the ACPI spec */ 469 470 acpi_ns_check_acpi_compliance(pathname, node, predefined); 471 472 ACPI_FREE(pathname); 473 (*count)++; 474 return (AE_OK); 475 } 476 477 /******************************************************************************* 478 * 479 * FUNCTION: acpi_db_check_predefined_names 480 * 481 * PARAMETERS: None 482 * 483 * RETURN: None 484 * 485 * DESCRIPTION: Validate all predefined names in the namespace 486 * 487 ******************************************************************************/ 488 489 void acpi_db_check_predefined_names(void) 490 { 491 u32 count = 0; 492 493 /* Search all nodes in namespace */ 494 495 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 496 ACPI_UINT32_MAX, 497 acpi_db_walk_for_predefined_names, NULL, 498 (void *)&count, NULL); 499 500 acpi_os_printf("Found %u predefined names in the namespace\n", count); 501 } 502 503 /******************************************************************************* 504 * 505 * FUNCTION: acpi_db_walk_for_object_counts 506 * 507 * PARAMETERS: Callback from walk_namespace 508 * 509 * RETURN: Status 510 * 511 * DESCRIPTION: Display short info about objects in the namespace 512 * 513 ******************************************************************************/ 514 515 static acpi_status 516 acpi_db_walk_for_object_counts(acpi_handle obj_handle, 517 u32 nesting_level, 518 void *context, void **return_value) 519 { 520 struct acpi_object_info *info = (struct acpi_object_info *)context; 521 struct acpi_namespace_node *node = 522 (struct acpi_namespace_node *)obj_handle; 523 524 if (node->type > ACPI_TYPE_NS_NODE_MAX) { 525 acpi_os_printf("[%4.4s]: Unknown object type %X\n", 526 node->name.ascii, node->type); 527 } else { 528 info->types[node->type]++; 529 } 530 531 return (AE_OK); 532 } 533 534 /******************************************************************************* 535 * 536 * FUNCTION: acpi_db_walk_for_specific_objects 537 * 538 * PARAMETERS: Callback from walk_namespace 539 * 540 * RETURN: Status 541 * 542 * DESCRIPTION: Display short info about objects in the namespace 543 * 544 ******************************************************************************/ 545 546 static acpi_status 547 acpi_db_walk_for_specific_objects(acpi_handle obj_handle, 548 u32 nesting_level, 549 void *context, void **return_value) 550 { 551 struct acpi_walk_info *info = (struct acpi_walk_info *)context; 552 struct acpi_buffer buffer; 553 acpi_status status; 554 555 info->count++; 556 557 /* Get and display the full pathname to this object */ 558 559 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; 560 status = acpi_ns_handle_to_pathname(obj_handle, &buffer, TRUE); 561 if (ACPI_FAILURE(status)) { 562 acpi_os_printf("Could Not get pathname for object %p\n", 563 obj_handle); 564 return (AE_OK); 565 } 566 567 acpi_os_printf("%32s", (char *)buffer.pointer); 568 ACPI_FREE(buffer.pointer); 569 570 /* Dump short info about the object */ 571 572 (void)acpi_ns_dump_one_object(obj_handle, nesting_level, info, NULL); 573 return (AE_OK); 574 } 575 576 /******************************************************************************* 577 * 578 * FUNCTION: acpi_db_display_objects 579 * 580 * PARAMETERS: obj_type_arg - Type of object to display 581 * display_count_arg - Max depth to display 582 * 583 * RETURN: None 584 * 585 * DESCRIPTION: Display objects in the namespace of the requested type 586 * 587 ******************************************************************************/ 588 589 acpi_status acpi_db_display_objects(char *obj_type_arg, char *display_count_arg) 590 { 591 struct acpi_walk_info info; 592 acpi_object_type type; 593 struct acpi_object_info *object_info; 594 u32 i; 595 u32 total_objects = 0; 596 597 /* No argument means display summary/count of all object types */ 598 599 if (!obj_type_arg) { 600 object_info = 601 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_object_info)); 602 603 /* Walk the namespace from the root */ 604 605 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 606 ACPI_UINT32_MAX, 607 acpi_db_walk_for_object_counts, NULL, 608 (void *)object_info, NULL); 609 610 acpi_os_printf("\nSummary of namespace objects:\n\n"); 611 612 for (i = 0; i < ACPI_TOTAL_TYPES; i++) { 613 acpi_os_printf("%8u %s\n", object_info->types[i], 614 acpi_ut_get_type_name(i)); 615 616 total_objects += object_info->types[i]; 617 } 618 619 acpi_os_printf("\n%8u Total namespace objects\n\n", 620 total_objects); 621 622 ACPI_FREE(object_info); 623 return (AE_OK); 624 } 625 626 /* Get the object type */ 627 628 type = acpi_db_match_argument(obj_type_arg, acpi_db_object_types); 629 if (type == ACPI_TYPE_NOT_FOUND) { 630 acpi_os_printf("Invalid or unsupported argument\n"); 631 return (AE_OK); 632 } 633 634 acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT); 635 acpi_os_printf 636 ("Objects of type [%s] defined in the current ACPI Namespace:\n", 637 acpi_ut_get_type_name(type)); 638 639 acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT); 640 641 info.count = 0; 642 info.owner_id = ACPI_OWNER_ID_MAX; 643 info.debug_level = ACPI_UINT32_MAX; 644 info.display_type = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT; 645 646 /* Walk the namespace from the root */ 647 648 (void)acpi_walk_namespace(type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, 649 acpi_db_walk_for_specific_objects, NULL, 650 (void *)&info, NULL); 651 652 acpi_os_printf 653 ("\nFound %u objects of type [%s] in the current ACPI Namespace\n", 654 info.count, acpi_ut_get_type_name(type)); 655 656 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); 657 return (AE_OK); 658 } 659 660 /******************************************************************************* 661 * 662 * FUNCTION: acpi_db_integrity_walk 663 * 664 * PARAMETERS: Callback from walk_namespace 665 * 666 * RETURN: Status 667 * 668 * DESCRIPTION: Examine one NS node for valid values. 669 * 670 ******************************************************************************/ 671 672 static acpi_status 673 acpi_db_integrity_walk(acpi_handle obj_handle, 674 u32 nesting_level, void *context, void **return_value) 675 { 676 struct acpi_integrity_info *info = 677 (struct acpi_integrity_info *)context; 678 struct acpi_namespace_node *node = 679 (struct acpi_namespace_node *)obj_handle; 680 union acpi_operand_object *object; 681 u8 alias = TRUE; 682 683 info->nodes++; 684 685 /* Verify the NS node, and dereference aliases */ 686 687 while (alias) { 688 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) { 689 acpi_os_printf 690 ("Invalid Descriptor Type for Node %p [%s] - " 691 "is %2.2X should be %2.2X\n", node, 692 acpi_ut_get_descriptor_name(node), 693 ACPI_GET_DESCRIPTOR_TYPE(node), 694 ACPI_DESC_TYPE_NAMED); 695 return (AE_OK); 696 } 697 698 if ((node->type == ACPI_TYPE_LOCAL_ALIAS) || 699 (node->type == ACPI_TYPE_LOCAL_METHOD_ALIAS)) { 700 node = (struct acpi_namespace_node *)node->object; 701 } else { 702 alias = FALSE; 703 } 704 } 705 706 if (node->type > ACPI_TYPE_LOCAL_MAX) { 707 acpi_os_printf("Invalid Object Type for Node %p, Type = %X\n", 708 node, node->type); 709 return (AE_OK); 710 } 711 712 if (!acpi_ut_valid_nameseg(node->name.ascii)) { 713 acpi_os_printf("Invalid AcpiName for Node %p\n", node); 714 return (AE_OK); 715 } 716 717 object = acpi_ns_get_attached_object(node); 718 if (object) { 719 info->objects++; 720 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) { 721 acpi_os_printf 722 ("Invalid Descriptor Type for Object %p [%s]\n", 723 object, acpi_ut_get_descriptor_name(object)); 724 } 725 } 726 727 return (AE_OK); 728 } 729 730 /******************************************************************************* 731 * 732 * FUNCTION: acpi_db_check_integrity 733 * 734 * PARAMETERS: None 735 * 736 * RETURN: None 737 * 738 * DESCRIPTION: Check entire namespace for data structure integrity 739 * 740 ******************************************************************************/ 741 742 void acpi_db_check_integrity(void) 743 { 744 struct acpi_integrity_info info = { 0, 0 }; 745 746 /* Search all nodes in namespace */ 747 748 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 749 ACPI_UINT32_MAX, acpi_db_integrity_walk, NULL, 750 (void *)&info, NULL); 751 752 acpi_os_printf("Verified %u namespace nodes with %u Objects\n", 753 info.nodes, info.objects); 754 } 755 756 /******************************************************************************* 757 * 758 * FUNCTION: acpi_db_walk_for_references 759 * 760 * PARAMETERS: Callback from walk_namespace 761 * 762 * RETURN: Status 763 * 764 * DESCRIPTION: Check if this namespace object refers to the target object 765 * that is passed in as the context value. 766 * 767 * Note: Currently doesn't check subobjects within the Node's object 768 * 769 ******************************************************************************/ 770 771 static acpi_status 772 acpi_db_walk_for_references(acpi_handle obj_handle, 773 u32 nesting_level, 774 void *context, void **return_value) 775 { 776 union acpi_operand_object *obj_desc = 777 (union acpi_operand_object *)context; 778 struct acpi_namespace_node *node = 779 (struct acpi_namespace_node *)obj_handle; 780 781 /* Check for match against the namespace node itself */ 782 783 if (node == (void *)obj_desc) { 784 acpi_os_printf("Object is a Node [%4.4s]\n", 785 acpi_ut_get_node_name(node)); 786 } 787 788 /* Check for match against the object attached to the node */ 789 790 if (acpi_ns_get_attached_object(node) == obj_desc) { 791 acpi_os_printf("Reference at Node->Object %p [%4.4s]\n", 792 node, acpi_ut_get_node_name(node)); 793 } 794 795 return (AE_OK); 796 } 797 798 /******************************************************************************* 799 * 800 * FUNCTION: acpi_db_find_references 801 * 802 * PARAMETERS: object_arg - String with hex value of the object 803 * 804 * RETURN: None 805 * 806 * DESCRIPTION: Search namespace for all references to the input object 807 * 808 ******************************************************************************/ 809 810 void acpi_db_find_references(char *object_arg) 811 { 812 union acpi_operand_object *obj_desc; 813 acpi_size address; 814 815 /* Convert string to object pointer */ 816 817 address = strtoul(object_arg, NULL, 16); 818 obj_desc = ACPI_TO_POINTER(address); 819 820 /* Search all nodes in namespace */ 821 822 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 823 ACPI_UINT32_MAX, acpi_db_walk_for_references, 824 NULL, (void *)obj_desc, NULL); 825 } 826 827 /******************************************************************************* 828 * 829 * FUNCTION: acpi_db_bus_walk 830 * 831 * PARAMETERS: Callback from walk_namespace 832 * 833 * RETURN: Status 834 * 835 * DESCRIPTION: Display info about device objects that have a corresponding 836 * _PRT method. 837 * 838 ******************************************************************************/ 839 840 static acpi_status 841 acpi_db_bus_walk(acpi_handle obj_handle, 842 u32 nesting_level, void *context, void **return_value) 843 { 844 struct acpi_namespace_node *node = 845 (struct acpi_namespace_node *)obj_handle; 846 acpi_status status; 847 struct acpi_buffer buffer; 848 struct acpi_namespace_node *temp_node; 849 struct acpi_device_info *info; 850 u32 i; 851 852 if ((node->type != ACPI_TYPE_DEVICE) && 853 (node->type != ACPI_TYPE_PROCESSOR)) { 854 return (AE_OK); 855 } 856 857 /* Exit if there is no _PRT under this device */ 858 859 status = acpi_get_handle(node, METHOD_NAME__PRT, 860 ACPI_CAST_PTR(acpi_handle, &temp_node)); 861 if (ACPI_FAILURE(status)) { 862 return (AE_OK); 863 } 864 865 /* Get the full path to this device object */ 866 867 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; 868 status = acpi_ns_handle_to_pathname(obj_handle, &buffer, TRUE); 869 if (ACPI_FAILURE(status)) { 870 acpi_os_printf("Could Not get pathname for object %p\n", 871 obj_handle); 872 return (AE_OK); 873 } 874 875 status = acpi_get_object_info(obj_handle, &info); 876 if (ACPI_FAILURE(status)) { 877 return (AE_OK); 878 } 879 880 /* Display the full path */ 881 882 acpi_os_printf("%-32s Type %X", (char *)buffer.pointer, node->type); 883 ACPI_FREE(buffer.pointer); 884 885 if (info->flags & ACPI_PCI_ROOT_BRIDGE) { 886 acpi_os_printf(" - Is PCI Root Bridge"); 887 } 888 acpi_os_printf("\n"); 889 890 /* _PRT info */ 891 892 acpi_os_printf("_PRT: %p\n", temp_node); 893 894 /* Dump _ADR, _HID, _UID, _CID */ 895 896 if (info->valid & ACPI_VALID_ADR) { 897 acpi_os_printf("_ADR: %8.8X%8.8X\n", 898 ACPI_FORMAT_UINT64(info->address)); 899 } else { 900 acpi_os_printf("_ADR: <Not Present>\n"); 901 } 902 903 if (info->valid & ACPI_VALID_HID) { 904 acpi_os_printf("_HID: %s\n", info->hardware_id.string); 905 } else { 906 acpi_os_printf("_HID: <Not Present>\n"); 907 } 908 909 if (info->valid & ACPI_VALID_UID) { 910 acpi_os_printf("_UID: %s\n", info->unique_id.string); 911 } else { 912 acpi_os_printf("_UID: <Not Present>\n"); 913 } 914 915 if (info->valid & ACPI_VALID_CID) { 916 for (i = 0; i < info->compatible_id_list.count; i++) { 917 acpi_os_printf("_CID: %s\n", 918 info->compatible_id_list.ids[i].string); 919 } 920 } else { 921 acpi_os_printf("_CID: <Not Present>\n"); 922 } 923 924 ACPI_FREE(info); 925 return (AE_OK); 926 } 927 928 /******************************************************************************* 929 * 930 * FUNCTION: acpi_db_get_bus_info 931 * 932 * PARAMETERS: None 933 * 934 * RETURN: None 935 * 936 * DESCRIPTION: Display info about system busses. 937 * 938 ******************************************************************************/ 939 940 void acpi_db_get_bus_info(void) 941 { 942 /* Search all nodes in namespace */ 943 944 (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, 945 ACPI_UINT32_MAX, acpi_db_bus_walk, NULL, NULL, 946 NULL); 947 } 948