1 /*******************************************************************************
2 *
3 * Module Name: dbinput - user front-end to the AML debugger
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2011, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44
45 #include "acpi.h"
46 #include "accommon.h"
47 #include "acdebug.h"
48
49
50 #ifdef ACPI_DEBUGGER
51
52 #define _COMPONENT ACPI_CA_DEBUGGER
53 ACPI_MODULE_NAME ("dbinput")
54
55 /* Local prototypes */
56
57 static UINT32
58 AcpiDbGetLine (
59 char *InputBuffer);
60
61 static UINT32
62 AcpiDbMatchCommand (
63 char *UserCommand);
64
65 static void
66 AcpiDbSingleThread (
67 void);
68
69 static void
70 AcpiDbDisplayHelp (
71 void);
72
73
74 /*
75 * Top-level debugger commands.
76 *
77 * This list of commands must match the string table below it
78 */
79 enum AcpiExDebuggerCommands
80 {
81 CMD_NOT_FOUND = 0,
82 CMD_NULL,
83 CMD_ALLOCATIONS,
84 CMD_ARGS,
85 CMD_ARGUMENTS,
86 CMD_BATCH,
87 CMD_BREAKPOINT,
88 CMD_BUSINFO,
89 CMD_CALL,
90 CMD_CLOSE,
91 CMD_DEBUG,
92 CMD_DISASSEMBLE,
93 CMD_DUMP,
94 CMD_ENABLEACPI,
95 CMD_EVENT,
96 CMD_EXECUTE,
97 CMD_EXIT,
98 CMD_FIND,
99 CMD_GO,
100 CMD_GPE,
101 CMD_GPES,
102 CMD_HANDLERS,
103 CMD_HELP,
104 CMD_HELP2,
105 CMD_HISTORY,
106 CMD_HISTORY_EXE,
107 CMD_HISTORY_LAST,
108 CMD_INFORMATION,
109 CMD_INTEGRITY,
110 CMD_INTO,
111 CMD_LEVEL,
112 CMD_LIST,
113 CMD_LOAD,
114 CMD_LOCALS,
115 CMD_LOCKS,
116 CMD_METHODS,
117 CMD_NAMESPACE,
118 CMD_NOTIFY,
119 CMD_OBJECT,
120 CMD_OPEN,
121 CMD_OSI,
122 CMD_OWNER,
123 CMD_PREDEFINED,
124 CMD_PREFIX,
125 CMD_QUIT,
126 CMD_REFERENCES,
127 CMD_RESOURCES,
128 CMD_RESULTS,
129 CMD_SET,
130 CMD_SLEEP,
131 CMD_STATS,
132 CMD_STOP,
133 CMD_TABLES,
134 CMD_TERMINATE,
135 CMD_THREADS,
136 CMD_TRACE,
137 CMD_TREE,
138 CMD_TYPE,
139 CMD_UNLOAD
140 };
141
142 #define CMD_FIRST_VALID 2
143
144
145 /* Second parameter is the required argument count */
146
147 static const COMMAND_INFO AcpiGbl_DbCommands[] =
148 {
149 {"<NOT FOUND>", 0},
150 {"<NULL>", 0},
151 {"ALLOCATIONS", 0},
152 {"ARGS", 0},
153 {"ARGUMENTS", 0},
154 {"BATCH", 0},
155 {"BREAKPOINT", 1},
156 {"BUSINFO", 0},
157 {"CALL", 0},
158 {"CLOSE", 0},
159 {"DEBUG", 1},
160 {"DISASSEMBLE", 1},
161 {"DUMP", 1},
162 {"ENABLEACPI", 0},
163 {"EVENT", 1},
164 {"EXECUTE", 1},
165 {"EXIT", 0},
166 {"FIND", 1},
167 {"GO", 0},
168 {"GPE", 2},
169 {"GPES", 0},
170 {"HANDLERS", 0},
171 {"HELP", 0},
172 {"?", 0},
173 {"HISTORY", 0},
174 {"!", 1},
175 {"!!", 0},
176 {"INFORMATION", 0},
177 {"INTEGRITY", 0},
178 {"INTO", 0},
179 {"LEVEL", 0},
180 {"LIST", 0},
181 {"LOAD", 1},
182 {"LOCALS", 0},
183 {"LOCKS", 0},
184 {"METHODS", 0},
185 {"NAMESPACE", 0},
186 {"NOTIFY", 2},
187 {"OBJECT", 1},
188 {"OPEN", 1},
189 {"OSI", 0},
190 {"OWNER", 1},
191 {"PREDEFINED", 0},
192 {"PREFIX", 0},
193 {"QUIT", 0},
194 {"REFERENCES", 1},
195 {"RESOURCES", 1},
196 {"RESULTS", 0},
197 {"SET", 3},
198 {"SLEEP", 1},
199 {"STATS", 0},
200 {"STOP", 0},
201 {"TABLES", 0},
202 {"TERMINATE", 0},
203 {"THREADS", 3},
204 {"TRACE", 1},
205 {"TREE", 0},
206 {"TYPE", 1},
207 {"UNLOAD", 1},
208 {NULL, 0}
209 };
210
211
212 /*******************************************************************************
213 *
214 * FUNCTION: AcpiDbDisplayHelp
215 *
216 * PARAMETERS: None
217 *
218 * RETURN: None
219 *
220 * DESCRIPTION: Print a usage message.
221 *
222 ******************************************************************************/
223
224 static void
225 AcpiDbDisplayHelp (
226 void)
227 {
228
229 AcpiOsPrintf ("\nGeneral-Purpose Commands:\n");
230 AcpiOsPrintf (" Allocations Display list of current memory allocations\n");
231 AcpiOsPrintf (" Dump <Address>|<Namepath>\n");
232 AcpiOsPrintf (" [Byte|Word|Dword|Qword] Display ACPI objects or memory\n");
233 AcpiOsPrintf (" EnableAcpi Enable ACPI (hardware) mode\n");
234 AcpiOsPrintf (" Handlers Info about global handlers\n");
235 AcpiOsPrintf (" Help This help screen\n");
236 AcpiOsPrintf (" History Display command history buffer\n");
237 AcpiOsPrintf (" Level [<DebugLevel>] [console] Get/Set debug level for file or console\n");
238 AcpiOsPrintf (" Locks Current status of internal mutexes\n");
239 AcpiOsPrintf (" Osi [Install|Remove <name>] Display or modify global _OSI list\n");
240 AcpiOsPrintf (" Quit or Exit Exit this command\n");
241 AcpiOsPrintf (" Stats [Allocations|Memory|Misc|\n");
242 AcpiOsPrintf (" Objects|Sizes|Stack|Tables] Display namespace and memory statistics\n");
243 AcpiOsPrintf (" Allocations Display list of current memory allocations\n");
244 AcpiOsPrintf (" Memory Dump internal memory lists\n");
245 AcpiOsPrintf (" Misc Namespace search and mutex stats\n");
246 AcpiOsPrintf (" Objects Summary of namespace objects\n");
247 AcpiOsPrintf (" Sizes Sizes for each of the internal objects\n");
248 AcpiOsPrintf (" Stack Display CPU stack usage\n");
249 AcpiOsPrintf (" Tables Info about current ACPI table(s)\n");
250 AcpiOsPrintf (" Tables Display info about loaded ACPI tables\n");
251 AcpiOsPrintf (" Unload <TableSig> [Instance] Unload an ACPI table\n");
252 AcpiOsPrintf (" ! <CommandNumber> Execute command from history buffer\n");
253 AcpiOsPrintf (" !! Execute last command again\n");
254
255 AcpiOsPrintf ("\nNamespace Access Commands:\n");
256 AcpiOsPrintf (" Businfo Display system bus info\n");
257 AcpiOsPrintf (" Disassemble <Method> Disassemble a control method\n");
258 AcpiOsPrintf (" Event <F|G> <Value> Generate AcpiEvent (Fixed/GPE)\n");
259 AcpiOsPrintf (" Find <AcpiName> (? is wildcard) Find ACPI name(s) with wildcards\n");
260 AcpiOsPrintf (" Gpe <GpeNum> <GpeBlock> Simulate a GPE\n");
261 AcpiOsPrintf (" Gpes Display info on all GPEs\n");
262 AcpiOsPrintf (" Integrity Validate namespace integrity\n");
263 AcpiOsPrintf (" Methods Display list of loaded control methods\n");
264 AcpiOsPrintf (" Namespace [Object] [Depth] Display loaded namespace tree/subtree\n");
265 AcpiOsPrintf (" Notify <Object> <Value> Send a notification on Object\n");
266 AcpiOsPrintf (" Objects <ObjectType> Display all objects of the given type\n");
267 AcpiOsPrintf (" Owner <OwnerId> [Depth] Display loaded namespace by object owner\n");
268 AcpiOsPrintf (" Predefined Check all predefined names\n");
269 AcpiOsPrintf (" Prefix [<NamePath>] Set or Get current execution prefix\n");
270 AcpiOsPrintf (" References <Addr> Find all references to object at addr\n");
271 AcpiOsPrintf (" Resources <Device> Get and display Device resources\n");
272 AcpiOsPrintf (" Set N <NamedObject> <Value> Set value for named integer\n");
273 AcpiOsPrintf (" Sleep <SleepState> Simulate sleep/wake sequence\n");
274 AcpiOsPrintf (" Terminate Delete namespace and all internal objects\n");
275 AcpiOsPrintf (" Type <Object> Display object type\n");
276
277 AcpiOsPrintf ("\nControl Method Execution Commands:\n");
278 AcpiOsPrintf (" Arguments (or Args) Display method arguments\n");
279 AcpiOsPrintf (" Breakpoint <AmlOffset> Set an AML execution breakpoint\n");
280 AcpiOsPrintf (" Call Run to next control method invocation\n");
281 AcpiOsPrintf (" Debug <Namepath> [Arguments] Single Step a control method\n");
282 AcpiOsPrintf (" Execute <Namepath> [Arguments] Execute control method\n");
283 AcpiOsPrintf (" Hex Integer Integer method argument\n");
284 AcpiOsPrintf (" \"Ascii String\" String method argument\n");
285 AcpiOsPrintf (" (Byte List) Buffer method argument\n");
286 AcpiOsPrintf (" [Package Element List] Package method argument\n");
287 AcpiOsPrintf (" Go Allow method to run to completion\n");
288 AcpiOsPrintf (" Information Display info about the current method\n");
289 AcpiOsPrintf (" Into Step into (not over) a method call\n");
290 AcpiOsPrintf (" List [# of Aml Opcodes] Display method ASL statements\n");
291 AcpiOsPrintf (" Locals Display method local variables\n");
292 AcpiOsPrintf (" Results Display method result stack\n");
293 AcpiOsPrintf (" Set <A|L> <#> <Value> Set method data (Arguments/Locals)\n");
294 AcpiOsPrintf (" Stop Terminate control method\n");
295 AcpiOsPrintf (" Thread <Threads><Loops><NamePath> Spawn threads to execute method(s)\n");
296 AcpiOsPrintf (" Trace <method name> Trace method execution\n");
297 AcpiOsPrintf (" Tree Display control method calling tree\n");
298 AcpiOsPrintf (" <Enter> Single step next AML opcode (over calls)\n");
299
300 AcpiOsPrintf ("\nFile I/O Commands:\n");
301 AcpiOsPrintf (" Close Close debug output file\n");
302 AcpiOsPrintf (" Load <Input Filename> Load ACPI table from a file\n");
303 AcpiOsPrintf (" Open <Output Filename> Open a file for debug output\n");
304 }
305
306
307 /*******************************************************************************
308 *
309 * FUNCTION: AcpiDbGetNextToken
310 *
311 * PARAMETERS: String - Command buffer
312 * Next - Return value, end of next token
313 *
314 * RETURN: Pointer to the start of the next token.
315 *
316 * DESCRIPTION: Command line parsing. Get the next token on the command line
317 *
318 ******************************************************************************/
319
320 char *
321 AcpiDbGetNextToken (
322 char *String,
323 char **Next,
324 ACPI_OBJECT_TYPE *ReturnType)
325 {
326 char *Start;
327 UINT32 Depth;
328 ACPI_OBJECT_TYPE Type = ACPI_TYPE_INTEGER;
329
330
331 /* At end of buffer? */
332
333 if (!String || !(*String))
334 {
335 return (NULL);
336 }
337
338 /* Remove any spaces at the beginning */
339
340 if (*String == ' ')
341 {
342 while (*String && (*String == ' '))
343 {
344 String++;
345 }
346
347 if (!(*String))
348 {
349 return (NULL);
350 }
351 }
352
353 switch (*String)
354 {
355 case '"':
356
357 /* This is a quoted string, scan until closing quote */
358
359 String++;
360 Start = String;
361 Type = ACPI_TYPE_STRING;
362
363 /* Find end of string */
364
365 while (*String && (*String != '"'))
366 {
367 String++;
368 }
369 break;
370
371 case '(':
372
373 /* This is the start of a buffer, scan until closing paren */
374
375 String++;
376 Start = String;
377 Type = ACPI_TYPE_BUFFER;
378
379 /* Find end of buffer */
380
381 while (*String && (*String != ')'))
382 {
383 String++;
384 }
385 break;
386
387 case '[':
388
389 /* This is the start of a package, scan until closing bracket */
390
391 String++;
392 Depth = 1;
393 Start = String;
394 Type = ACPI_TYPE_PACKAGE;
395
396 /* Find end of package (closing bracket) */
397
398 while (*String)
399 {
400 /* Handle String package elements */
401
402 if (*String == '"')
403 {
404 /* Find end of string */
405
406 String++;
407 while (*String && (*String != '"'))
408 {
409 String++;
410 }
411 if (!(*String))
412 {
413 break;
414 }
415 }
416 else if (*String == '[')
417 {
418 Depth++; /* A nested package declaration */
419 }
420 else if (*String == ']')
421 {
422 Depth--;
423 if (Depth == 0) /* Found final package closing bracket */
424 {
425 break;
426 }
427 }
428
429 String++;
430 }
431 break;
432
433 default:
434
435 Start = String;
436
437 /* Find end of token */
438
439 while (*String && (*String != ' '))
440 {
441 String++;
442 }
443 break;
444 }
445
446 if (!(*String))
447 {
448 *Next = NULL;
449 }
450 else
451 {
452 *String = 0;
453 *Next = String + 1;
454 }
455
456 *ReturnType = Type;
457 return (Start);
458 }
459
460
461 /*******************************************************************************
462 *
463 * FUNCTION: AcpiDbGetLine
464 *
465 * PARAMETERS: InputBuffer - Command line buffer
466 *
467 * RETURN: Count of arguments to the command
468 *
469 * DESCRIPTION: Get the next command line from the user. Gets entire line
470 * up to the next newline
471 *
472 ******************************************************************************/
473
474 static UINT32
475 AcpiDbGetLine (
476 char *InputBuffer)
477 {
478 UINT32 i;
479 UINT32 Count;
480 char *Next;
481 char *This;
482
483
484 ACPI_STRCPY (AcpiGbl_DbParsedBuf, InputBuffer);
485
486 This = AcpiGbl_DbParsedBuf;
487 for (i = 0; i < ACPI_DEBUGGER_MAX_ARGS; i++)
488 {
489 AcpiGbl_DbArgs[i] = AcpiDbGetNextToken (This, &Next,
490 &AcpiGbl_DbArgTypes[i]);
491 if (!AcpiGbl_DbArgs[i])
492 {
493 break;
494 }
495
496 This = Next;
497 }
498
499 /* Uppercase the actual command */
500
501 if (AcpiGbl_DbArgs[0])
502 {
503 AcpiUtStrupr (AcpiGbl_DbArgs[0]);
504 }
505
506 Count = i;
507 if (Count)
508 {
509 Count--; /* Number of args only */
510 }
511
512 return (Count);
513 }
514
515
516 /*******************************************************************************
517 *
518 * FUNCTION: AcpiDbMatchCommand
519 *
520 * PARAMETERS: UserCommand - User command line
521 *
522 * RETURN: Index into command array, -1 if not found
523 *
524 * DESCRIPTION: Search command array for a command match
525 *
526 ******************************************************************************/
527
528 static UINT32
529 AcpiDbMatchCommand (
530 char *UserCommand)
531 {
532 UINT32 i;
533
534
535 if (!UserCommand || UserCommand[0] == 0)
536 {
537 return (CMD_NULL);
538 }
539
540 for (i = CMD_FIRST_VALID; AcpiGbl_DbCommands[i].Name; i++)
541 {
542 if (ACPI_STRSTR (AcpiGbl_DbCommands[i].Name, UserCommand) ==
543 AcpiGbl_DbCommands[i].Name)
544 {
545 return (i);
546 }
547 }
548
549 /* Command not recognized */
550
551 return (CMD_NOT_FOUND);
552 }
553
554
555 /*******************************************************************************
556 *
557 * FUNCTION: AcpiDbCommandDispatch
558 *
559 * PARAMETERS: InputBuffer - Command line buffer
560 * WalkState - Current walk
561 * Op - Current (executing) parse op
562 *
563 * RETURN: Status
564 *
565 * DESCRIPTION: Command dispatcher.
566 *
567 ******************************************************************************/
568
569 ACPI_STATUS
570 AcpiDbCommandDispatch (
571 char *InputBuffer,
572 ACPI_WALK_STATE *WalkState,
573 ACPI_PARSE_OBJECT *Op)
574 {
575 UINT32 Temp;
576 UINT32 CommandIndex;
577 UINT32 ParamCount;
578 char *CommandLine;
579 ACPI_STATUS Status = AE_CTRL_TRUE;
580
581
582 /* If AcpiTerminate has been called, terminate this thread */
583
584 if (AcpiGbl_DbTerminateThreads)
585 {
586 return (AE_CTRL_TERMINATE);
587 }
588
589 ParamCount = AcpiDbGetLine (InputBuffer);
590 CommandIndex = AcpiDbMatchCommand (AcpiGbl_DbArgs[0]);
591 Temp = 0;
592
593 /* Verify that we have the minimum number of params */
594
595 if (ParamCount < AcpiGbl_DbCommands[CommandIndex].MinArgs)
596 {
597 AcpiOsPrintf ("%u parameters entered, [%s] requires %u parameters\n",
598 ParamCount, AcpiGbl_DbCommands[CommandIndex].Name,
599 AcpiGbl_DbCommands[CommandIndex].MinArgs);
600
601 return (AE_CTRL_TRUE);
602 }
603
604 /* Decode and dispatch the command */
605
606 switch (CommandIndex)
607 {
608 case CMD_NULL:
609 if (Op)
610 {
611 return (AE_OK);
612 }
613 break;
614
615 case CMD_ALLOCATIONS:
616
617 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
618 AcpiUtDumpAllocations ((UINT32) -1, NULL);
619 #endif
620 break;
621
622 case CMD_ARGS:
623 case CMD_ARGUMENTS:
624 AcpiDbDisplayArguments ();
625 break;
626
627 case CMD_BATCH:
628 AcpiDbBatchExecute (AcpiGbl_DbArgs[1]);
629 break;
630
631 case CMD_BREAKPOINT:
632 AcpiDbSetMethodBreakpoint (AcpiGbl_DbArgs[1], WalkState, Op);
633 break;
634
635 case CMD_BUSINFO:
636 AcpiDbGetBusInfo ();
637 break;
638
639 case CMD_CALL:
640 AcpiDbSetMethodCallBreakpoint (Op);
641 Status = AE_OK;
642 break;
643
644 case CMD_CLOSE:
645 AcpiDbCloseDebugFile ();
646 break;
647
648 case CMD_DEBUG:
649 AcpiDbExecute (AcpiGbl_DbArgs[1],
650 &AcpiGbl_DbArgs[2], &AcpiGbl_DbArgTypes[2], EX_SINGLE_STEP);
651 break;
652
653 case CMD_DISASSEMBLE:
654 (void) AcpiDbDisassembleMethod (AcpiGbl_DbArgs[1]);
655 break;
656
657 case CMD_DUMP:
658 AcpiDbDecodeAndDisplayObject (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]);
659 break;
660
661 case CMD_ENABLEACPI:
662 Status = AcpiEnable();
663 if (ACPI_FAILURE(Status))
664 {
665 AcpiOsPrintf("AcpiEnable failed (Status=%X)\n", Status);
666 return (Status);
667 }
668 break;
669
670 case CMD_EVENT:
671 AcpiOsPrintf ("Event command not implemented\n");
672 break;
673
674 case CMD_EXECUTE:
675 AcpiDbExecute (AcpiGbl_DbArgs[1],
676 &AcpiGbl_DbArgs[2], &AcpiGbl_DbArgTypes[2], EX_NO_SINGLE_STEP);
677 break;
678
679 case CMD_FIND:
680 Status = AcpiDbFindNameInNamespace (AcpiGbl_DbArgs[1]);
681 break;
682
683 case CMD_GO:
684 AcpiGbl_CmSingleStep = FALSE;
685 return (AE_OK);
686
687 case CMD_GPE:
688 AcpiDbGenerateGpe (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]);
689 break;
690
691 case CMD_GPES:
692 AcpiDbDisplayGpes ();
693 break;
694
695 case CMD_HANDLERS:
696 AcpiDbDisplayHandlers ();
697 break;
698
699 case CMD_HELP:
700 case CMD_HELP2:
701 AcpiDbDisplayHelp ();
702 break;
703
704 case CMD_HISTORY:
705 AcpiDbDisplayHistory ();
706 break;
707
708 case CMD_HISTORY_EXE:
709 CommandLine = AcpiDbGetFromHistory (AcpiGbl_DbArgs[1]);
710 if (!CommandLine)
711 {
712 return (AE_CTRL_TRUE);
713 }
714
715 Status = AcpiDbCommandDispatch (CommandLine, WalkState, Op);
716 return (Status);
717
718 case CMD_HISTORY_LAST:
719 CommandLine = AcpiDbGetFromHistory (NULL);
720 if (!CommandLine)
721 {
722 return (AE_CTRL_TRUE);
723 }
724
725 Status = AcpiDbCommandDispatch (CommandLine, WalkState, Op);
726 return (Status);
727
728 case CMD_INFORMATION:
729 AcpiDbDisplayMethodInfo (Op);
730 break;
731
732 case CMD_INTEGRITY:
733 AcpiDbCheckIntegrity ();
734 break;
735
736 case CMD_INTO:
737 if (Op)
738 {
739 AcpiGbl_CmSingleStep = TRUE;
740 return (AE_OK);
741 }
742 break;
743
744 case CMD_LEVEL:
745 if (ParamCount == 0)
746 {
747 AcpiOsPrintf ("Current debug level for file output is: %8.8lX\n",
748 AcpiGbl_DbDebugLevel);
749 AcpiOsPrintf ("Current debug level for console output is: %8.8lX\n",
750 AcpiGbl_DbConsoleDebugLevel);
751 }
752 else if (ParamCount == 2)
753 {
754 Temp = AcpiGbl_DbConsoleDebugLevel;
755 AcpiGbl_DbConsoleDebugLevel = ACPI_STRTOUL (AcpiGbl_DbArgs[1],
756 NULL, 16);
757 AcpiOsPrintf (
758 "Debug Level for console output was %8.8lX, now %8.8lX\n",
759 Temp, AcpiGbl_DbConsoleDebugLevel);
760 }
761 else
762 {
763 Temp = AcpiGbl_DbDebugLevel;
764 AcpiGbl_DbDebugLevel = ACPI_STRTOUL (AcpiGbl_DbArgs[1], NULL, 16);
765 AcpiOsPrintf (
766 "Debug Level for file output was %8.8lX, now %8.8lX\n",
767 Temp, AcpiGbl_DbDebugLevel);
768 }
769 break;
770
771 case CMD_LIST:
772 AcpiDbDisassembleAml (AcpiGbl_DbArgs[1], Op);
773 break;
774
775 case CMD_LOAD:
776 Status = AcpiDbGetTableFromFile (AcpiGbl_DbArgs[1], NULL);
777 break;
778
779 case CMD_LOCKS:
780 AcpiDbDisplayLocks ();
781 break;
782
783 case CMD_LOCALS:
784 AcpiDbDisplayLocals ();
785 break;
786
787 case CMD_METHODS:
788 Status = AcpiDbDisplayObjects ("METHOD", AcpiGbl_DbArgs[1]);
789 break;
790
791 case CMD_NAMESPACE:
792 AcpiDbDumpNamespace (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]);
793 break;
794
795 case CMD_NOTIFY:
796 Temp = ACPI_STRTOUL (AcpiGbl_DbArgs[2], NULL, 0);
797 AcpiDbSendNotify (AcpiGbl_DbArgs[1], Temp);
798 break;
799
800 case CMD_OBJECT:
801 AcpiUtStrupr (AcpiGbl_DbArgs[1]);
802 Status = AcpiDbDisplayObjects (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]);
803 break;
804
805 case CMD_OPEN:
806 AcpiDbOpenDebugFile (AcpiGbl_DbArgs[1]);
807 break;
808
809 case CMD_OSI:
810 AcpiDbDisplayInterfaces (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]);
811 break;
812
813 case CMD_OWNER:
814 AcpiDbDumpNamespaceByOwner (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]);
815 break;
816
817 case CMD_PREDEFINED:
818 AcpiDbCheckPredefinedNames ();
819 break;
820
821 case CMD_PREFIX:
822 AcpiDbSetScope (AcpiGbl_DbArgs[1]);
823 break;
824
825 case CMD_REFERENCES:
826 AcpiDbFindReferences (AcpiGbl_DbArgs[1]);
827 break;
828
829 case CMD_RESOURCES:
830 AcpiDbDisplayResources (AcpiGbl_DbArgs[1]);
831 break;
832
833 case CMD_RESULTS:
834 AcpiDbDisplayResults ();
835 break;
836
837 case CMD_SET:
838 AcpiDbSetMethodData (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2],
839 AcpiGbl_DbArgs[3]);
840 break;
841
842 case CMD_SLEEP:
843 Status = AcpiDbSleep (AcpiGbl_DbArgs[1]);
844 break;
845
846 case CMD_STATS:
847 Status = AcpiDbDisplayStatistics (AcpiGbl_DbArgs[1]);
848 break;
849
850 case CMD_STOP:
851 return (AE_NOT_IMPLEMENTED);
852
853 case CMD_TABLES:
854 AcpiDbDisplayTableInfo (AcpiGbl_DbArgs[1]);
855 break;
856
857 case CMD_TERMINATE:
858 AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
859 AcpiUtSubsystemShutdown ();
860
861 /*
862 * TBD: [Restructure] Need some way to re-initialize without
863 * re-creating the semaphores!
864 */
865
866 /* AcpiInitialize (NULL); */
867 break;
868
869 case CMD_THREADS:
870 AcpiDbCreateExecutionThreads (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2],
871 AcpiGbl_DbArgs[3]);
872 break;
873
874 case CMD_TRACE:
875 (void) AcpiDebugTrace (AcpiGbl_DbArgs[1],0,0,1);
876 break;
877
878 case CMD_TREE:
879 AcpiDbDisplayCallingTree ();
880 break;
881
882 case CMD_TYPE:
883 AcpiDbDisplayObjectType (AcpiGbl_DbArgs[1]);
884 break;
885
886 case CMD_UNLOAD:
887 AcpiDbUnloadAcpiTable (AcpiGbl_DbArgs[1], AcpiGbl_DbArgs[2]);
888 break;
889
890 case CMD_EXIT:
891 case CMD_QUIT:
892 if (Op)
893 {
894 AcpiOsPrintf ("Method execution terminated\n");
895 return (AE_CTRL_TERMINATE);
896 }
897
898 if (!AcpiGbl_DbOutputToFile)
899 {
900 AcpiDbgLevel = ACPI_DEBUG_DEFAULT;
901 }
902
903 AcpiDbCloseDebugFile ();
904 AcpiGbl_DbTerminateThreads = TRUE;
905 return (AE_CTRL_TERMINATE);
906
907 case CMD_NOT_FOUND:
908 default:
909 AcpiOsPrintf ("Unknown Command\n");
910 return (AE_CTRL_TRUE);
911 }
912
913 if (ACPI_SUCCESS (Status))
914 {
915 Status = AE_CTRL_TRUE;
916 }
917
918 /* Add all commands that come here to the history buffer */
919
920 AcpiDbAddToHistory (InputBuffer);
921 return (Status);
922 }
923
924
925 /*******************************************************************************
926 *
927 * FUNCTION: AcpiDbExecuteThread
928 *
929 * PARAMETERS: Context - Not used
930 *
931 * RETURN: None
932 *
933 * DESCRIPTION: Debugger execute thread. Waits for a command line, then
934 * simply dispatches it.
935 *
936 ******************************************************************************/
937
938 void ACPI_SYSTEM_XFACE
939 AcpiDbExecuteThread (
940 void *Context)
941 {
942 ACPI_STATUS Status = AE_OK;
943 ACPI_STATUS MStatus;
944
945
946 while (Status != AE_CTRL_TERMINATE)
947 {
948 AcpiGbl_MethodExecuting = FALSE;
949 AcpiGbl_StepToNextCall = FALSE;
950
951 MStatus = AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_READY);
952 if (ACPI_FAILURE (MStatus))
953 {
954 return;
955 }
956
957 Status = AcpiDbCommandDispatch (AcpiGbl_DbLineBuf, NULL, NULL);
958
959 MStatus = AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_COMPLETE);
960 if (ACPI_FAILURE (MStatus))
961 {
962 return;
963 }
964 }
965 }
966
967
968 /*******************************************************************************
969 *
970 * FUNCTION: AcpiDbSingleThread
971 *
972 * PARAMETERS: None
973 *
974 * RETURN: None
975 *
976 * DESCRIPTION: Debugger execute thread. Waits for a command line, then
977 * simply dispatches it.
978 *
979 ******************************************************************************/
980
981 static void
982 AcpiDbSingleThread (
983 void)
984 {
985
986 AcpiGbl_MethodExecuting = FALSE;
987 AcpiGbl_StepToNextCall = FALSE;
988
989 (void) AcpiDbCommandDispatch (AcpiGbl_DbLineBuf, NULL, NULL);
990 }
991
992
993 /*******************************************************************************
994 *
995 * FUNCTION: AcpiDbUserCommands
996 *
997 * PARAMETERS: Prompt - User prompt (depends on mode)
998 * Op - Current executing parse op
999 *
1000 * RETURN: None
1001 *
1002 * DESCRIPTION: Command line execution for the AML debugger. Commands are
1003 * matched and dispatched here.
1004 *
1005 ******************************************************************************/
1006
1007 ACPI_STATUS
1008 AcpiDbUserCommands (
1009 char Prompt,
1010 ACPI_PARSE_OBJECT *Op)
1011 {
1012 ACPI_STATUS Status = AE_OK;
1013
1014
1015 /* TBD: [Restructure] Need a separate command line buffer for step mode */
1016
1017 while (!AcpiGbl_DbTerminateThreads)
1018 {
1019 /* Force output to console until a command is entered */
1020
1021 AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
1022
1023 /* Different prompt if method is executing */
1024
1025 if (!AcpiGbl_MethodExecuting)
1026 {
1027 AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_COMMAND_PROMPT);
1028 }
1029 else
1030 {
1031 AcpiOsPrintf ("%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT);
1032 }
1033
1034 /* Get the user input line */
1035
1036 Status = AcpiOsGetLine (AcpiGbl_DbLineBuf,
1037 ACPI_DB_LINE_BUFFER_SIZE, NULL);
1038 if (ACPI_FAILURE (Status))
1039 {
1040 ACPI_EXCEPTION ((AE_INFO, Status, "While parsing command line"));
1041 return (Status);
1042 }
1043
1044 /* Check for single or multithreaded debug */
1045
1046 if (AcpiGbl_DebuggerConfiguration & DEBUGGER_MULTI_THREADED)
1047 {
1048 /*
1049 * Signal the debug thread that we have a command to execute,
1050 * and wait for the command to complete.
1051 */
1052 Status = AcpiUtReleaseMutex (ACPI_MTX_DEBUG_CMD_READY);
1053 if (ACPI_FAILURE (Status))
1054 {
1055 return (Status);
1056 }
1057
1058 Status = AcpiUtAcquireMutex (ACPI_MTX_DEBUG_CMD_COMPLETE);
1059 if (ACPI_FAILURE (Status))
1060 {
1061 return (Status);
1062 }
1063 }
1064 else
1065 {
1066 /* Just call to the command line interpreter */
1067
1068 AcpiDbSingleThread ();
1069 }
1070 }
1071
1072 /*
1073 * Only this thread (the original thread) should actually terminate the
1074 * subsystem, because all the semaphores are deleted during termination
1075 */
1076 Status = AcpiTerminate ();
1077 return (Status);
1078 }
1079
1080 #endif /* ACPI_DEBUGGER */
1081