/******************************************************************************* * * Module Name: dbinput - user front-end to the AML debugger * ******************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * *****************************************************************************/ #include #include #include #ifdef ACPI_DEBUGGER #define _COMPONENT ACPI_CA_DEBUGGER ACPI_MODULE_NAME ("dbinput") /* Local prototypes */ static char * AcpiDbGetNextToken ( char *String, char **Next); static UINT32 AcpiDbGetLine ( char *InputBuffer); static UINT32 AcpiDbMatchCommand ( char *UserCommand); static void AcpiDbSingleThread ( void); static void AcpiDbDisplayHelp ( char *HelpType); /* * Top-level debugger commands. * * This list of commands must match the string table below it */ enum AcpiExDebuggerCommands { CMD_NOT_FOUND = 0, CMD_NULL, CMD_ALLOCATIONS, CMD_ARGS, CMD_ARGUMENTS, CMD_BATCH, CMD_BREAKPOINT, CMD_BUSINFO, CMD_CALL, CMD_CLOSE, CMD_DEBUG, CMD_DISASSEMBLE, CMD_DUMP, CMD_ENABLEACPI, CMD_EVENT, CMD_EXECUTE, CMD_EXIT, CMD_FIND, CMD_GO, CMD_GPE, CMD_GPES, CMD_HELP, CMD_HELP2, CMD_HISTORY, CMD_HISTORY_EXE, CMD_HISTORY_LAST, CMD_INFORMATION, CMD_INTEGRITY, CMD_INTO, CMD_LEVEL, CMD_LIST, CMD_LOAD, CMD_LOCALS, CMD_LOCKS, CMD_METHODS, CMD_NAMESPACE, CMD_NOTIFY, CMD_OBJECT, CMD_OPEN, CMD_OWNER, CMD_PREDEFINED, CMD_PREFIX, CMD_QUIT, CMD_REFERENCES, CMD_RESOURCES, CMD_RESULTS, CMD_SET, CMD_SLEEP, CMD_STATS, CMD_STOP, CMD_TABLES, CMD_TERMINATE, CMD_THREADS, CMD_TRACE, CMD_TREE, CMD_TYPE, CMD_UNLOAD }; #define CMD_FIRST_VALID 2 /* Second parameter is the required argument count */ static const COMMAND_INFO AcpiGbl_DbCommands[] = { {"", 0}, {"", 0}, {"ALLOCATIONS", 0}, {"ARGS", 0}, {"ARGUMENTS", 0}, {"BATCH", 0}, {"BREAKPOINT", 1}, {"BUSINFO", 0}, {"CALL", 0}, {"CLOSE", 0}, {"DEBUG", 1}, {"DISASSEMBLE", 1}, {"DUMP", 1}, {"ENABLEACPI", 0}, {"EVENT", 1}, {"EXECUTE", 1}, {"EXIT", 0}, {"FIND", 1}, {"GO", 0}, {"GPE", 2}, {"GPES", 0}, {"HELP", 0}, {"?", 0}, {"HISTORY", 0}, {"!", 1}, {"!!", 0}, {"INFORMATION", 0}, {"INTEGRITY", 0}, {"INTO", 0}, {"LEVEL", 0}, {"LIST", 0}, {"LOAD", 1}, {"LOCALS", 0}, {"LOCKS", 0}, {"METHODS", 0}, {"NAMESPACE", 0}, {"NOTIFY", 2}, {"OBJECT", 1}, {"OPEN", 1}, {"OWNER", 1}, {"PREDEFINED", 0}, {"PREFIX", 0}, {"QUIT", 0}, {"REFERENCES", 1}, {"RESOURCES", 1}, {"RESULTS", 0}, {"SET", 3}, {"SLEEP", 1}, {"STATS", 0}, {"STOP", 0}, {"TABLES", 0}, {"TERMINATE", 0}, {"THREADS", 3}, {"TRACE", 1}, {"TREE", 0}, {"TYPE", 1}, {"UNLOAD", 1}, {NULL, 0} }; /******************************************************************************* * * FUNCTION: AcpiDbDisplayHelp * * PARAMETERS: HelpType - Subcommand (optional) * * RETURN: None * * DESCRIPTION: Print a usage message. * ******************************************************************************/ static void AcpiDbDisplayHelp ( char *HelpType) { AcpiUtStrupr (HelpType); /* No parameter, just give the overview */ if (!HelpType) { AcpiOsPrintf ("ACPI CA Debugger Commands\n\n"); AcpiOsPrintf ("The following classes of commands are available. Help is available for\n"); AcpiOsPrintf ("each class by entering \"Help \"\n\n"); AcpiOsPrintf (" [GENERAL] General-Purpose Commands\n"); AcpiOsPrintf (" [NAMESPACE] Namespace Access Commands\n"); AcpiOsPrintf (" [METHOD] Control Method Execution Commands\n"); AcpiOsPrintf (" [STATISTICS] Statistical Information\n"); AcpiOsPrintf (" [FILE] File I/O Commands\n"); return; } /* * Parameter is the command class * * The idea here is to keep each class of commands smaller than a screenful */ switch (HelpType[0]) { case 'G': AcpiOsPrintf ("\nGeneral-Purpose Commands\n\n"); AcpiOsPrintf ("Allocations Display list of current memory allocations\n"); AcpiOsPrintf ("Dump
|\n"); AcpiOsPrintf (" [Byte|Word|Dword|Qword] Display ACPI objects or memory\n"); AcpiOsPrintf ("EnableAcpi Enable ACPI (hardware) mode\n"); AcpiOsPrintf ("Help This help screen\n"); AcpiOsPrintf ("History Display command history buffer\n"); AcpiOsPrintf ("Level [] [console] Get/Set debug level for file or console\n"); AcpiOsPrintf ("Locks Current status of internal mutexes\n"); AcpiOsPrintf ("Quit or Exit Exit this command\n"); AcpiOsPrintf ("Stats [Allocations|Memory|Misc\n"); AcpiOsPrintf (" |Objects|Sizes|Stack|Tables] Display namespace and memory statistics\n"); AcpiOsPrintf ("Tables Display info about loaded ACPI tables\n"); AcpiOsPrintf ("Unload [Instance] Unload an ACPI table\n"); AcpiOsPrintf ("! Execute command from history buffer\n"); AcpiOsPrintf ("!! Execute last command again\n"); return; case 'S': AcpiOsPrintf ("\nStats Subcommands\n\n"); AcpiOsPrintf ("Allocations Display list of current memory allocations\n"); AcpiOsPrintf ("Memory Dump internal memory lists\n"); AcpiOsPrintf ("Misc Namespace search and mutex stats\n"); AcpiOsPrintf ("Objects Summary of namespace objects\n"); AcpiOsPrintf ("Sizes Sizes for each of the internal objects\n"); AcpiOsPrintf ("Stack Display CPU stack usage\n"); AcpiOsPrintf ("Tables Info about current ACPI table(s)\n"); return; case 'N': AcpiOsPrintf ("\nNamespace Access Commands\n\n"); AcpiOsPrintf ("Businfo Display system bus info\n"); AcpiOsPrintf ("Disassemble Disassemble a control method\n"); AcpiOsPrintf ("Event Generate AcpiEvent (Fixed/GPE)\n"); AcpiOsPrintf ("Find (? is wildcard) Find ACPI name(s) with wildcards\n"); AcpiOsPrintf ("Gpe Simulate a GPE\n"); AcpiOsPrintf ("Gpes Display info on all GPEs\n"); AcpiOsPrintf ("Integrity Validate namespace integrity\n"); AcpiOsPrintf ("Methods Display list of loaded control methods\n"); AcpiOsPrintf ("Namespace [Object] [Depth] Display loaded namespace tree/subtree\n"); AcpiOsPrintf ("Notify Send a notification on Object\n"); AcpiOsPrintf ("Objects Display all objects of the given type\n"); AcpiOsPrintf ("Owner [Depth] Display loaded namespace by object owner\n"); AcpiOsPrintf ("Predefined Check all predefined names\n"); AcpiOsPrintf ("Prefix [] Set or Get current execution prefix\n"); AcpiOsPrintf ("References Find all references to object at addr\n"); AcpiOsPrintf ("Resources Get and display Device resources\n"); AcpiOsPrintf ("Set N Set value for named integer\n"); AcpiOsPrintf ("Sleep Simulate sleep/wake sequence\n"); AcpiOsPrintf ("Terminate Delete namespace and all internal objects\n"); AcpiOsPrintf ("Type Display object type\n"); return; case 'M': AcpiOsPrintf ("\nControl Method Execution Commands\n\n"); AcpiOsPrintf ("Arguments (or Args) Display method arguments\n"); AcpiOsPrintf ("Breakpoint Set an AML execution breakpoint\n"); AcpiOsPrintf ("Call Run to next control method invocation\n"); AcpiOsPrintf ("Debug [Arguments] Single Step a control method\n"); AcpiOsPrintf ("Execute [Arguments] Execute control method\n"); AcpiOsPrintf ("Go Allow method to run to completion\n"); AcpiOsPrintf ("Information Display info about the current method\n"); AcpiOsPrintf ("Into Step into (not over) a method call\n"); AcpiOsPrintf ("List [# of Aml Opcodes] Display method ASL statements\n"); AcpiOsPrintf ("Locals Display method local variables\n"); AcpiOsPrintf ("Results Display method result stack\n"); AcpiOsPrintf ("Set <#> Set method data (Arguments/Locals)\n"); AcpiOsPrintf ("Stop Terminate control method\n"); AcpiOsPrintf ("Thread Spawn threads to execute method(s)\n"); AcpiOsPrintf ("Trace Trace method execution\n"); AcpiOsPrintf ("Tree Display control method calling tree\n"); AcpiOsPrintf (" Single step next AML opcode (over calls)\n"); return; case 'F': AcpiOsPrintf ("\nFile I/O Commands\n\n"); AcpiOsPrintf ("Close Close debug output file\n"); AcpiOsPrintf ("Open Open a file for debug output\n"); AcpiOsPrintf ("Load Load ACPI table from a file\n"); return; default: AcpiOsPrintf ("Unrecognized Command Class: %s\n", HelpType); return; } } /******************************************************************************* * * FUNCTION: AcpiDbGetNextToken * * PARAMETERS: String - Command buffer * Next - Return value, end of next token * * RETURN: Pointer to the start of the next token. * * DESCRIPTION: Command line parsing. Get the next token on the command line * ******************************************************************************/ static char * AcpiDbGetNextToken ( char *String, char **Next) { char *Start; /* At end of buffer? */ if (!String || !(*String)) { return (NULL); } /* Get rid of any spaces at the beginning */ if (*String == ' ') { while (*String && (*String == ' ')) { String++; } if (!(*String)) { return (NULL); } } Start = String; /* Find end of token */ while (*String && (*String != ' ')) { String++; } if (!(*String)) { *Next = NULL; } else { *String = 0; *Next = String + 1; } return (Start); } /******************************************************************************* * * FUNCTION: AcpiDbGetLine * * PARAMETERS: InputBuffer - Command line buffer * * RETURN: Count of arguments to the command * * DESCRIPTION: Get the next command line from the user. Gets entire line * up to the next newline * ******************************************************************************/ static UINT32 AcpiDbGetLine ( char *InputBuffer) { UINT32 i; UINT32 Count; char *Next; char *This; ACPI_STRCPY (AcpiGbl_DbParsedBuf, InputBuffer); This = AcpiGbl_DbParsedBuf; for (i = 0; i < ACPI_DEBUGGER_MAX_ARGS; i++) { AcpiGbl_DbArgs[i] = AcpiDbGetNextToken (This, &Next); if (!AcpiGbl_DbArgs[i]) { break; } This = Next; } /* Uppercase the actual command */ if (AcpiGbl_DbArgs[0]) { AcpiUtStrupr (AcpiGbl_DbArgs[0]); } Count = i; if (Count) { Count--; /* Number of args only */ } return (Count); } /******************************************************************************* * * FUNCTION: AcpiDbMatchCommand * * PARAMETERS: UserCommand - User command line * * RETURN: Index into command array, -1 if not found * * DESCRIPTION: Search command array for a command match * ******************************************************************************/ static UINT32 AcpiDbMatchCommand ( char *UserCommand) { UINT32 i; if (!UserCommand || UserCommand[0] == 0) { return (CMD_NULL); } for (i = CMD_FIRST_VALID; AcpiGbl_DbCommands[i].Name; i++) { if (ACPI_STRSTR (AcpiGbl_DbCommands[i].Name, UserCommand) == AcpiGbl_DbCommands[i].Name) { return (i); } } /* Command not recognized */ return (CMD_NOT_FOUND); } /******************************************************************************* * * FUNCTION: AcpiDbCommandDispatch * * PARAMETERS: InputBuffer - Command line buffer * WalkState - Current walk * Op - Current (executing) parse op * * RETURN: Status * * DESCRIPTION: Command dispatcher. * ******************************************************************************/ ACPI_STATUS AcpiDbCommandDispatch ( char *InputBuffer, ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) { UINT32 Temp; UINT32 CommandIndex; UINT32 ParamCount; char *CommandLine; ACPI_STATUS Status = AE_CTRL_TRUE; /* If AcpiTerminate has been called, terminate this thread */ if (AcpiGbl_DbTerminateThreads) { return (AE_CTRL_TERMINATE); } ParamCount = AcpiDbGetLine (InputBuffer); CommandIndex = AcpiDbMatchCommand (AcpiGbl_DbArgs[0]); Temp = 0; /* Verify that we have the minimum number of params */ if (ParamCount < AcpiGbl_DbCommands[CommandIndex].MinArgs) { AcpiOsPrintf ("%d parameters entered, [%s] requires %d parameters\n", ParamCount, AcpiGbl_DbCommands[CommandIndex].Name, AcpiGbl_DbCommands[CommandIndex].MinArgs); return (AE_CTRL_TRUE); } /* Decode and dispatch the command */ switch (CommandIndex) { case CMD_NULL: if (Op) { return (AE_OK); } break; case CMD_ALLOCATIONS: #ifdef ACPI_DBG_TRACK_ALLOCATIONS AcpiUtDumpAllocations ((UINT32) -1, NULL); #endif break; case CMD_ARGS: case CMD_ARGUMENTS: AcpiDbDisplayArguments (); break; case CMD_BATCH: AcpiDbBatchExecute (AcpiGbl_DbArgs[1]); break; case CMD_BREAKPOINT: AcpiDbSetMethodBreakpoint (AcpiGbl_DbArgs[1], WalkState, Op); break; case CMD_BUSINFO: AcpiDbGetBusInfo (); break; case CMD_CALL: AcpiDbSetMethodCallBreakpoint (Op); Status = AE_OK; break; case CMD_CLOSE: AcpiDbCloseDebugFile (); break; case CMD_DEBUG: AcpiDbExecute (AcpiGbl_DbArgs[1], &AcpiGbl_DbArgs[2], EX_SINGLE_STEP); break; case CMD_DISASSEMBLE: (void) AcpiDbDisassembleMethod (AcpiGbl_DbArgs[1]); break; case CMD_DUMP: AcpiDbDecodeAndDisplayObject (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]); break; case CMD_ENABLEACPI: Status = AcpiEnable(); if (ACPI_FAILURE(Status)) { AcpiOsPrintf("AcpiEnable failed (Status=%X)\n", Status); return (Status); } break; case CMD_EVENT: AcpiOsPrintf ("Event command not implemented\n"); break; case CMD_EXECUTE: AcpiDbExecute (AcpiGbl_DbArgs[1], &AcpiGbl_DbArgs[2], EX_NO_SINGLE_STEP); break; case CMD_FIND: Status = AcpiDbFindNameInNamespace (AcpiGbl_DbArgs[1]); break; case CMD_GO: AcpiGbl_CmSingleStep = FALSE; return (AE_OK); case CMD_GPE: AcpiDbGenerateGpe (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]); break; case CMD_GPES: AcpiDbDisplayGpes (); break; case CMD_HELP: case CMD_HELP2: AcpiDbDisplayHelp (AcpiGbl_DbArgs[1]); break; case CMD_HISTORY: AcpiDbDisplayHistory (); break; case CMD_HISTORY_EXE: CommandLine = AcpiDbGetFromHistory (AcpiGbl_DbArgs[1]); if (!CommandLine) { return (AE_CTRL_TRUE); } Status = AcpiDbCommandDispatch (CommandLine, WalkState, Op); return (Status); case CMD_HISTORY_LAST: CommandLine = AcpiDbGetFromHistory (NULL); if (!CommandLine) { return (AE_CTRL_TRUE); } Status = AcpiDbCommandDispatch (CommandLine, WalkState, Op); return (Status); case CMD_INFORMATION: AcpiDbDisplayMethodInfo (Op); break; case CMD_INTEGRITY: AcpiDbCheckIntegrity (); break; case CMD_INTO: if (Op) { AcpiGbl_CmSingleStep = TRUE; return (AE_OK); } break; case CMD_LEVEL: if (ParamCount == 0) { AcpiOsPrintf ("Current debug level for file output is: %8.8lX\n", AcpiGbl_DbDebugLevel); AcpiOsPrintf ("Current debug level for console output is: %8.8lX\n", AcpiGbl_DbConsoleDebugLevel); } else if (ParamCount == 2) { Temp = AcpiGbl_DbConsoleDebugLevel; AcpiGbl_DbConsoleDebugLevel = ACPI_STRTOUL (AcpiGbl_DbArgs[1], NULL, 16); AcpiOsPrintf ( "Debug Level for console output was %8.8lX, now %8.8lX\n", Temp, AcpiGbl_DbConsoleDebugLevel); } else { Temp = AcpiGbl_DbDebugLevel; AcpiGbl_DbDebugLevel = ACPI_STRTOUL (AcpiGbl_DbArgs[1], NULL, 16); AcpiOsPrintf ( "Debug Level for file output was %8.8lX, now %8.8lX\n", Temp, AcpiGbl_DbDebugLevel); } break; case CMD_LIST: AcpiDbDisassembleAml (AcpiGbl_DbArgs[1], Op); break; case CMD_LOAD: Status = AcpiDbGetTableFromFile (AcpiGbl_DbArgs[1], NULL); break; case CMD_LOCKS: AcpiDbDisplayLocks (); break; case CMD_LOCALS: AcpiDbDisplayLocals (); break; case CMD_METHODS: Status = AcpiDbDisplayObjects ("METHOD", AcpiGbl_DbArgs[1]); break; case CMD_NAMESPACE: AcpiDbDumpNamespace (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]); break; case CMD_NOTIFY: Temp = ACPI_STRTOUL (AcpiGbl_DbArgs[2], NULL, 0); AcpiDbSendNotify (AcpiGbl_DbArgs[1], Temp); break; case CMD_OBJECT: AcpiUtStrupr (AcpiGbl_DbArgs[1]); Status = AcpiDbDisplayObjects (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]); break; case CMD_OPEN: AcpiDbOpenDebugFile (AcpiGbl_DbArgs[1]); break; case CMD_OWNER: AcpiDbDumpNamespaceByOwner (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]); break; case CMD_PREDEFINED: AcpiDbCheckPredefinedNames (); break; case CMD_PREFIX: AcpiDbSetScope (AcpiGbl_DbArgs[1]); break; case CMD_REFERENCES: AcpiDbFindReferences (AcpiGbl_DbArgs[1]); break; case CMD_RESOURCES: AcpiDbDisplayResources (AcpiGbl_DbArgs[1]); break; case CMD_RESULTS: AcpiDbDisplayResults (); break; case CMD_SET: AcpiDbSetMethodData (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2], AcpiGbl_DbArgs[3]); break; case CMD_SLEEP: Status = AcpiDbSleep (AcpiGbl_DbArgs[1]); break; case CMD_STATS: Status = AcpiDbDisplayStatistics (AcpiGbl_DbArgs[1]); break; case CMD_STOP: return (AE_NOT_IMPLEMENTED); case CMD_TABLES: AcpiDbDisplayTableInfo (AcpiGbl_DbArgs[1]); break; case CMD_TERMINATE: AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT); AcpiUtSubsystemShutdown (); /* * TBD: [Restructure] Need some way to re-initialize without * re-creating the semaphores! */ /* AcpiInitialize (NULL); */ break; case CMD_THREADS: AcpiDbCreateExecutionThreads (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2], AcpiGbl_DbArgs[3]); break; case CMD_TRACE: (void) AcpiDebugTrace (AcpiGbl_DbArgs[1],0,0,1); break; case CMD_TREE: AcpiDbDisplayCallingTree (); break; case CMD_TYPE: AcpiDbDisplayObjectType (AcpiGbl_DbArgs[1]); break; case CMD_UNLOAD: AcpiDbUnloadAcpiTable (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]); break; case CMD_EXIT: case CMD_QUIT: if (Op) { AcpiOsPrintf ("Method execution terminated\n"); return (AE_CTRL_TERMINATE); } if (!AcpiGbl_DbOutputToFile) { AcpiDbgLevel = ACPI_DEBUG_DEFAULT; } AcpiDbCloseDebugFile (); AcpiGbl_DbTerminateThreads = TRUE; return (AE_CTRL_TERMINATE); case CMD_NOT_FOUND: default: AcpiOsPrintf ("Unknown Command\n"); return (AE_CTRL_TRUE); } if (ACPI_SUCCESS (Status)) { Status = AE_CTRL_TRUE; } /* Add all commands that come here to the history buffer */ AcpiDbAddToHistory (InputBuffer); return (Status); } /******************************************************************************* * * FUNCTION: AcpiDbExecuteThread * * PARAMETERS: Context - Not used * * RETURN: None * * DESCRIPTION: Debugger execute thread. Waits for a command line, then * simply dispatches it. * ******************************************************************************/ void ACPI_SYSTEM_XFACE AcpiDbExecuteThread ( void *Context) { ACPI_STATUS Status = AE_OK; ACPI_STATUS MStatus; while (Status != AE_CTRL_TERMINATE) { AcpiGbl_MethodExecuting = FALSE; AcpiGbl_StepToNextCall = FALSE; MStatus = AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_READY); if (ACPI_FAILURE (MStatus)) { return; } Status = AcpiDbCommandDispatch (AcpiGbl_DbLineBuf, NULL, NULL); MStatus = AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_COMPLETE); if (ACPI_FAILURE (MStatus)) { return; } } } /******************************************************************************* * * FUNCTION: AcpiDbSingleThread * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: Debugger execute thread. Waits for a command line, then * simply dispatches it. * ******************************************************************************/ static void AcpiDbSingleThread ( void) { AcpiGbl_MethodExecuting = FALSE; AcpiGbl_StepToNextCall = FALSE; (void) AcpiDbCommandDispatch (AcpiGbl_DbLineBuf, NULL, NULL); } /******************************************************************************* * * FUNCTION: AcpiDbUserCommands * * PARAMETERS: Prompt - User prompt (depends on mode) * Op - Current executing parse op * * RETURN: None * * DESCRIPTION: Command line execution for the AML debugger. Commands are * matched and dispatched here. * ******************************************************************************/ ACPI_STATUS AcpiDbUserCommands ( char Prompt, ACPI_PARSE_OBJECT *Op) { ACPI_STATUS Status = AE_OK; /* TBD: [Restructure] Need a separate command line buffer for step mode */ while (!AcpiGbl_DbTerminateThreads) { /* Force output to console until a command is entered */ AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT); /* Different prompt if method is executing */ if (!AcpiGbl_MethodExecuting) { AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_COMMAND_PROMPT); } else { AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT); } /* Get the user input line */ (void) AcpiOsGetLine (AcpiGbl_DbLineBuf); /* Check for single or multithreaded debug */ if (AcpiGbl_DebuggerConfiguration & DEBUGGER_MULTI_THREADED) { /* * Signal the debug thread that we have a command to execute, * and wait for the command to complete. */ Status = AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_READY); if (ACPI_FAILURE (Status)) { return (Status); } Status = AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_COMPLETE); if (ACPI_FAILURE (Status)) { return (Status); } } else { /* Just call to the command line interpreter */ AcpiDbSingleThread (); } } /* * Only this thread (the original thread) should actually terminate the * subsystem, because all the semaphores are deleted during termination */ Status = AcpiTerminate (); return (Status); } #endif /* ACPI_DEBUGGER */