acpi_status acpi_db_single_step(struct acpi_walk_state * walk_state, union acpi_parse_object * op, u32 opcode_class) { union acpi_parse_object *next; acpi_status status = AE_OK; u32 original_debug_level; union acpi_parse_object *display_op; union acpi_parse_object *parent_op; u32 aml_offset; ACPI_FUNCTION_ENTRY(); #ifndef ACPI_APPLICATION if (acpi_gbl_db_thread_id != acpi_os_get_thread_id()) { return (AE_OK); } #endif /* Check the abort flag */ if (acpi_gbl_abort_method) { acpi_gbl_abort_method = FALSE; return (AE_ABORT_METHOD); } aml_offset = (u32)ACPI_PTR_DIFF(op->common.aml, walk_state->parser_state.aml_start); /* Check for single-step breakpoint */ if (walk_state->method_breakpoint && (walk_state->method_breakpoint <= aml_offset)) { /* Check if the breakpoint has been reached or passed */ /* Hit the breakpoint, resume single step, reset breakpoint */ acpi_os_printf("***Break*** at AML offset %X\n", aml_offset); acpi_gbl_cm_single_step = TRUE; acpi_gbl_step_to_next_call = FALSE; walk_state->method_breakpoint = 0; } /* Check for user breakpoint (Must be on exact Aml offset) */ else if (walk_state->user_breakpoint && (walk_state->user_breakpoint == aml_offset)) { acpi_os_printf("***UserBreakpoint*** at AML offset %X\n", 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->common.aml_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); default: /* All other opcodes -- continue */ 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[AmlDebug] 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->common.next; op->common.next = NULL; display_op = op; parent_op = op->common.parent; if (parent_op) { if ((walk_state->control_state) && (walk_state->control_state->common.state == ACPI_CONTROL_PREDICATE_EXECUTING)) { /* * We are executing the predicate of an IF or WHILE statement * Search upwards for the containing IF or WHILE so that the * entire predicate can be displayed. */ while (parent_op) { if ((parent_op->common.aml_opcode == AML_IF_OP) || (parent_op->common.aml_opcode == AML_WHILE_OP)) { display_op = parent_op; break; } parent_op = parent_op->common.parent; } } else { while (parent_op) { if ((parent_op->common.aml_opcode == AML_IF_OP) || (parent_op->common.aml_opcode == AML_ELSE_OP) || (parent_op->common.aml_opcode == AML_SCOPE_OP) || (parent_op->common.aml_opcode == AML_METHOD_OP) || (parent_op->common.aml_opcode == AML_WHILE_OP)) { break; } display_op = parent_op; parent_op = parent_op->common.parent; } } } /* Now we can display it */ #ifdef ACPI_DISASSEMBLER acpi_dm_disassemble(walk_state, display_op, ACPI_UINT32_MAX); #endif if ((op->common.aml_opcode == AML_IF_OP) || (op->common.aml_opcode == AML_WHILE_OP)) { if (walk_state->control_state->common.value) { acpi_os_printf ("Predicate = [True], IF block was executed\n"); } else { acpi_os_printf ("Predicate = [False], Skipping IF block\n"); } } else if (op->common.aml_opcode == AML_ELSE_OP) { acpi_os_printf ("Predicate = [False], ELSE block was executed\n"); } /* Restore everything */ op->common.next = next; acpi_os_printf("\n"); if ((acpi_gbl_db_output_to_file) || (acpi_dbg_level & ACPI_LV_PARSE)) { 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->common.aml_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->common.aml_opcode == AML_INT_METHODCALL_OP) { /* Force no more single stepping while executing called method */ acpi_gbl_cm_single_step = FALSE; /* * Set the breakpoint on/before the call, it will stop execution * as soon as we return */ walk_state->method_breakpoint = 1; /* Must be non-zero! */ } status = acpi_db_start_command(walk_state, op); /* User commands complete, continue execution of the interrupted method */ return (status); }
void acpi_ds_dump_method_stack(acpi_status status, struct acpi_walk_state *walk_state, union acpi_parse_object *op) { union acpi_parse_object *next; struct acpi_thread_state *thread; struct acpi_walk_state *next_walk_state; struct acpi_namespace_node *previous_method = NULL; union acpi_operand_object *method_desc; ACPI_FUNCTION_TRACE(ds_dump_method_stack); /* Ignore control codes, they are not errors */ if ((status & AE_CODE_MASK) == AE_CODE_CONTROL) { return_VOID; } /* We may be executing a deferred opcode */ if (walk_state->deferred_node) { ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Executing subtree for Buffer/Package/Region\n")); return_VOID; } /* * If there is no Thread, we are not actually executing a method. * This can happen when the iASL compiler calls the interpreter * to perform constant folding. */ thread = walk_state->thread; if (!thread) { return_VOID; } /* Display exception and method name */ ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "\n**** Exception %s during execution of method ", acpi_format_exception(status))); acpi_ds_print_node_pathname(walk_state->method_node, NULL); /* Display stack of executing methods */ ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH, "\n\nMethod Execution Stack:\n")); next_walk_state = thread->walk_state_list; /* Walk list of linked walk states */ while (next_walk_state) { method_desc = next_walk_state->method_desc; if (method_desc) { acpi_ex_stop_trace_method((struct acpi_namespace_node *) method_desc->method.node, method_desc, walk_state); } ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, " Method [%4.4s] executing: ", acpi_ut_get_node_name(next_walk_state-> method_node))); /* First method is the currently executing method */ if (next_walk_state == walk_state) { if (op) { /* Display currently executing ASL statement */ next = op->common.next; op->common.next = NULL; #ifdef ACPI_DISASSEMBLER acpi_dm_disassemble(next_walk_state, op, ACPI_UINT32_MAX); #endif op->common.next = next; } } else { /* * This method has called another method * NOTE: the method call parse subtree is already deleted at * this point, so we cannot disassemble the method invocation. */ ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH, "Call to method ")); acpi_ds_print_node_pathname(previous_method, NULL); } previous_method = next_walk_state->method_node; next_walk_state = next_walk_state->next; ACPI_DEBUG_PRINT_RAW((ACPI_DB_DISPATCH, "\n")); } return_VOID; }