/******************************************************************************* * * Module Name: dbdisply - debug display commands * ******************************************************************************/ /* * Copyright (C) 2000 - 2018, Intel Corp. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions, and the following disclaimer, * without modification. * 2. Redistributions in binary form must reproduce at minimum a disclaimer * substantially similar to the "NO WARRANTY" disclaimer below * ("Disclaimer") and any redistribution must be conditioned upon * including a substantially similar Disclaimer requirement for further * binary redistribution. * 3. Neither the names of the above-listed copyright holders nor the names * of any contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * NO WARRANTY * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGES. */ #include #include "accommon.h" #include "amlcode.h" #include "acdispat.h" #include "acnamesp.h" #include "acparser.h" #include "acinterp.h" #include "acevents.h" #include "acdebug.h" #define _COMPONENT ACPI_CA_DEBUGGER ACPI_MODULE_NAME("dbdisply") /* Local prototypes */ static void acpi_db_dump_parser_descriptor(union acpi_parse_object *op); static void *acpi_db_get_pointer(void *target); static acpi_status acpi_db_display_non_root_handlers(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value); /* * System handler information. * Used for Handlers command, in acpi_db_display_handlers. */ #define ACPI_PREDEFINED_PREFIX "%25s (%.2X) : " #define ACPI_HANDLER_NAME_STRING "%30s : " #define ACPI_HANDLER_PRESENT_STRING "%-9s (%p)\n" #define ACPI_HANDLER_PRESENT_STRING2 "%-9s (%p)" #define ACPI_HANDLER_NOT_PRESENT_STRING "%-9s\n" /* All predefined Address Space IDs */ static acpi_adr_space_type acpi_gbl_space_id_list[] = { ACPI_ADR_SPACE_SYSTEM_MEMORY, ACPI_ADR_SPACE_SYSTEM_IO, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_ADR_SPACE_EC, ACPI_ADR_SPACE_SMBUS, ACPI_ADR_SPACE_CMOS, ACPI_ADR_SPACE_PCI_BAR_TARGET, ACPI_ADR_SPACE_IPMI, ACPI_ADR_SPACE_GPIO, ACPI_ADR_SPACE_GSBUS, ACPI_ADR_SPACE_DATA_TABLE, ACPI_ADR_SPACE_FIXED_HARDWARE }; /* Global handler information */ typedef struct acpi_handler_info { void *handler; char *name; } acpi_handler_info; static struct acpi_handler_info acpi_gbl_handler_list[] = { {&acpi_gbl_global_notify[0].handler, "System Notifications"}, {&acpi_gbl_global_notify[1].handler, "Device Notifications"}, {&acpi_gbl_table_handler, "ACPI Table Events"}, {&acpi_gbl_exception_handler, "Control Method Exceptions"}, {&acpi_gbl_interface_handler, "OSI Invocations"} }; /******************************************************************************* * * FUNCTION: acpi_db_get_pointer * * PARAMETERS: target - Pointer to string to be converted * * RETURN: Converted pointer * * DESCRIPTION: Convert an ascii pointer value to a real value * ******************************************************************************/ static void *acpi_db_get_pointer(void *target) { void *obj_ptr; acpi_size address; address = strtoul(target, NULL, 16); obj_ptr = ACPI_TO_POINTER(address); return (obj_ptr); } /******************************************************************************* * * FUNCTION: acpi_db_dump_parser_descriptor * * PARAMETERS: op - A parser Op descriptor * * RETURN: None * * DESCRIPTION: Display a formatted parser object * ******************************************************************************/ static void acpi_db_dump_parser_descriptor(union acpi_parse_object *op) { const struct acpi_opcode_info *info; info = acpi_ps_get_opcode_info(op->common.aml_opcode); acpi_os_printf("Parser Op Descriptor:\n"); acpi_os_printf("%20.20s : %4.4X\n", "Opcode", op->common.aml_opcode); ACPI_DEBUG_ONLY_MEMBERS(acpi_os_printf("%20.20s : %s\n", "Opcode Name", info->name)); acpi_os_printf("%20.20s : %p\n", "Value/ArgList", op->common.value.arg); acpi_os_printf("%20.20s : %p\n", "Parent", op->common.parent); acpi_os_printf("%20.20s : %p\n", "NextOp", op->common.next); } /******************************************************************************* * * FUNCTION: acpi_db_decode_and_display_object * * PARAMETERS: target - String with object to be displayed. Names * and hex pointers are supported. * output_type - Byte, Word, Dword, or Qword (B|W|D|Q) * * RETURN: None * * DESCRIPTION: Display a formatted ACPI object * ******************************************************************************/ void acpi_db_decode_and_display_object(char *target, char *output_type) { void *obj_ptr; struct acpi_namespace_node *node; union acpi_operand_object *obj_desc; u32 display = DB_BYTE_DISPLAY; char buffer[80]; struct acpi_buffer ret_buf; acpi_status status; u32 size; if (!target) { return; } /* Decode the output type */ if (output_type) { acpi_ut_strupr(output_type); if (output_type[0] == 'W') { display = DB_WORD_DISPLAY; } else if (output_type[0] == 'D') { display = DB_DWORD_DISPLAY; } else if (output_type[0] == 'Q') { display = DB_QWORD_DISPLAY; } } ret_buf.length = sizeof(buffer); ret_buf.pointer = buffer; /* Differentiate between a number and a name */ if ((target[0] >= 0x30) && (target[0] <= 0x39)) { obj_ptr = acpi_db_get_pointer(target); if (!acpi_os_readable(obj_ptr, 16)) { acpi_os_printf ("Address %p is invalid in this address space\n", obj_ptr); return; } /* Decode the object type */ switch (ACPI_GET_DESCRIPTOR_TYPE(obj_ptr)) { case ACPI_DESC_TYPE_NAMED: /* This is a namespace Node */ if (!acpi_os_readable (obj_ptr, sizeof(struct acpi_namespace_node))) { acpi_os_printf ("Cannot read entire Named object at address %p\n", obj_ptr); return; } node = obj_ptr; goto dump_node; case ACPI_DESC_TYPE_OPERAND: /* This is a ACPI OPERAND OBJECT */ if (!acpi_os_readable (obj_ptr, sizeof(union acpi_operand_object))) { acpi_os_printf ("Cannot read entire ACPI object at address %p\n", obj_ptr); return; } acpi_ut_debug_dump_buffer(obj_ptr, sizeof(union acpi_operand_object), display, ACPI_UINT32_MAX); acpi_ex_dump_object_descriptor(obj_ptr, 1); break; case ACPI_DESC_TYPE_PARSER: /* This is a Parser Op object */ if (!acpi_os_readable (obj_ptr, sizeof(union acpi_parse_object))) { acpi_os_printf ("Cannot read entire Parser object at address %p\n", obj_ptr); return; } acpi_ut_debug_dump_buffer(obj_ptr, sizeof(union acpi_parse_object), display, ACPI_UINT32_MAX); acpi_db_dump_parser_descriptor((union acpi_parse_object *)obj_ptr); break; default: /* Is not a recognizeable object */ acpi_os_printf ("Not a known ACPI internal object, descriptor type %2.2X\n", ACPI_GET_DESCRIPTOR_TYPE(obj_ptr)); size = 16; if (acpi_os_readable(obj_ptr, 64)) { size = 64; } /* Just dump some memory */ acpi_ut_debug_dump_buffer(obj_ptr, size, display, ACPI_UINT32_MAX); break; } return; } /* The parameter is a name string that must be resolved to a Named obj */ node = acpi_db_local_ns_lookup(target); if (!node) { return; } dump_node: /* Now dump the NS node */ status = acpi_get_name(node, ACPI_FULL_PATHNAME_NO_TRAILING, &ret_buf); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not convert name to pathname\n"); } else { acpi_os_printf("Object %p: Namespace Node - Pathname: %s\n", node, (char *)ret_buf.pointer); } if (!acpi_os_readable(node, sizeof(struct acpi_namespace_node))) { acpi_os_printf("Invalid Named object at address %p\n", node); return; } acpi_ut_debug_dump_buffer((void *)node, sizeof(struct acpi_namespace_node), display, ACPI_UINT32_MAX); acpi_ex_dump_namespace_node(node, 1); obj_desc = acpi_ns_get_attached_object(node); if (obj_desc) { acpi_os_printf("\nAttached Object %p:", obj_desc); if (!acpi_os_readable (obj_desc, sizeof(union acpi_operand_object))) { acpi_os_printf ("Invalid internal ACPI Object at address %p\n", obj_desc); return; } if (ACPI_GET_DESCRIPTOR_TYPE(((struct acpi_namespace_node *) obj_desc)) == ACPI_DESC_TYPE_NAMED) { acpi_os_printf(" Namespace Node - "); status = acpi_get_name((struct acpi_namespace_node *) obj_desc, ACPI_FULL_PATHNAME_NO_TRAILING, &ret_buf); if (ACPI_FAILURE(status)) { acpi_os_printf ("Could not convert name to pathname\n"); } else { acpi_os_printf("Pathname: %s", (char *)ret_buf.pointer); } acpi_os_printf("\n"); acpi_ut_debug_dump_buffer((void *)obj_desc, sizeof(struct acpi_namespace_node), display, ACPI_UINT32_MAX); } else { acpi_os_printf("\n"); acpi_ut_debug_dump_buffer((void *)obj_desc, sizeof(union acpi_operand_object), display, ACPI_UINT32_MAX); } acpi_ex_dump_object_descriptor(obj_desc, 1); } } /******************************************************************************* * * FUNCTION: acpi_db_display_method_info * * PARAMETERS: start_op - Root of the control method parse tree * * RETURN: None * * DESCRIPTION: Display information about the current method * ******************************************************************************/ void acpi_db_display_method_info(union acpi_parse_object *start_op) { struct acpi_walk_state *walk_state; union acpi_operand_object *obj_desc; struct acpi_namespace_node *node; union acpi_parse_object *root_op; union acpi_parse_object *op; const struct acpi_opcode_info *op_info; u32 num_ops = 0; u32 num_operands = 0; u32 num_operators = 0; u32 num_remaining_ops = 0; u32 num_remaining_operands = 0; u32 num_remaining_operators = 0; u8 count_remaining = FALSE; walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list); if (!walk_state) { acpi_os_printf("There is no method currently executing\n"); return; } obj_desc = walk_state->method_desc; node = walk_state->method_node; acpi_os_printf("Currently executing control method is [%4.4s]\n", acpi_ut_get_node_name(node)); acpi_os_printf("%X Arguments, SyncLevel = %X\n", (u32)obj_desc->method.param_count, (u32)obj_desc->method.sync_level); root_op = start_op; while (root_op->common.parent) { root_op = root_op->common.parent; } op = root_op; while (op) { if (op == start_op) { count_remaining = TRUE; } num_ops++; if (count_remaining) { num_remaining_ops++; } /* Decode the opcode */ op_info = acpi_ps_get_opcode_info(op->common.aml_opcode); switch (op_info->class) { case AML_CLASS_ARGUMENT: if (count_remaining) { num_remaining_operands++; } num_operands++; break; case AML_CLASS_UNKNOWN: /* Bad opcode or ASCII character */ continue; default: if (count_remaining) { num_remaining_operators++; } num_operators++; break; } op = acpi_ps_get_depth_next(start_op, op); } acpi_os_printf ("Method contains: %X AML Opcodes - %X Operators, %X Operands\n", num_ops, num_operators, num_operands); acpi_os_printf ("Remaining to execute: %X AML Opcodes - %X Operators, %X Operands\n", num_remaining_ops, num_remaining_operators, num_remaining_operands); } /******************************************************************************* * * FUNCTION: acpi_db_display_locals * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display all locals for the currently running control method * ******************************************************************************/ void acpi_db_display_locals(void) { struct acpi_walk_state *walk_state; walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list); if (!walk_state) { acpi_os_printf("There is no method currently executing\n"); return; } acpi_db_decode_locals(walk_state); } /******************************************************************************* * * FUNCTION: acpi_db_display_arguments * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display all arguments for the currently running control method * ******************************************************************************/ void acpi_db_display_arguments(void) { struct acpi_walk_state *walk_state; walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list); if (!walk_state) { acpi_os_printf("There is no method currently executing\n"); return; } acpi_db_decode_arguments(walk_state); } /******************************************************************************* * * FUNCTION: acpi_db_display_results * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display current contents of a method result stack * ******************************************************************************/ void acpi_db_display_results(void) { u32 i; struct acpi_walk_state *walk_state; union acpi_operand_object *obj_desc; u32 result_count = 0; struct acpi_namespace_node *node; union acpi_generic_state *frame; u32 index; /* Index onto current frame */ walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list); if (!walk_state) { acpi_os_printf("There is no method currently executing\n"); return; } obj_desc = walk_state->method_desc; node = walk_state->method_node; if (walk_state->results) { result_count = walk_state->result_count; } acpi_os_printf("Method [%4.4s] has %X stacked result objects\n", acpi_ut_get_node_name(node), result_count); /* From the top element of result stack */ frame = walk_state->results; index = (result_count - 1) % ACPI_RESULTS_FRAME_OBJ_NUM; for (i = 0; i < result_count; i++) { obj_desc = frame->results.obj_desc[index]; acpi_os_printf("Result%u: ", i); acpi_db_display_internal_object(obj_desc, walk_state); if (index == 0) { frame = frame->results.next; index = ACPI_RESULTS_FRAME_OBJ_NUM; } index--; } } /******************************************************************************* * * FUNCTION: acpi_db_display_calling_tree * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display current calling tree of nested control methods * ******************************************************************************/ void acpi_db_display_calling_tree(void) { struct acpi_walk_state *walk_state; struct acpi_namespace_node *node; walk_state = acpi_ds_get_current_walk_state(acpi_gbl_current_walk_list); if (!walk_state) { acpi_os_printf("There is no method currently executing\n"); return; } node = walk_state->method_node; acpi_os_printf("Current Control Method Call Tree\n"); while (walk_state) { node = walk_state->method_node; acpi_os_printf(" [%4.4s]\n", acpi_ut_get_node_name(node)); walk_state = walk_state->next; } } /******************************************************************************* * * FUNCTION: acpi_db_display_object_type * * PARAMETERS: object_arg - User entered NS node handle * * RETURN: None * * DESCRIPTION: Display type of an arbitrary NS node * ******************************************************************************/ void acpi_db_display_object_type(char *object_arg) { acpi_size arg; acpi_handle handle; struct acpi_device_info *info; acpi_status status; u32 i; arg = strtoul(object_arg, NULL, 16); handle = ACPI_TO_POINTER(arg); status = acpi_get_object_info(handle, &info); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not get object info, %s\n", acpi_format_exception(status)); return; } acpi_os_printf("ADR: %8.8X%8.8X, Flags: %X\n", ACPI_FORMAT_UINT64(info->address), info->flags); acpi_os_printf("S1D-%2.2X S2D-%2.2X S3D-%2.2X S4D-%2.2X\n", info->highest_dstates[0], info->highest_dstates[1], info->highest_dstates[2], info->highest_dstates[3]); acpi_os_printf("S0W-%2.2X S1W-%2.2X S2W-%2.2X S3W-%2.2X S4W-%2.2X\n", info->lowest_dstates[0], info->lowest_dstates[1], info->lowest_dstates[2], info->lowest_dstates[3], info->lowest_dstates[4]); if (info->valid & ACPI_VALID_HID) { acpi_os_printf("HID: %s\n", info->hardware_id.string); } if (info->valid & ACPI_VALID_UID) { acpi_os_printf("UID: %s\n", info->unique_id.string); } if (info->valid & ACPI_VALID_CID) { for (i = 0; i < info->compatible_id_list.count; i++) { acpi_os_printf("CID %u: %s\n", i, info->compatible_id_list.ids[i].string); } } ACPI_FREE(info); } /******************************************************************************* * * FUNCTION: acpi_db_display_result_object * * PARAMETERS: obj_desc - Object to be displayed * walk_state - Current walk state * * RETURN: None * * DESCRIPTION: Display the result of an AML opcode * * Note: Curently only displays the result object if we are single stepping. * However, this output may be useful in other contexts and could be enabled * to do so if needed. * ******************************************************************************/ void acpi_db_display_result_object(union acpi_operand_object *obj_desc, struct acpi_walk_state *walk_state) { #ifndef ACPI_APPLICATION if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) { return; } #endif /* Only display if single stepping */ if (!acpi_gbl_cm_single_step) { return; } acpi_os_printf("ResultObj: "); acpi_db_display_internal_object(obj_desc, walk_state); acpi_os_printf("\n"); } /******************************************************************************* * * FUNCTION: acpi_db_display_argument_object * * PARAMETERS: obj_desc - Object to be displayed * walk_state - Current walk state * * RETURN: None * * DESCRIPTION: Display the result of an AML opcode * ******************************************************************************/ void acpi_db_display_argument_object(union acpi_operand_object *obj_desc, struct acpi_walk_state *walk_state) { #ifndef ACPI_APPLICATION if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) { return; } #endif if (!acpi_gbl_cm_single_step) { return; } acpi_os_printf("ArgObj: "); acpi_db_display_internal_object(obj_desc, walk_state); } #if (!ACPI_REDUCED_HARDWARE) /******************************************************************************* * * FUNCTION: acpi_db_display_gpes * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display the current GPE structures * ******************************************************************************/ void acpi_db_display_gpes(void) { struct acpi_gpe_block_info *gpe_block; struct acpi_gpe_xrupt_info *gpe_xrupt_info; struct acpi_gpe_event_info *gpe_event_info; struct acpi_gpe_register_info *gpe_register_info; char *gpe_type; struct acpi_gpe_notify_info *notify; u32 gpe_index; u32 block = 0; u32 i; u32 j; u32 count; char buffer[80]; struct acpi_buffer ret_buf; acpi_status status; ret_buf.length = sizeof(buffer); ret_buf.pointer = buffer; block = 0; /* Walk the GPE lists */ gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head; while (gpe_xrupt_info) { gpe_block = gpe_xrupt_info->gpe_block_list_head; while (gpe_block) { status = acpi_get_name(gpe_block->node, ACPI_FULL_PATHNAME_NO_TRAILING, &ret_buf); if (ACPI_FAILURE(status)) { acpi_os_printf ("Could not convert name to pathname\n"); } if (gpe_block->node == acpi_gbl_fadt_gpe_device) { gpe_type = "FADT-defined GPE block"; } else { gpe_type = "GPE Block Device"; } acpi_os_printf ("\nBlock %u - Info %p DeviceNode %p [%s] - %s\n", block, gpe_block, gpe_block->node, buffer, gpe_type); acpi_os_printf(" Registers: %u (%u GPEs)\n", gpe_block->register_count, gpe_block->gpe_count); acpi_os_printf (" GPE range: 0x%X to 0x%X on interrupt %u\n", gpe_block->block_base_number, gpe_block->block_base_number + (gpe_block->gpe_count - 1), gpe_xrupt_info->interrupt_number); acpi_os_printf (" RegisterInfo: %p Status %8.8X%8.8X Enable %8.8X%8.8X\n", gpe_block->register_info, ACPI_FORMAT_UINT64(gpe_block->register_info-> status_address.address), ACPI_FORMAT_UINT64(gpe_block->register_info-> enable_address.address)); acpi_os_printf(" EventInfo: %p\n", gpe_block->event_info); /* Examine each GPE Register within the block */ for (i = 0; i < gpe_block->register_count; i++) { gpe_register_info = &gpe_block->register_info[i]; acpi_os_printf(" Reg %u: (GPE %.2X-%.2X) " "RunEnable %2.2X WakeEnable %2.2X" " Status %8.8X%8.8X Enable %8.8X%8.8X\n", i, gpe_register_info-> base_gpe_number, gpe_register_info-> base_gpe_number + (ACPI_GPE_REGISTER_WIDTH - 1), gpe_register_info-> enable_for_run, gpe_register_info-> enable_for_wake, ACPI_FORMAT_UINT64 (gpe_register_info-> status_address.address), ACPI_FORMAT_UINT64 (gpe_register_info-> enable_address.address)); /* Now look at the individual GPEs in this byte register */ for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) { gpe_index = (i * ACPI_GPE_REGISTER_WIDTH) + j; gpe_event_info = &gpe_block->event_info[gpe_index]; if (ACPI_GPE_DISPATCH_TYPE (gpe_event_info->flags) == ACPI_GPE_DISPATCH_NONE) { /* This GPE is not used (no method or handler), ignore it */ continue; } acpi_os_printf (" GPE %.2X: %p RunRefs %2.2X Flags %2.2X (", gpe_block->block_base_number + gpe_index, gpe_event_info, gpe_event_info->runtime_count, gpe_event_info->flags); /* Decode the flags byte */ if (gpe_event_info-> flags & ACPI_GPE_LEVEL_TRIGGERED) { acpi_os_printf("Level, "); } else { acpi_os_printf("Edge, "); } if (gpe_event_info-> flags & ACPI_GPE_CAN_WAKE) { acpi_os_printf("CanWake, "); } else { acpi_os_printf("RunOnly, "); } switch (ACPI_GPE_DISPATCH_TYPE (gpe_event_info->flags)) { case ACPI_GPE_DISPATCH_NONE: acpi_os_printf("NotUsed"); break; case ACPI_GPE_DISPATCH_METHOD: acpi_os_printf("Method"); break; case ACPI_GPE_DISPATCH_HANDLER: acpi_os_printf("Handler"); break; case ACPI_GPE_DISPATCH_NOTIFY: count = 0; notify = gpe_event_info->dispatch. notify_list; while (notify) { count++; notify = notify->next; } acpi_os_printf ("Implicit Notify on %u devices", count); break; case ACPI_GPE_DISPATCH_RAW_HANDLER: acpi_os_printf("RawHandler"); break; default: acpi_os_printf("UNKNOWN: %X", ACPI_GPE_DISPATCH_TYPE (gpe_event_info-> flags)); break; } acpi_os_printf(")\n"); } } block++; gpe_block = gpe_block->next; } gpe_xrupt_info = gpe_xrupt_info->next; } } #endif /* !ACPI_REDUCED_HARDWARE */ /******************************************************************************* * * FUNCTION: acpi_db_display_handlers * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Display the currently installed global handlers * ******************************************************************************/ void acpi_db_display_handlers(void) { union acpi_operand_object *obj_desc; union acpi_operand_object *handler_obj; acpi_adr_space_type space_id; u32 i; /* Operation region handlers */ acpi_os_printf("\nOperation Region Handlers at the namespace root:\n"); obj_desc = acpi_ns_get_attached_object(acpi_gbl_root_node); if (obj_desc) { for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_gbl_space_id_list); i++) { space_id = acpi_gbl_space_id_list[i]; acpi_os_printf(ACPI_PREDEFINED_PREFIX, acpi_ut_get_region_name((u8)space_id), space_id); handler_obj = acpi_ev_find_region_handler(space_id, obj_desc->common_notify. handler); if (handler_obj) { acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, (handler_obj->address_space. handler_flags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default" : "User", handler_obj->address_space. handler); goto found_handler; } /* There is no handler for this space_id */ acpi_os_printf("None\n"); found_handler: ; } /* Find all handlers for user-defined space_IDs */ handler_obj = obj_desc->common_notify.handler; while (handler_obj) { if (handler_obj->address_space.space_id >= ACPI_USER_REGION_BEGIN) { acpi_os_printf(ACPI_PREDEFINED_PREFIX, "User-defined ID", handler_obj->address_space. space_id); acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, (handler_obj->address_space. handler_flags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default" : "User", handler_obj->address_space. handler); } handler_obj = handler_obj->address_space.next; } } #if (!ACPI_REDUCED_HARDWARE) /* Fixed event handlers */ acpi_os_printf("\nFixed Event Handlers:\n"); for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) { acpi_os_printf(ACPI_PREDEFINED_PREFIX, acpi_ut_get_event_name(i), i); if (acpi_gbl_fixed_event_handlers[i].handler) { acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, "User", acpi_gbl_fixed_event_handlers[i]. handler); } else { acpi_os_printf(ACPI_HANDLER_NOT_PRESENT_STRING, "None"); } } #endif /* !ACPI_REDUCED_HARDWARE */ /* Miscellaneous global handlers */ acpi_os_printf("\nMiscellaneous Global Handlers:\n"); for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_gbl_handler_list); i++) { acpi_os_printf(ACPI_HANDLER_NAME_STRING, acpi_gbl_handler_list[i].name); if (acpi_gbl_handler_list[i].handler) { acpi_os_printf(ACPI_HANDLER_PRESENT_STRING, "User", acpi_gbl_handler_list[i].handler); } else { acpi_os_printf(ACPI_HANDLER_NOT_PRESENT_STRING, "None"); } } /* Other handlers that are installed throughout the namespace */ acpi_os_printf("\nOperation Region Handlers for specific devices:\n"); (void)acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_display_non_root_handlers, NULL, NULL, NULL); } /******************************************************************************* * * FUNCTION: acpi_db_display_non_root_handlers * * PARAMETERS: acpi_walk_callback * * RETURN: Status * * DESCRIPTION: Display information about all handlers installed for a * device object. * ******************************************************************************/ static acpi_status acpi_db_display_non_root_handlers(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value) { struct acpi_namespace_node *node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); union acpi_operand_object *obj_desc; union acpi_operand_object *handler_obj; char *pathname; obj_desc = acpi_ns_get_attached_object(node); if (!obj_desc) { return (AE_OK); } pathname = acpi_ns_get_normalized_pathname(node, TRUE); if (!pathname) { return (AE_OK); } /* Display all handlers associated with this device */ handler_obj = obj_desc->common_notify.handler; while (handler_obj) { acpi_os_printf(ACPI_PREDEFINED_PREFIX, acpi_ut_get_region_name((u8)handler_obj-> address_space.space_id), handler_obj->address_space.space_id); acpi_os_printf(ACPI_HANDLER_PRESENT_STRING2, (handler_obj->address_space.handler_flags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) ? "Default" : "User", handler_obj->address_space.handler); acpi_os_printf(" Device Name: %s (%p)\n", pathname, node); handler_obj = handler_obj->address_space.next; } ACPI_FREE(pathname); return (AE_OK); }