static void acpi_db_single_thread(void) { acpi_gbl_method_executing = FALSE; acpi_gbl_step_to_next_call = FALSE; (void)acpi_db_command_dispatch(acpi_gbl_db_line_buf, NULL, NULL); }
void ACPI_SYSTEM_XFACE acpi_db_execute_thread(void *context) { acpi_status status = AE_OK; acpi_status Mstatus; while (status != AE_CTRL_TERMINATE && !acpi_gbl_db_terminate_loop) { acpi_gbl_method_executing = FALSE; acpi_gbl_step_to_next_call = FALSE; Mstatus = acpi_os_acquire_mutex(acpi_gbl_db_command_ready, ACPI_WAIT_FOREVER); if (ACPI_FAILURE(Mstatus)) { return; } status = acpi_db_command_dispatch(acpi_gbl_db_line_buf, NULL, NULL); acpi_os_release_mutex(acpi_gbl_db_command_complete); } acpi_gbl_db_threads_terminated = TRUE; }
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); }
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); }
static acpi_status acpi_db_start_command(struct acpi_walk_state *walk_state, union acpi_parse_object *op) { acpi_status status; /* TBD: [Investigate] are there 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_os_release_mutex(acpi_gbl_db_command_complete); status = acpi_os_acquire_mutex(acpi_gbl_db_command_ready, ACPI_WAIT_FOREVER); if (ACPI_FAILURE(status)) { return (status); } } else { /* Single threaded, we must get a command line ourselves */ /* Force output to console until a command is entered */ acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); /* Different prompt if method is executing */ if (!acpi_gbl_method_executing) { acpi_os_printf("%1c ", ACPI_DEBUGGER_COMMAND_PROMPT); } else { acpi_os_printf("%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT); } /* Get the user input line */ status = acpi_os_get_line(acpi_gbl_db_line_buf, ACPI_DB_LINE_BUFFER_SIZE, NULL); if (ACPI_FAILURE(status)) { ACPI_EXCEPTION((AE_INFO, status, "While parsing command line")); return (status); } } status = acpi_db_command_dispatch(acpi_gbl_db_line_buf, walk_state, op); } /* acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE); */ return (status); }
acpi_status acpi_db_command_dispatch(char *input_buffer, struct acpi_walk_state * walk_state, union acpi_parse_object * op) { u32 temp; u32 command_index; u32 param_count; char *command_line; acpi_status status = AE_CTRL_TRUE; /* If acpi_terminate has been called, terminate this thread */ if (acpi_gbl_db_terminate_loop) { return (AE_CTRL_TERMINATE); } /* Find command and add to the history buffer */ param_count = acpi_db_get_line(input_buffer); command_index = acpi_db_match_command(acpi_gbl_db_args[0]); temp = 0; /* * We don't want to add the !! command to the history buffer. It * would cause an infinite loop because it would always be the * previous command. */ if (command_index != CMD_HISTORY_LAST) { acpi_db_add_to_history(input_buffer); } /* Verify that we have the minimum number of params */ if (param_count < acpi_gbl_db_commands[command_index].min_args) { acpi_os_printf ("%u parameters entered, [%s] requires %u parameters\n", param_count, acpi_gbl_db_commands[command_index].name, acpi_gbl_db_commands[command_index].min_args); acpi_db_display_command_info(acpi_gbl_db_commands [command_index].name, FALSE); return (AE_CTRL_TRUE); } /* Decode and dispatch the command */ switch (command_index) { case CMD_NULL: if (op) { return (AE_OK); } break; case CMD_ALLOCATIONS: #ifdef ACPI_DBG_TRACK_ALLOCATIONS acpi_ut_dump_allocations((u32)-1, NULL); #endif break; case CMD_ARGS: case CMD_ARGUMENTS: acpi_db_display_arguments(); break; case CMD_BREAKPOINT: acpi_db_set_method_breakpoint(acpi_gbl_db_args[1], walk_state, op); break; case CMD_BUSINFO: acpi_db_get_bus_info(); break; case CMD_CALL: acpi_db_set_method_call_breakpoint(op); status = AE_OK; break; case CMD_DEBUG: acpi_db_execute(acpi_gbl_db_args[1], &acpi_gbl_db_args[2], &acpi_gbl_db_arg_types[2], EX_SINGLE_STEP); break; case CMD_DISASSEMBLE: case CMD_DISASM: (void)acpi_db_disassemble_method(acpi_gbl_db_args[1]); break; case CMD_DUMP: acpi_db_decode_and_display_object(acpi_gbl_db_args[1], acpi_gbl_db_args[2]); break; case CMD_EVALUATE: case CMD_EXECUTE: acpi_db_execute(acpi_gbl_db_args[1], &acpi_gbl_db_args[2], &acpi_gbl_db_arg_types[2], EX_NO_SINGLE_STEP); break; case CMD_FIND: status = acpi_db_find_name_in_namespace(acpi_gbl_db_args[1]); break; case CMD_GO: acpi_gbl_cm_single_step = FALSE; return (AE_OK); case CMD_HANDLERS: acpi_db_display_handlers(); break; case CMD_HELP: case CMD_HELP2: acpi_db_display_help(acpi_gbl_db_args[1]); break; case CMD_HISTORY: acpi_db_display_history(); break; case CMD_HISTORY_EXE: /* ! command */ command_line = acpi_db_get_from_history(acpi_gbl_db_args[1]); if (!command_line) { return (AE_CTRL_TRUE); } status = acpi_db_command_dispatch(command_line, walk_state, op); return (status); case CMD_HISTORY_LAST: /* !! command */ command_line = acpi_db_get_from_history(NULL); if (!command_line) { return (AE_CTRL_TRUE); } status = acpi_db_command_dispatch(command_line, walk_state, op); return (status); case CMD_INFORMATION: acpi_db_display_method_info(op); break; case CMD_INTEGRITY: acpi_db_check_integrity(); break; case CMD_INTO: if (op) { acpi_gbl_cm_single_step = TRUE; return (AE_OK); } break; case CMD_LEVEL: if (param_count == 0) { acpi_os_printf ("Current debug level for file output is: %8.8lX\n", acpi_gbl_db_debug_level); acpi_os_printf ("Current debug level for console output is: %8.8lX\n", acpi_gbl_db_console_debug_level); } else if (param_count == 2) { temp = acpi_gbl_db_console_debug_level; acpi_gbl_db_console_debug_level = strtoul(acpi_gbl_db_args[1], NULL, 16); acpi_os_printf ("Debug Level for console output was %8.8lX, now %8.8lX\n", temp, acpi_gbl_db_console_debug_level); } else { temp = acpi_gbl_db_debug_level; acpi_gbl_db_debug_level = strtoul(acpi_gbl_db_args[1], NULL, 16); acpi_os_printf ("Debug Level for file output was %8.8lX, now %8.8lX\n", temp, acpi_gbl_db_debug_level); } break; case CMD_LIST: acpi_db_disassemble_aml(acpi_gbl_db_args[1], op); break; case CMD_LOCKS: acpi_db_display_locks(); break; case CMD_LOCALS: acpi_db_display_locals(); break; case CMD_METHODS: status = acpi_db_display_objects("METHOD", acpi_gbl_db_args[1]); break; case CMD_NAMESPACE: acpi_db_dump_namespace(acpi_gbl_db_args[1], acpi_gbl_db_args[2]); break; case CMD_NOTIFY: temp = strtoul(acpi_gbl_db_args[2], NULL, 0); acpi_db_send_notify(acpi_gbl_db_args[1], temp); break; case CMD_OBJECTS: acpi_ut_strupr(acpi_gbl_db_args[1]); status = acpi_db_display_objects(acpi_gbl_db_args[1], acpi_gbl_db_args[2]); break; case CMD_OSI: acpi_db_display_interfaces(acpi_gbl_db_args[1], acpi_gbl_db_args[2]); break; case CMD_OWNER: acpi_db_dump_namespace_by_owner(acpi_gbl_db_args[1], acpi_gbl_db_args[2]); break; case CMD_PATHS: acpi_db_dump_namespace_paths(); break; case CMD_PREFIX: acpi_db_set_scope(acpi_gbl_db_args[1]); break; case CMD_REFERENCES: acpi_db_find_references(acpi_gbl_db_args[1]); break; case CMD_RESOURCES: acpi_db_display_resources(acpi_gbl_db_args[1]); break; case CMD_RESULTS: acpi_db_display_results(); break; case CMD_SET: acpi_db_set_method_data(acpi_gbl_db_args[1], acpi_gbl_db_args[2], acpi_gbl_db_args[3]); break; case CMD_STATS: status = acpi_db_display_statistics(acpi_gbl_db_args[1]); break; case CMD_STOP: return (AE_NOT_IMPLEMENTED); case CMD_TABLES: acpi_db_display_table_info(acpi_gbl_db_args[1]); break; case CMD_TEMPLATE: acpi_db_display_template(acpi_gbl_db_args[1]); break; case CMD_TRACE: acpi_db_trace(acpi_gbl_db_args[1], acpi_gbl_db_args[2], acpi_gbl_db_args[3]); break; case CMD_TREE: acpi_db_display_calling_tree(); break; case CMD_TYPE: acpi_db_display_object_type(acpi_gbl_db_args[1]); break; #ifdef ACPI_APPLICATION /* Hardware simulation commands. */ case CMD_ENABLEACPI: #if (!ACPI_REDUCED_HARDWARE) status = acpi_enable(); if (ACPI_FAILURE(status)) { acpi_os_printf("AcpiEnable failed (Status=%X)\n", status); return (status); } #endif /* !ACPI_REDUCED_HARDWARE */ break; case CMD_EVENT: acpi_os_printf("Event command not implemented\n"); break; case CMD_GPE: acpi_db_generate_gpe(acpi_gbl_db_args[1], acpi_gbl_db_args[2]); break; case CMD_GPES: acpi_db_display_gpes(); break; case CMD_SCI: acpi_db_generate_sci(); break; case CMD_SLEEP: status = acpi_db_sleep(acpi_gbl_db_args[1]); break; /* File I/O commands. */ case CMD_CLOSE: acpi_db_close_debug_file(); break; case CMD_LOAD:{ struct acpi_new_table_desc *list_head = NULL; status = ac_get_all_tables_from_file(acpi_gbl_db_args[1], ACPI_GET_ALL_TABLES, &list_head); if (ACPI_SUCCESS(status)) { acpi_db_load_tables(list_head); } } break; case CMD_OPEN: acpi_db_open_debug_file(acpi_gbl_db_args[1]); break; /* User space commands. */ case CMD_TERMINATE: acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT); acpi_ut_subsystem_shutdown(); /* * TBD: [Restructure] Need some way to re-initialize without * re-creating the semaphores! */ acpi_gbl_db_terminate_loop = TRUE; /* acpi_initialize (NULL); */ break; case CMD_THREADS: acpi_db_create_execution_threads(acpi_gbl_db_args[1], acpi_gbl_db_args[2], acpi_gbl_db_args[3]); break; /* Debug test commands. */ case CMD_PREDEFINED: acpi_db_check_predefined_names(); break; case CMD_TEST: acpi_db_execute_test(acpi_gbl_db_args[1]); break; case CMD_UNLOAD: acpi_db_unload_acpi_table(acpi_gbl_db_args[1]); break; #endif case CMD_EXIT: case CMD_QUIT: if (op) { acpi_os_printf("Method execution terminated\n"); return (AE_CTRL_TERMINATE); } if (!acpi_gbl_db_output_to_file) { acpi_dbg_level = ACPI_DEBUG_DEFAULT; } #ifdef ACPI_APPLICATION acpi_db_close_debug_file(); #endif acpi_gbl_db_terminate_loop = TRUE; return (AE_CTRL_TERMINATE); case CMD_NOT_FOUND: default: acpi_os_printf("%s: unknown command\n", acpi_gbl_db_args[0]); return (AE_CTRL_TRUE); } if (ACPI_SUCCESS(status)) { status = AE_CTRL_TRUE; } return (status); }