/******************************************************************************* * * FUNCTION: acpi_bios_error * * PARAMETERS: module_name - Caller's module name (for error output) * line_number - Caller's line number (for error output) * format - Printf format string + additional args * * RETURN: None * * DESCRIPTION: Print "ACPI Firmware Error" message with module/line/version * info * ******************************************************************************/ void ACPI_INTERNAL_VAR_XFACE acpi_bios_error(const char *module_name, u32 line_number, const char *format, ...) { va_list arg_list; ACPI_MSG_REDIRECT_BEGIN; acpi_os_printf(ACPI_MSG_BIOS_ERROR); va_start(arg_list, format); acpi_os_vprintf(format, arg_list); ACPI_MSG_SUFFIX; va_end(arg_list); ACPI_MSG_REDIRECT_END; }
/******************************************************************************* * * FUNCTION: acpi_exception * * PARAMETERS: module_name - Caller's module name (for error output) * line_number - Caller's line number (for error output) * Status - Status to be formatted * Format - Printf format string + additional args * * RETURN: None * * DESCRIPTION: Print "ACPI Exception" message with module/line/version info * and decoded acpi_status. * ******************************************************************************/ void ACPI_INTERNAL_VAR_XFACE acpi_exception(const char *module_name, u32 line_number, acpi_status status, const char *format, ...) { va_list arg_list; ACPI_MSG_REDIRECT_BEGIN; acpi_os_printf(ACPI_MSG_EXCEPTION "%s, ", acpi_format_exception(status)); va_start(arg_list, format); acpi_os_vprintf(format, arg_list); ACPI_MSG_SUFFIX; va_end(arg_list); ACPI_MSG_REDIRECT_END; }
void acpi_ns_dump_pathname(acpi_handle handle, char *msg, u32 level, u32 component) { ACPI_FUNCTION_TRACE(ns_dump_pathname); /* */ if (!(acpi_dbg_level & level) || !(acpi_dbg_layer & component)) { return_VOID; } /* */ acpi_ns_print_node_pathname(handle, msg); acpi_os_printf("\n"); return_VOID; }
acpi_status acpi_db_find_name_in_namespace ( NATIVE_CHAR *name_arg) { if (STRLEN (name_arg) > 4) { acpi_os_printf ("Name must be no longer than 4 characters\n"); return (AE_OK); } /* Walk the namespace from the root */ acpi_walk_namespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_walk_and_match_name, name_arg, NULL); acpi_db_set_output_destination (DB_CONSOLE_OUTPUT); return (AE_OK); }
void ACPI_INTERNAL_VAR_XFACE acpi_ut_predefined_info(const char *module_name, u32 line_number, char *pathname, u8 node_flags, const char *format, ...) { va_list arg_list; if (node_flags & ANOBJ_EVALUATED) { return; } acpi_os_printf(ACPI_MSG_INFO "For %s: ", pathname); va_start(arg_list, format); acpi_os_vprintf(format, arg_list); ACPI_MSG_SUFFIX; va_end(arg_list); }
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); }
void acpi_ns_dump_pathname(acpi_handle handle, char *msg, u32 level, u32 component) { ACPI_FUNCTION_TRACE(ns_dump_pathname); /* Do this only if the requested debug level and component are enabled */ if (!(acpi_dbg_level & level) || !(acpi_dbg_layer & component)) { return_VOID; } /* Convert handle to a full pathname and print it (with supplied message) */ acpi_ns_print_node_pathname(handle, msg); acpi_os_printf("\n"); return_VOID; }
static acpi_status acpi_db_walk_for_object_counts(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value) { struct acpi_object_info *info = (struct acpi_object_info *)context; struct acpi_namespace_node *node = (struct acpi_namespace_node *)obj_handle; if (node->type > ACPI_TYPE_NS_NODE_MAX) { acpi_os_printf("[%4.4s]: Unknown object type %X\n", node->name.ascii, node->type); } else { info->types[node->type]++; } return (AE_OK); }
void acpi_db_display_object_type(char *object_arg) { acpi_handle handle; struct acpi_device_info *info; acpi_status status; u32 i; handle = ACPI_TO_POINTER(strtoul(object_arg, NULL, 16)); 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, STA: %8.8X, Flags: %X\n", ACPI_FORMAT_UINT64(info->address), info->current_status, 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); }
static void acpi_db_display_help(char *command) { const struct acpi_db_command_help *next = acpi_gbl_db_command_help; if (!command) { /* No argument to help, display help for all commands */ while (next->invocation) { acpi_os_printf("%-38s%s", next->invocation, next->description); next++; } } else { /* Display help for all commands that match the subtring */ acpi_db_display_command_info(command, TRUE); } }
void acpi_db_disassemble_aml ( NATIVE_CHAR *statements, acpi_parse_object *op) { u32 num_statements = 8; if (!op) { acpi_os_printf ("There is no method currently executing\n"); return; } if (statements) { num_statements = STRTOUL (statements, NULL, 0); } acpi_db_display_op (NULL, op, num_statements); }
void ec_print ( EC_CONTEXT *ec) { #ifdef ACPI_DEBUG acpi_buffer buffer; #endif /*ACPI_DEBUG*/ PROC_NAME("ec_print"); if (!ec) { return; } acpi_os_printf("EC: found, GPE %d\n", ec->gpe_bit); #ifdef ACPI_DEBUG buffer.length = 256; buffer.pointer = acpi_os_callocate(buffer.length); if (!buffer.pointer) { return; } /* * Get the full pathname for this ACPI object. */ acpi_get_name(ec->acpi_handle, ACPI_FULL_PATHNAME, &buffer); /* * Print out basic thermal zone information. */ ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------\n")); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "| Embedded_controller[%02x]:[%p] %s\n", ec->device_handle, ec->acpi_handle, (char*)buffer.pointer)); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "| gpe_bit[%02x] status/command_port[%02x] data_port[%02x]\n", ec->gpe_bit, ec->status_port, ec->data_port)); ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------\n")); acpi_os_free(buffer.pointer); #endif /*ACPI_DEBUG*/ return; }
acpi_status acpi_ut_read_table_from_file(char *filename, struct acpi_table_header ** table) { FILE *file; u32 file_size; u32 table_length; acpi_status status = AE_ERROR; /* Open the file, get current size */ file = fopen(filename, "rb"); if (!file) { perror("Could not open input file"); if (errno == ENOENT) { return (AE_NOT_EXIST); } return (status); } file_size = cm_get_file_size(file); if (file_size == ACPI_UINT32_MAX) { goto exit; } /* Get the entire file */ fprintf(stderr, "Reading ACPI table from file %12s - Length %.8u (0x%06X)\n", filename, file_size, file_size); status = acpi_ut_read_table(file, table, &table_length); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not get table from the file\n"); } exit: fclose(file); return (status); }
void acpi_ns_dump_object_paths(acpi_object_type type, u8 display_type, u32 max_depth, acpi_owner_id owner_id, acpi_handle start_handle) { acpi_status status; u32 max_level = 0; ACPI_FUNCTION_ENTRY(); /* * Just lock the entire namespace for the duration of the dump. * We don't want any changes to the namespace during this time, * especially the temporary nodes since we are going to display * them also. */ status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); if (ACPI_FAILURE(status)) { acpi_os_printf("Could not acquire namespace mutex\n"); return; } /* Get the max depth of the namespace tree, for formatting later */ (void)acpi_ns_walk_namespace(type, start_handle, max_depth, ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES, acpi_ns_get_max_depth, NULL, (void *)&max_level, NULL); /* Now dump the entire namespace */ (void)acpi_ns_walk_namespace(type, start_handle, max_depth, ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES, acpi_ns_dump_one_object_path, NULL, (void *)&max_level, NULL); (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); }
static u32 acpi_db_get_line(char *input_buffer) { u32 i; u32 count; char *next; char *this; if (acpi_ut_safe_strcpy (acpi_gbl_db_parsed_buf, sizeof(acpi_gbl_db_parsed_buf), input_buffer)) { acpi_os_printf ("Buffer overflow while parsing input line (max %u characters)\n", sizeof(acpi_gbl_db_parsed_buf)); return (0); } this = acpi_gbl_db_parsed_buf; for (i = 0; i < ACPI_DEBUGGER_MAX_ARGS; i++) { acpi_gbl_db_args[i] = acpi_db_get_next_token(this, &next, &acpi_gbl_db_arg_types [i]); if (!acpi_gbl_db_args[i]) { break; } this = next; } /* Uppercase the actual command */ if (acpi_gbl_db_args[0]) { acpi_ut_strupr(acpi_gbl_db_args[0]); } count = i; if (count) { count--; /* Number of args only */ } return (count); }
static void acpi_db_evaluate_all_predefined_names(char *count_arg) { struct acpi_db_execute_walk info; info.count = 0; info.max_count = ACPI_UINT32_MAX; if (count_arg) { info.max_count = strtoul(count_arg, NULL, 0); } /* Search all nodes in namespace */ (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_evaluate_one_predefined_name, NULL, (void *)&info, NULL); acpi_os_printf("Evaluated %u predefined names in the namespace\n", info.count); }
static u8 acpi_db_match_command_help(const char *command, const struct acpi_db_command_help *help) { char *invocation = help->invocation; u32 line_count; /* Valid commands in the help table begin with a couple of spaces */ if (*invocation != ' ') { return (FALSE); } while (*invocation == ' ') { invocation++; } /* Match command name (full command or substring) */ while ((*command) && (*invocation) && (*invocation != ' ')) { if (tolower((int)*command) != tolower((int)*invocation)) { return (FALSE); } invocation++; command++; } /* Print the appropriate number of help lines */ line_count = help->line_count; while (line_count) { acpi_os_printf("%-38s : %s", help->invocation, help->description); help++; line_count--; } return (TRUE); }
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); }
void ACPI_INTERNAL_VAR_XFACE acpi_ut_predefined_info(const char *module_name, u32 line_number, char *pathname, u8 node_flags, const char *format, ...) { va_list arg_list; /* * Warning messages for this method/object will be disabled after the * first time a validation fails or an object is successfully repaired. */ if (node_flags & ANOBJ_EVALUATED) { return; } acpi_os_printf(ACPI_MSG_INFO "For %s: ", pathname); va_start(arg_list, format); acpi_os_vprintf(format, arg_list); ACPI_MSG_SUFFIX; va_end(arg_list); }
void acpi_ex_dump_namespace_node(struct acpi_namespace_node *node, u32 flags) { ACPI_FUNCTION_ENTRY(); if (!flags) { if (! ((ACPI_LV_OBJECTS & acpi_dbg_level) && (_COMPONENT & acpi_dbg_layer))) { return; } } acpi_os_printf("%20s : %4.4s\n", "Name", acpi_ut_get_node_name(node)); acpi_ex_out_string("Type", acpi_ut_get_type_name(node->type)); acpi_ex_out_pointer("Attached Object", acpi_ns_get_attached_object(node)); acpi_ex_out_pointer("Parent", acpi_ns_get_parent_node(node)); acpi_ex_dump_object(ACPI_CAST_PTR(union acpi_operand_object, node), acpi_ex_dump_node); }
acpi_status acpi_db_user_commands(void) { acpi_status status = AE_OK; acpi_os_printf("\n"); /* TBD: [Restructure] Need a separate command line buffer for step mode */ while (!acpi_gbl_db_terminate_loop) { /* Wait the readiness of the command */ status = acpi_os_wait_command_ready(); if (ACPI_FAILURE(status)) { break; } /* Just call to the command line interpreter */ acpi_gbl_method_executing = FALSE; acpi_gbl_step_to_next_call = FALSE; (void)acpi_db_command_dispatch(acpi_gbl_db_line_buf, NULL, NULL); /* Notify the completion of the command */ status = acpi_os_notify_command_complete(); if (ACPI_FAILURE(status)) { break; } } if (ACPI_FAILURE(status) && status != AE_CTRL_TERMINATE) { ACPI_EXCEPTION((AE_INFO, status, "While parsing command line")); } return (status); }
void acpi_db_dump_namespace_by_owner(char *owner_arg, char *depth_arg) { acpi_handle subtree_entry = acpi_gbl_root_node; u32 max_depth = ACPI_UINT32_MAX; acpi_owner_id owner_id; owner_id = (acpi_owner_id)strtoul(owner_arg, NULL, 0); /* Now we can check for the depth argument */ if (depth_arg) { max_depth = strtoul(depth_arg, NULL, 0); } acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT); acpi_os_printf("ACPI Namespace by owner %X:\n", owner_id); /* Display the subtree */ acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT); acpi_ns_dump_objects(ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, max_depth, owner_id, subtree_entry); acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); }
static acpi_status acpi_db_bus_walk(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value) { struct acpi_namespace_node *node = (struct acpi_namespace_node *)obj_handle; acpi_status status; struct acpi_buffer buffer; struct acpi_namespace_node *temp_node; struct acpi_device_info *info; u32 i; if ((node->type != ACPI_TYPE_DEVICE) && (node->type != ACPI_TYPE_PROCESSOR)) { return (AE_OK); } /* Exit if there is no _PRT under this device */ status = acpi_get_handle(node, METHOD_NAME__PRT, ACPI_CAST_PTR(acpi_handle, &temp_node)); if (ACPI_FAILURE(status)) { return (AE_OK); } /* Get the full path to this device object */ buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; status = acpi_ns_handle_to_pathname(obj_handle, &buffer, TRUE); if (ACPI_FAILURE(status)) { acpi_os_printf("Could Not get pathname for object %p\n", obj_handle); return (AE_OK); } status = acpi_get_object_info(obj_handle, &info); if (ACPI_FAILURE(status)) { return (AE_OK); } /* Display the full path */ acpi_os_printf("%-32s Type %X", (char *)buffer.pointer, node->type); ACPI_FREE(buffer.pointer); if (info->flags & ACPI_PCI_ROOT_BRIDGE) { acpi_os_printf(" - Is PCI Root Bridge"); } acpi_os_printf("\n"); /* _PRT info */ acpi_os_printf("_PRT: %p\n", temp_node); /* Dump _ADR, _HID, _UID, _CID */ if (info->valid & ACPI_VALID_ADR) { acpi_os_printf("_ADR: %8.8X%8.8X\n", ACPI_FORMAT_UINT64(info->address)); } else { acpi_os_printf("_ADR: <Not Present>\n"); } if (info->valid & ACPI_VALID_HID) { acpi_os_printf("_HID: %s\n", info->hardware_id.string); } else { acpi_os_printf("_HID: <Not Present>\n"); } if (info->valid & ACPI_VALID_UID) { acpi_os_printf("_UID: %s\n", info->unique_id.string); } else { acpi_os_printf("_UID: <Not Present>\n"); } if (info->valid & ACPI_VALID_CID) { for (i = 0; i < info->compatible_id_list.count; i++) { acpi_os_printf("_CID: %s\n", info->compatible_id_list.ids[i].string); } } else { acpi_os_printf("_CID: <Not Present>\n"); } ACPI_FREE(info); return (AE_OK); }
acpi_status acpi_db_display_objects(char *obj_type_arg, char *display_count_arg) { struct acpi_walk_info info; acpi_object_type type; struct acpi_object_info *object_info; u32 i; u32 total_objects = 0; /* No argument means display summary/count of all object types */ if (!obj_type_arg) { object_info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_object_info)); /* Walk the namespace from the root */ (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_walk_for_object_counts, NULL, (void *)object_info, NULL); acpi_os_printf("\nSummary of namespace objects:\n\n"); for (i = 0; i < ACPI_TOTAL_TYPES; i++) { acpi_os_printf("%8u %s\n", object_info->types[i], acpi_ut_get_type_name(i)); total_objects += object_info->types[i]; } acpi_os_printf("\n%8u Total namespace objects\n\n", total_objects); ACPI_FREE(object_info); return (AE_OK); } /* Get the object type */ type = acpi_db_match_argument(obj_type_arg, acpi_db_object_types); if (type == ACPI_TYPE_NOT_FOUND) { acpi_os_printf("Invalid or unsupported argument\n"); return (AE_OK); } acpi_db_set_output_destination(ACPI_DB_DUPLICATE_OUTPUT); acpi_os_printf ("Objects of type [%s] defined in the current ACPI Namespace:\n", acpi_ut_get_type_name(type)); acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT); info.count = 0; info.owner_id = ACPI_OWNER_ID_MAX; info.debug_level = ACPI_UINT32_MAX; info.display_type = ACPI_DISPLAY_SUMMARY | ACPI_DISPLAY_SHORT; /* Walk the namespace from the root */ (void)acpi_walk_namespace(type, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_walk_for_specific_objects, NULL, (void *)&info, NULL); acpi_os_printf ("\nFound %u objects of type [%s] in the current ACPI Namespace\n", info.count, acpi_ut_get_type_name(type)); acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); return (AE_OK); }
acpi_status acpi_db_second_pass_parse ( acpi_parse_object *root) { acpi_parse_object *op = root; acpi_parse2_object *method; acpi_parse_object *search_op; acpi_parse_object *start_op; acpi_status status = AE_OK; u32 base_aml_offset; acpi_walk_state *walk_state; FUNCTION_ENTRY (); acpi_os_printf ("Pass two parse ....\n"); while (op) { if (op->opcode == AML_METHOD_OP) { method = (acpi_parse2_object *) op; walk_state = acpi_ds_create_walk_state (TABLE_ID_DSDT, NULL, NULL, NULL); if (!walk_state) { return (AE_NO_MEMORY); } walk_state->parser_state.aml = walk_state->parser_state.aml_start = method->data; walk_state->parser_state.aml_end = walk_state->parser_state.pkg_end = method->data + method->length; walk_state->parser_state.start_scope = op; walk_state->descending_callback = acpi_ds_load1_begin_op; walk_state->ascending_callback = acpi_ds_load1_end_op; status = acpi_ps_parse_aml (walk_state); base_aml_offset = (method->value.arg)->aml_offset + 1; start_op = (method->value.arg)->next; search_op = start_op; while (search_op) { search_op->aml_offset += base_aml_offset; search_op = acpi_ps_get_depth_next (start_op, search_op); } } if (op->opcode == AML_REGION_OP) { /* TBD: [Investigate] this isn't quite the right thing to do! */ /* * * Method = (ACPI_DEFERRED_OP *) Op; * Status = Acpi_ps_parse_aml (Op, Method->Body, Method->Body_length); */ } if (ACPI_FAILURE (status)) { break; } op = acpi_ps_get_depth_next (root, op); } return (status); }
void acpi_db_dump_object ( acpi_object *obj_desc, u32 level) { u32 i; if (!obj_desc) { acpi_os_printf ("[Null Object]\n"); return; } for (i = 0; i < level; i++) { acpi_os_printf (" "); } switch (obj_desc->type) { case ACPI_TYPE_ANY: acpi_os_printf ("[Object Reference] = %p\n", obj_desc->reference.handle); break; case ACPI_TYPE_INTEGER: acpi_os_printf ("[Integer] = %8.8X%8.8X\n", HIDWORD (obj_desc->integer.value), LODWORD (obj_desc->integer.value)); break; case ACPI_TYPE_STRING: acpi_os_printf ("[String] Value: "); for (i = 0; i < obj_desc->string.length; i++) { acpi_os_printf ("%c", obj_desc->string.pointer[i]); } acpi_os_printf ("\n"); break; case ACPI_TYPE_BUFFER: acpi_os_printf ("[Buffer] = "); acpi_ut_dump_buffer ((u8 *) obj_desc->buffer.pointer, obj_desc->buffer.length, DB_DWORD_DISPLAY, _COMPONENT); break; case ACPI_TYPE_PACKAGE: acpi_os_printf ("[Package] Contains %d Elements: \n", obj_desc->package.count); for (i = 0; i < obj_desc->package.count; i++) { acpi_db_dump_object (&obj_desc->package.elements[i], level+1); } break; case INTERNAL_TYPE_REFERENCE: acpi_os_printf ("[Object Reference] = %p\n", obj_desc->reference.handle); break; case ACPI_TYPE_PROCESSOR: acpi_os_printf ("[Processor]\n"); break; case ACPI_TYPE_POWER: acpi_os_printf ("[Power Resource]\n"); break; default: acpi_os_printf ("[Unknown Type] %X \n", obj_desc->type); break; } }
acpi_status acpi_db_single_step ( acpi_walk_state *walk_state, acpi_parse_object *op, u32 opcode_class) { acpi_parse_object *next; acpi_status status = AE_OK; u32 original_debug_level; acpi_parse_object *display_op; FUNCTION_ENTRY (); /* Is there a breakpoint set? */ if (walk_state->method_breakpoint) { /* Check if the breakpoint has been reached or passed */ if (walk_state->method_breakpoint <= op->aml_offset) { /* Hit the breakpoint, resume single step, reset breakpoint */ acpi_os_printf ("***Break*** at AML offset %X\n", op->aml_offset); acpi_gbl_cm_single_step = TRUE; acpi_gbl_step_to_next_call = FALSE; walk_state->method_breakpoint = 0; } } /* * Check if this is an opcode that we are interested in -- * namely, opcodes that have arguments */ if (op->opcode == AML_INT_NAMEDFIELD_OP) { return (AE_OK); } switch (opcode_class) { case AML_CLASS_UNKNOWN: case AML_CLASS_ARGUMENT: /* constants, literals, etc. do nothing */ return (AE_OK); break; } /* * Under certain debug conditions, display this opcode and its operands */ if ((acpi_gbl_db_output_to_file) || (acpi_gbl_cm_single_step) || (acpi_dbg_level & ACPI_LV_PARSE)) { if ((acpi_gbl_db_output_to_file) || (acpi_dbg_level & ACPI_LV_PARSE)) { acpi_os_printf ("\n[Aml_debug] Next AML Opcode to execute:\n"); } /* * Display this op (and only this op - zero out the NEXT field temporarily, * and disable parser trace output for the duration of the display because * we don't want the extraneous debug output) */ original_debug_level = acpi_dbg_level; acpi_dbg_level &= ~(ACPI_LV_PARSE | ACPI_LV_FUNCTIONS); next = op->next; op->next = NULL; display_op = op; if (op->parent) { if ((op->parent->opcode == AML_IF_OP) || (op->parent->opcode == AML_WHILE_OP)) { display_op = op->parent; } } /* Now we can display it */ acpi_db_display_op (walk_state, display_op, ACPI_UINT32_MAX); if ((op->opcode == AML_IF_OP) || (op->opcode == AML_WHILE_OP)) { if (walk_state->control_state->common.value) { acpi_os_printf ("Predicate was TRUE, executed block\n"); } else { acpi_os_printf ("Predicate is FALSE, skipping block\n"); } } else if (op->opcode == AML_ELSE_OP) { /* TBD */ } /* Restore everything */ op->next = next; acpi_os_printf ("\n"); acpi_dbg_level = original_debug_level; } /* If we are not single stepping, just continue executing the method */ if (!acpi_gbl_cm_single_step) { return (AE_OK); } /* * If we are executing a step-to-call command, * Check if this is a method call. */ if (acpi_gbl_step_to_next_call) { if (op->opcode != AML_INT_METHODCALL_OP) { /* Not a method call, just keep executing */ return (AE_OK); } /* Found a method call, stop executing */ acpi_gbl_step_to_next_call = FALSE; } /* * If the next opcode is a method call, we will "step over" it * by default. */ if (op->opcode == AML_INT_METHODCALL_OP) { acpi_gbl_cm_single_step = FALSE; /* No more single step while executing called method */ /* Set the breakpoint on the call, it will stop execution as soon as we return */ /* TBD: [Future] don't kill the user breakpoint! */ walk_state->method_breakpoint = /* Op->Aml_offset + */ 1; /* Must be non-zero! */ } /* TBD: [Investigate] what are the namespace locking issues here */ /* Acpi_ut_release_mutex (ACPI_MTX_NAMESPACE); */ /* Go into the command loop and await next user command */ acpi_gbl_method_executing = TRUE; status = AE_CTRL_TRUE; while (status == AE_CTRL_TRUE) { if (acpi_gbl_debugger_configuration == DEBUGGER_MULTI_THREADED) { /* Handshake with the front-end that gets user command lines */ acpi_ut_release_mutex (ACPI_MTX_DEBUG_CMD_COMPLETE); acpi_ut_acquire_mutex (ACPI_MTX_DEBUG_CMD_READY); } else { /* Single threaded, we must get a command line ourselves */ /* Force output to console until a command is entered */ acpi_db_set_output_destination (DB_CONSOLE_OUTPUT); /* Different prompt if method is executing */ if (!acpi_gbl_method_executing) { acpi_os_printf ("%1c ", DB_COMMAND_PROMPT); } else { acpi_os_printf ("%1c ", DB_EXECUTE_PROMPT); } /* Get the user input line */ acpi_os_get_line (acpi_gbl_db_line_buf); } status = acpi_db_command_dispatch (acpi_gbl_db_line_buf, walk_state, op); } /* Acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE); */ /* User commands complete, continue execution of the interrupted method */ return (status); }
void acpi_ut_dump_allocations(u32 component, const char *module) { struct acpi_debug_mem_block *element; union acpi_descriptor *descriptor; u32 num_outstanding = 0; u8 descriptor_type; ACPI_FUNCTION_TRACE(ut_dump_allocations); if (acpi_gbl_disable_mem_tracking) { return_VOID; } /* * Walk the allocation list. */ if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) { return_VOID; } element = acpi_gbl_global_list->list_head; while (element) { if ((element->component & component) && ((module == NULL) || (0 == strcmp(module, element->module)))) { descriptor = ACPI_CAST_PTR(union acpi_descriptor, &element->user_space); if (element->size < sizeof(struct acpi_common_descriptor)) { acpi_os_printf("%p Length 0x%04X %9.9s-%u " "[Not a Descriptor - too small]\n", descriptor, element->size, element->module, element->line); } else { /* Ignore allocated objects that are in a cache */ if (ACPI_GET_DESCRIPTOR_TYPE(descriptor) != ACPI_DESC_TYPE_CACHED) { acpi_os_printf ("%p Length 0x%04X %9.9s-%u [%s] ", descriptor, element->size, element->module, element->line, acpi_ut_get_descriptor_name (descriptor)); /* Validate the descriptor type using Type field and length */ descriptor_type = 0; /* Not a valid descriptor type */ switch (ACPI_GET_DESCRIPTOR_TYPE (descriptor)) { case ACPI_DESC_TYPE_OPERAND: if (element->size == sizeof(union acpi_operand_object)) { descriptor_type = ACPI_DESC_TYPE_OPERAND; } break; case ACPI_DESC_TYPE_PARSER: if (element->size == sizeof(union acpi_parse_object)) { descriptor_type = ACPI_DESC_TYPE_PARSER; } break; case ACPI_DESC_TYPE_NAMED: if (element->size == sizeof(struct acpi_namespace_node)) { descriptor_type = ACPI_DESC_TYPE_NAMED; } break; default: break; } /* Display additional info for the major descriptor types */ switch (descriptor_type) { case ACPI_DESC_TYPE_OPERAND: acpi_os_printf ("%12.12s RefCount 0x%04X\n", acpi_ut_get_type_name (descriptor->object.common. type), descriptor->object.common. reference_count); break; case ACPI_DESC_TYPE_PARSER: acpi_os_printf ("AmlOpcode 0x%04hX\n", descriptor->op.asl. aml_opcode); break; case ACPI_DESC_TYPE_NAMED: acpi_os_printf("%4.4s\n", acpi_ut_get_node_name (&descriptor-> node)); break; default: acpi_os_printf("\n"); break; } } } num_outstanding++; } element = element->next; }
void acpi_ut_dump_buffer2(u8 * buffer, u32 count, u32 display) { u32 i = 0; u32 j; u32 temp32; u8 buf_char; if (!buffer) { acpi_os_printf("Null Buffer Pointer in DumpBuffer!\n"); return; } if ((count < 4) || (count & 0x01)) { display = DB_BYTE_DISPLAY; } /* Nasty little dump buffer routine! */ while (i < count) { /* Print current offset */ acpi_os_printf("%6.4X: ", i); /* Print 16 hex chars */ for (j = 0; j < 16;) { if (i + j >= count) { /* Dump fill spaces */ acpi_os_printf("%*s", ((display * 2) + 1), " "); j += display; continue; } switch (display) { case DB_BYTE_DISPLAY: default: /* Default is BYTE display */ acpi_os_printf("%02X ", buffer[(acpi_size) i + j]); break; case DB_WORD_DISPLAY: ACPI_MOVE_16_TO_32(&temp32, &buffer[(acpi_size) i + j]); acpi_os_printf("%04X ", temp32); break; case DB_DWORD_DISPLAY: ACPI_MOVE_32_TO_32(&temp32, &buffer[(acpi_size) i + j]); acpi_os_printf("%08X ", temp32); break; case DB_QWORD_DISPLAY: ACPI_MOVE_32_TO_32(&temp32, &buffer[(acpi_size) i + j]); acpi_os_printf("%08X", temp32); ACPI_MOVE_32_TO_32(&temp32, &buffer[(acpi_size) i + j + 4]); acpi_os_printf("%08X ", temp32); break; } j += display; } /* * Print the ASCII equivalent characters but watch out for the bad * unprintable ones (printable chars are 0x20 through 0x7E) */ acpi_os_printf(" "); for (j = 0; j < 16; j++) { if (i + j >= count) { acpi_os_printf("\n"); return; } buf_char = buffer[(acpi_size) i + j]; if (ACPI_IS_PRINT(buf_char)) { acpi_os_printf("%c", buf_char); } else { acpi_os_printf("."); } } /* Done with that line. */ acpi_os_printf("\n"); i += 16; } return; }
void acpi_ut_print_string(char *string, u16 max_length) { u32 i; if (!string) { acpi_os_printf("<\"NULL STRING PTR\">"); return; } acpi_os_printf("\""); for (i = 0; (i < max_length) && string[i]; i++) { /* Escape sequences */ switch (string[i]) { case 0x07: acpi_os_printf("\\a"); /* BELL */ break; case 0x08: acpi_os_printf("\\b"); /* BACKSPACE */ break; case 0x0C: acpi_os_printf("\\f"); /* FORMFEED */ break; case 0x0A: acpi_os_printf("\\n"); /* LINEFEED */ break; case 0x0D: acpi_os_printf("\\r"); /* CARRIAGE RETURN */ break; case 0x09: acpi_os_printf("\\t"); /* HORIZONTAL TAB */ break; case 0x0B: acpi_os_printf("\\v"); /* VERTICAL TAB */ break; case '\'': /* Single Quote */ case '\"': /* Double Quote */ case '\\': /* Backslash */ acpi_os_printf("\\%c", (int)string[i]); break; default: /* Check for printable character or hex escape */ if (ACPI_IS_PRINT(string[i])) { /* This is a normal character */ acpi_os_printf("%c", (int)string[i]); } else { /* All others will be Hex escapes */ acpi_os_printf("\\x%2.2X", (s32) string[i]); } break; } } acpi_os_printf("\""); if (i == max_length && string[i]) { acpi_os_printf("..."); } }