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