void acpi_db_trace(char *enable_arg, char *method_arg, char *once_arg) { u32 debug_level = 0; u32 debug_layer = 0; u32 flags = 0; if (enable_arg) { acpi_ut_strupr(enable_arg); } if (once_arg) { acpi_ut_strupr(once_arg); } if (method_arg) { if (acpi_db_trace_method_name) { ACPI_FREE(acpi_db_trace_method_name); acpi_db_trace_method_name = NULL; } acpi_db_trace_method_name = ACPI_ALLOCATE(strlen(method_arg) + 1); if (!acpi_db_trace_method_name) { acpi_os_printf("Failed to allocate method name (%s)\n", method_arg); return; } strcpy(acpi_db_trace_method_name, method_arg); } if (!strcmp(enable_arg, "ENABLE") || !strcmp(enable_arg, "METHOD") || !strcmp(enable_arg, "OPCODE")) { if (!strcmp(enable_arg, "ENABLE")) { /* Inherit current console settings */ debug_level = acpi_gbl_db_console_debug_level; debug_layer = acpi_dbg_layer; } else { /* Restrict console output to trace points only */ debug_level = ACPI_LV_TRACE_POINT; debug_layer = ACPI_EXECUTER; } flags = ACPI_TRACE_ENABLED; if (!strcmp(enable_arg, "OPCODE")) { flags |= ACPI_TRACE_OPCODE; } if (once_arg && !strcmp(once_arg, "ONCE")) { flags |= ACPI_TRACE_ONESHOT; } } (void)acpi_debug_trace(acpi_db_trace_method_name, debug_level, debug_layer, flags); }
acpi_status acpi_db_find_name_in_namespace(char *name_arg) { char acpi_name[5] = "____"; char *acpi_name_ptr = acpi_name; if (strlen(name_arg) > ACPI_NAME_SIZE) { acpi_os_printf("Name must be no longer than 4 characters\n"); return (AE_OK); } /* Pad out name with underscores as necessary to create a 4-char name */ acpi_ut_strupr(name_arg); while (*name_arg) { *acpi_name_ptr = *name_arg; acpi_name_ptr++; name_arg++; } /* Walk the namespace from the root */ (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_walk_and_match_name, NULL, acpi_name, NULL); acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT); return (AE_OK); }
void acpi_db_execute_test(char *type_arg) { u32 temp; acpi_ut_strupr(type_arg); temp = acpi_db_match_argument(type_arg, acpi_db_test_types); if (temp == ACPI_TYPE_NOT_FOUND) { acpi_os_printf("Invalid or unsupported argument\n"); return; } switch (temp) { case CMD_TEST_OBJECTS: acpi_db_test_all_objects(); break; case CMD_TEST_PREDEFINED: acpi_db_evaluate_all_predefined_names(NULL); break; default: break; } }
void acpi_db_prep_namestring(char *name) { if (!name) { return; } acpi_ut_strupr(name); /* Convert a leading forward slash to a backslash */ if (*name == '/') { *name = '\\'; } /* Ignore a leading backslash, this is the root prefix */ if (ACPI_IS_ROOT_PREFIX(*name)) { name++; } /* Convert all slash path separators to dots */ while (*name) { if ((*name == '/') || (*name == '\\')) { *name = '.'; } name++; } }
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); }
acpi_status acpi_db_display_statistics(char *type_arg) { u32 i; u32 temp; acpi_ut_strupr(type_arg); temp = acpi_db_match_argument(type_arg, acpi_db_stat_types); if (temp == ACPI_TYPE_NOT_FOUND) { acpi_os_printf("Invalid or unsupported argument\n"); return (AE_OK); } switch (temp) { case CMD_STAT_ALLOCATIONS: #ifdef ACPI_DBG_TRACK_ALLOCATIONS acpi_ut_dump_allocation_info(); #endif break; case CMD_STAT_TABLES: acpi_os_printf("ACPI Table Information (not implemented):\n\n"); break; case CMD_STAT_OBJECTS: acpi_db_count_namespace_objects(); acpi_os_printf ("\nObjects defined in the current namespace:\n\n"); acpi_os_printf("%16.16s %10.10s %10.10s\n", "ACPI_TYPE", "NODES", "OBJECTS"); for (i = 0; i < ACPI_TYPE_NS_NODE_MAX; i++) { acpi_os_printf("%16.16s % 10ld% 10ld\n", acpi_ut_get_type_name(i), acpi_gbl_node_type_count[i], acpi_gbl_obj_type_count[i]); } acpi_os_printf("%16.16s % 10ld% 10ld\n", "Misc/Unknown", acpi_gbl_node_type_count_misc, acpi_gbl_obj_type_count_misc); acpi_os_printf("%16.16s % 10ld% 10ld\n", "TOTALS:", acpi_gbl_num_nodes, acpi_gbl_num_objects); break; case CMD_STAT_MEMORY: #ifdef ACPI_DBG_TRACK_ALLOCATIONS acpi_os_printf ("\n----Object Statistics (all in hex)---------\n"); acpi_db_list_info(acpi_gbl_global_list); acpi_db_list_info(acpi_gbl_ns_node_list); #endif #ifdef ACPI_USE_LOCAL_CACHE acpi_os_printf ("\n----Cache Statistics (all in hex)---------\n"); acpi_db_list_info(acpi_gbl_operand_cache); acpi_db_list_info(acpi_gbl_ps_node_cache); acpi_db_list_info(acpi_gbl_ps_node_ext_cache); acpi_db_list_info(acpi_gbl_state_cache); #endif break; case CMD_STAT_MISC: acpi_os_printf("\nMiscellaneous Statistics:\n\n"); acpi_os_printf("Calls to AcpiPsFind:.. ........% 7ld\n", acpi_gbl_ps_find_count); acpi_os_printf("Calls to AcpiNsLookup:..........% 7ld\n", acpi_gbl_ns_lookup_count); acpi_os_printf("\n"); acpi_os_printf("Mutex usage:\n\n"); for (i = 0; i < ACPI_NUM_MUTEX; i++) { acpi_os_printf("%-28s: % 7ld\n", acpi_ut_get_mutex_name(i), acpi_gbl_mutex_info[i].use_count); } break; case CMD_STAT_SIZES: acpi_os_printf("\nInternal object sizes:\n\n"); acpi_os_printf("Common %3d\n", sizeof(struct acpi_object_common)); acpi_os_printf("Number %3d\n", sizeof(struct acpi_object_integer)); acpi_os_printf("String %3d\n", sizeof(struct acpi_object_string)); acpi_os_printf("Buffer %3d\n", sizeof(struct acpi_object_buffer)); acpi_os_printf("Package %3d\n", sizeof(struct acpi_object_package)); acpi_os_printf("BufferField %3d\n", sizeof(struct acpi_object_buffer_field)); acpi_os_printf("Device %3d\n", sizeof(struct acpi_object_device)); acpi_os_printf("Event %3d\n", sizeof(struct acpi_object_event)); acpi_os_printf("Method %3d\n", sizeof(struct acpi_object_method)); acpi_os_printf("Mutex %3d\n", sizeof(struct acpi_object_mutex)); acpi_os_printf("Region %3d\n", sizeof(struct acpi_object_region)); acpi_os_printf("PowerResource %3d\n", sizeof(struct acpi_object_power_resource)); acpi_os_printf("Processor %3d\n", sizeof(struct acpi_object_processor)); acpi_os_printf("ThermalZone %3d\n", sizeof(struct acpi_object_thermal_zone)); acpi_os_printf("RegionField %3d\n", sizeof(struct acpi_object_region_field)); acpi_os_printf("BankField %3d\n", sizeof(struct acpi_object_bank_field)); acpi_os_printf("IndexField %3d\n", sizeof(struct acpi_object_index_field)); acpi_os_printf("Reference %3d\n", sizeof(struct acpi_object_reference)); acpi_os_printf("Notify %3d\n", sizeof(struct acpi_object_notify_handler)); acpi_os_printf("AddressSpace %3d\n", sizeof(struct acpi_object_addr_handler)); acpi_os_printf("Extra %3d\n", sizeof(struct acpi_object_extra)); acpi_os_printf("Data %3d\n", sizeof(struct acpi_object_data)); acpi_os_printf("\n"); acpi_os_printf("ParseObject %3d\n", sizeof(struct acpi_parse_obj_common)); acpi_os_printf("ParseObjectNamed %3d\n", sizeof(struct acpi_parse_obj_named)); acpi_os_printf("ParseObjectAsl %3d\n", sizeof(struct acpi_parse_obj_asl)); acpi_os_printf("OperandObject %3d\n", sizeof(union acpi_operand_object)); acpi_os_printf("NamespaceNode %3d\n", sizeof(struct acpi_namespace_node)); acpi_os_printf("AcpiObject %3d\n", sizeof(union acpi_object)); acpi_os_printf("\n"); acpi_os_printf("Generic State %3d\n", sizeof(union acpi_generic_state)); acpi_os_printf("Common State %3d\n", sizeof(struct acpi_common_state)); acpi_os_printf("Control State %3d\n", sizeof(struct acpi_control_state)); acpi_os_printf("Update State %3d\n", sizeof(struct acpi_update_state)); acpi_os_printf("Scope State %3d\n", sizeof(struct acpi_scope_state)); acpi_os_printf("Parse Scope %3d\n", sizeof(struct acpi_pscope_state)); acpi_os_printf("Package State %3d\n", sizeof(struct acpi_pkg_state)); acpi_os_printf("Thread State %3d\n", sizeof(struct acpi_thread_state)); acpi_os_printf("Result Values %3d\n", sizeof(struct acpi_result_values)); acpi_os_printf("Notify Info %3d\n", sizeof(struct acpi_notify_info)); break; case CMD_STAT_STACK: #if defined(ACPI_DEBUG_OUTPUT) temp = (u32)ACPI_PTR_DIFF(acpi_gbl_entry_stack_pointer, acpi_gbl_lowest_stack_pointer); acpi_os_printf("\nSubsystem Stack Usage:\n\n"); acpi_os_printf("Entry Stack Pointer %p\n", acpi_gbl_entry_stack_pointer); acpi_os_printf("Lowest Stack Pointer %p\n", acpi_gbl_lowest_stack_pointer); acpi_os_printf("Stack Use %X (%u)\n", temp, temp); acpi_os_printf("Deepest Procedure Nesting %u\n", acpi_gbl_deepest_nesting); #endif break; default: break; } acpi_os_printf("\n"); return (AE_OK); }
void acpi_db_display_interfaces(char *action_arg, char *interface_name_arg) { struct acpi_interface_info *next_interface; char *sub_string; acpi_status status; /* If no arguments, just display current interface list */ if (!action_arg) { (void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); next_interface = acpi_gbl_supported_interfaces; while (next_interface) { if (!(next_interface->flags & ACPI_OSI_INVALID)) { acpi_os_printf("%s\n", next_interface->name); } next_interface = next_interface->next; } acpi_os_release_mutex(acpi_gbl_osi_mutex); return; } /* If action_arg exists, so must interface_name_arg */ if (!interface_name_arg) { acpi_os_printf("Missing Interface Name argument\n"); return; } /* Uppercase the action for match below */ acpi_ut_strupr(action_arg); /* install - install an interface */ sub_string = strstr("INSTALL", action_arg); if (sub_string) { status = acpi_install_interface(interface_name_arg); if (ACPI_FAILURE(status)) { acpi_os_printf("%s, while installing \"%s\"\n", acpi_format_exception(status), interface_name_arg); } return; } /* remove - remove an interface */ sub_string = strstr("REMOVE", action_arg); if (sub_string) { status = acpi_remove_interface(interface_name_arg); if (ACPI_FAILURE(status)) { acpi_os_printf("%s, while removing \"%s\"\n", acpi_format_exception(status), interface_name_arg); } return; } /* Invalid action_arg */ acpi_os_printf("Invalid action argument: %s\n", action_arg); return; }
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) 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):\n", 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; } 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); } }
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); }