blob: 0480254437f1a30be42b91a920735b18d2b28f95 [file] [log] [blame]
Lv Zheng99575102015-10-19 10:25:20 +08001/*******************************************************************************
2 *
3 * Module Name: dbinput - user front-end to the AML debugger
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, 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#include <acpi/acpi.h>
45#include "accommon.h"
46#include "acdebug.h"
47
48#define _COMPONENT ACPI_CA_DEBUGGER
49ACPI_MODULE_NAME("dbinput")
50
51/* Local prototypes */
52static u32 acpi_db_get_line(char *input_buffer);
53
54static u32 acpi_db_match_command(char *user_command);
55
56static void acpi_db_single_thread(void);
57
58static void acpi_db_display_command_info(char *command, u8 display_all);
59
60static void acpi_db_display_help(char *command);
61
62static u8
63acpi_db_match_command_help(char *command,
64 const struct acpi_db_command_help *help);
65
66/*
67 * Top-level debugger commands.
68 *
69 * This list of commands must match the string table below it
70 */
71enum acpi_ex_debugger_commands {
72 CMD_NOT_FOUND = 0,
73 CMD_NULL,
74 CMD_ALLOCATIONS,
75 CMD_ARGS,
76 CMD_ARGUMENTS,
77 CMD_BREAKPOINT,
78 CMD_BUSINFO,
79 CMD_CALL,
80 CMD_DEBUG,
81 CMD_DISASSEMBLE,
82 CMD_DISASM,
83 CMD_DUMP,
84 CMD_EVALUATE,
85 CMD_EXECUTE,
86 CMD_EXIT,
87 CMD_FIND,
88 CMD_GO,
89 CMD_HANDLERS,
90 CMD_HELP,
91 CMD_HELP2,
92 CMD_HISTORY,
93 CMD_HISTORY_EXE,
94 CMD_HISTORY_LAST,
95 CMD_INFORMATION,
96 CMD_INTEGRITY,
97 CMD_INTO,
98 CMD_LEVEL,
99 CMD_LIST,
100 CMD_LOCALS,
101 CMD_LOCKS,
102 CMD_METHODS,
103 CMD_NAMESPACE,
104 CMD_NOTIFY,
105 CMD_OBJECTS,
106 CMD_OSI,
107 CMD_OWNER,
108 CMD_PATHS,
109 CMD_PREDEFINED,
110 CMD_PREFIX,
111 CMD_QUIT,
112 CMD_REFERENCES,
113 CMD_RESOURCES,
114 CMD_RESULTS,
115 CMD_SET,
116 CMD_STATS,
117 CMD_STOP,
118 CMD_TABLES,
119 CMD_TEMPLATE,
120 CMD_TRACE,
121 CMD_TREE,
122 CMD_TYPE,
123#ifdef ACPI_APPLICATION
124 CMD_ENABLEACPI,
125 CMD_EVENT,
126 CMD_GPE,
127 CMD_GPES,
128 CMD_SCI,
129 CMD_SLEEP,
130
131 CMD_CLOSE,
132 CMD_LOAD,
133 CMD_OPEN,
134 CMD_UNLOAD,
135
136 CMD_TERMINATE,
137 CMD_THREADS,
138
139 CMD_TEST,
140#endif
141};
142
143#define CMD_FIRST_VALID 2
144
145/* Second parameter is the required argument count */
146
147static const struct acpi_db_command_info acpi_gbl_db_commands[] = {
148 {"<NOT FOUND>", 0},
149 {"<NULL>", 0},
150 {"ALLOCATIONS", 0},
151 {"ARGS", 0},
152 {"ARGUMENTS", 0},
153 {"BREAKPOINT", 1},
154 {"BUSINFO", 0},
155 {"CALL", 0},
156 {"DEBUG", 1},
157 {"DISASSEMBLE", 1},
158 {"DISASM", 1},
159 {"DUMP", 1},
160 {"EVALUATE", 1},
161 {"EXECUTE", 1},
162 {"EXIT", 0},
163 {"FIND", 1},
164 {"GO", 0},
165 {"HANDLERS", 0},
166 {"HELP", 0},
167 {"?", 0},
168 {"HISTORY", 0},
169 {"!", 1},
170 {"!!", 0},
171 {"INFORMATION", 0},
172 {"INTEGRITY", 0},
173 {"INTO", 0},
174 {"LEVEL", 0},
175 {"LIST", 0},
176 {"LOCALS", 0},
177 {"LOCKS", 0},
178 {"METHODS", 0},
179 {"NAMESPACE", 0},
180 {"NOTIFY", 2},
181 {"OBJECTS", 0},
182 {"OSI", 0},
183 {"OWNER", 1},
184 {"PATHS", 0},
185 {"PREDEFINED", 0},
186 {"PREFIX", 0},
187 {"QUIT", 0},
188 {"REFERENCES", 1},
189 {"RESOURCES", 0},
190 {"RESULTS", 0},
191 {"SET", 3},
192 {"STATS", 1},
193 {"STOP", 0},
194 {"TABLES", 0},
195 {"TEMPLATE", 1},
196 {"TRACE", 1},
197 {"TREE", 0},
198 {"TYPE", 1},
199#ifdef ACPI_APPLICATION
200 {"ENABLEACPI", 0},
201 {"EVENT", 1},
202 {"GPE", 1},
203 {"GPES", 0},
204 {"SCI", 0},
205 {"SLEEP", 0},
206
207 {"CLOSE", 0},
208 {"LOAD", 1},
209 {"OPEN", 1},
210 {"UNLOAD", 1},
211
212 {"TERMINATE", 0},
213 {"THREADS", 3},
214
215 {"TEST", 1},
216#endif
217 {NULL, 0}
218};
219
220/*
221 * Help for all debugger commands. First argument is the number of lines
222 * of help to output for the command.
223 */
224static const struct acpi_db_command_help acpi_gbl_db_command_help[] = {
225 {0, "\nGeneral-Purpose Commands:", "\n"},
226 {1, " Allocations", "Display list of current memory allocations\n"},
227 {2, " Dump <Address>|<Namepath>", "\n"},
228 {0, " [Byte|Word|Dword|Qword]",
229 "Display ACPI objects or memory\n"},
230 {1, " Handlers", "Info about global handlers\n"},
231 {1, " Help [Command]", "This help screen or individual command\n"},
232 {1, " History", "Display command history buffer\n"},
233 {1, " Level <DebugLevel>] [console]",
234 "Get/Set debug level for file or console\n"},
235 {1, " Locks", "Current status of internal mutexes\n"},
236 {1, " Osi [Install|Remove <name>]",
237 "Display or modify global _OSI list\n"},
238 {1, " Quit or Exit", "Exit this command\n"},
239 {8, " Stats <SubCommand>",
240 "Display namespace and memory statistics\n"},
241 {1, " Allocations", "Display list of current memory allocations\n"},
242 {1, " Memory", "Dump internal memory lists\n"},
243 {1, " Misc", "Namespace search and mutex stats\n"},
244 {1, " Objects", "Summary of namespace objects\n"},
245 {1, " Sizes", "Sizes for each of the internal objects\n"},
246 {1, " Stack", "Display CPU stack usage\n"},
247 {1, " Tables", "Info about current ACPI table(s)\n"},
248 {1, " Tables", "Display info about loaded ACPI tables\n"},
249 {1, " ! <CommandNumber>", "Execute command from history buffer\n"},
250 {1, " !!", "Execute last command again\n"},
251
252 {0, "\nNamespace Access Commands:", "\n"},
253 {1, " Businfo", "Display system bus info\n"},
254 {1, " Disassemble <Method>", "Disassemble a control method\n"},
255 {1, " Find <AcpiName> (? is wildcard)",
256 "Find ACPI name(s) with wildcards\n"},
257 {1, " Integrity", "Validate namespace integrity\n"},
258 {1, " Methods", "Display list of loaded control methods\n"},
259 {1, " Namespace [Object] [Depth]",
260 "Display loaded namespace tree/subtree\n"},
261 {1, " Notify <Object> <Value>", "Send a notification on Object\n"},
262 {1, " Objects [ObjectType]",
263 "Display summary of all objects or just given type\n"},
264 {1, " Owner <OwnerId> [Depth]",
265 "Display loaded namespace by object owner\n"},
266 {1, " Paths", "Display full pathnames of namespace objects\n"},
267 {1, " Predefined", "Check all predefined names\n"},
268 {1, " Prefix [<Namepath>]", "Set or Get current execution prefix\n"},
269 {1, " References <Addr>", "Find all references to object at addr\n"},
270 {1, " Resources [DeviceName]",
271 "Display Device resources (no arg = all devices)\n"},
272 {1, " Set N <NamedObject> <Value>", "Set value for named integer\n"},
273 {1, " Template <Object>", "Format/dump a Buffer/ResourceTemplate\n"},
274 {1, " Type <Object>", "Display object type\n"},
275
276 {0, "\nControl Method Execution Commands:", "\n"},
277 {1, " Arguments (or Args)", "Display method arguments\n"},
278 {1, " Breakpoint <AmlOffset>", "Set an AML execution breakpoint\n"},
279 {1, " Call", "Run to next control method invocation\n"},
280 {1, " Debug <Namepath> [Arguments]", "Single Step a control method\n"},
281 {6, " Evaluate", "Synonym for Execute\n"},
282 {5, " Execute <Namepath> [Arguments]", "Execute control method\n"},
283 {1, " Hex Integer", "Integer method argument\n"},
284 {1, " \"Ascii String\"", "String method argument\n"},
285 {1, " (Hex Byte List)", "Buffer method argument\n"},
286 {1, " [Package Element List]", "Package method argument\n"},
287 {1, " Go", "Allow method to run to completion\n"},
288 {1, " Information", "Display info about the current method\n"},
289 {1, " Into", "Step into (not over) a method call\n"},
290 {1, " List [# of Aml Opcodes]", "Display method ASL statements\n"},
291 {1, " Locals", "Display method local variables\n"},
292 {1, " Results", "Display method result stack\n"},
293 {1, " Set <A|L> <#> <Value>", "Set method data (Arguments/Locals)\n"},
294 {1, " Stop", "Terminate control method\n"},
295 {5, " Trace <State> [<Namepath>] [Once]",
296 "Trace control method execution\n"},
297 {1, " Enable", "Enable all messages\n"},
298 {1, " Disable", "Disable tracing\n"},
299 {1, " Method", "Enable method execution messages\n"},
300 {1, " Opcode", "Enable opcode execution messages\n"},
301 {1, " Tree", "Display control method calling tree\n"},
302 {1, " <Enter>", "Single step next AML opcode (over calls)\n"},
303
304#ifdef ACPI_APPLICATION
305 {0, "\nHardware Simulation Commands:", "\n"},
306 {1, " EnableAcpi", "Enable ACPI (hardware) mode\n"},
307 {1, " Event <F|G> <Value>", "Generate AcpiEvent (Fixed/GPE)\n"},
308 {1, " Gpe <GpeNum> [GpeBlockDevice]", "Simulate a GPE\n"},
309 {1, " Gpes", "Display info on all GPE devices\n"},
310 {1, " Sci", "Generate an SCI\n"},
311 {1, " Sleep [SleepState]", "Simulate sleep/wake sequence(s) (0-5)\n"},
312
313 {0, "\nFile I/O Commands:", "\n"},
314 {1, " Close", "Close debug output file\n"},
315 {1, " Load <Input Filename>", "Load ACPI table from a file\n"},
316 {1, " Open <Output Filename>", "Open a file for debug output\n"},
317 {1, " Unload <Namepath>",
318 "Unload an ACPI table via namespace object\n"},
319
320 {0, "\nUser Space Commands:", "\n"},
321 {1, " Terminate", "Delete namespace and all internal objects\n"},
322 {1, " Thread <Threads><Loops><NamePath>",
323 "Spawn threads to execute method(s)\n"},
324
325 {0, "\nDebug Test Commands:", "\n"},
326 {3, " Test <TestName>", "Invoke a debug test\n"},
327 {1, " Objects", "Read/write/compare all namespace data objects\n"},
328 {1, " Predefined",
329 "Execute all ACPI predefined names (_STA, etc.)\n"},
330#endif
331 {0, NULL, NULL}
332};
333
334/*******************************************************************************
335 *
336 * FUNCTION: acpi_db_match_command_help
337 *
338 * PARAMETERS: command - Command string to match
339 * help - Help table entry to attempt match
340 *
341 * RETURN: TRUE if command matched, FALSE otherwise
342 *
343 * DESCRIPTION: Attempt to match a command in the help table in order to
344 * print help information for a single command.
345 *
346 ******************************************************************************/
347
348static u8
349acpi_db_match_command_help(char *command,
350 const struct acpi_db_command_help *help)
351{
352 char *invocation = help->invocation;
353 u32 line_count;
354
355 /* Valid commands in the help table begin with a couple of spaces */
356
357 if (*invocation != ' ') {
358 return (FALSE);
359 }
360
361 while (*invocation == ' ') {
362 invocation++;
363 }
364
365 /* Match command name (full command or substring) */
366
367 while ((*command) && (*invocation) && (*invocation != ' ')) {
368 if (tolower((int)*command) != tolower((int)*invocation)) {
369 return (FALSE);
370 }
371
372 invocation++;
373 command++;
374 }
375
376 /* Print the appropriate number of help lines */
377
378 line_count = help->line_count;
379 while (line_count) {
380 acpi_os_printf("%-38s : %s", help->invocation,
381 help->description);
382 help++;
383 line_count--;
384 }
385
386 return (TRUE);
387}
388
389/*******************************************************************************
390 *
391 * FUNCTION: acpi_db_display_command_info
392 *
393 * PARAMETERS: command - Command string to match
394 * display_all - Display all matching commands, or just
395 * the first one (substring match)
396 *
397 * RETURN: None
398 *
399 * DESCRIPTION: Display help information for a Debugger command.
400 *
401 ******************************************************************************/
402
403static void acpi_db_display_command_info(char *command, u8 display_all)
404{
405 const struct acpi_db_command_help *next;
406 u8 matched;
407
408 next = acpi_gbl_db_command_help;
409 while (next->invocation) {
410 matched = acpi_db_match_command_help(command, next);
411 if (!display_all && matched) {
412 return;
413 }
414
415 next++;
416 }
417}
418
419/*******************************************************************************
420 *
421 * FUNCTION: acpi_db_display_help
422 *
423 * PARAMETERS: command - Optional command string to display help.
424 * if not specified, all debugger command
425 * help strings are displayed
426 *
427 * RETURN: None
428 *
429 * DESCRIPTION: Display help for a single debugger command, or all of them.
430 *
431 ******************************************************************************/
432
433static void acpi_db_display_help(char *command)
434{
435 const struct acpi_db_command_help *next = acpi_gbl_db_command_help;
436
437 if (!command) {
438
439 /* No argument to help, display help for all commands */
440
441 while (next->invocation) {
442 acpi_os_printf("%-38s%s", next->invocation,
443 next->description);
444 next++;
445 }
446 } else {
447 /* Display help for all commands that match the subtring */
448
449 acpi_db_display_command_info(command, TRUE);
450 }
451}
452
453/*******************************************************************************
454 *
455 * FUNCTION: acpi_db_get_next_token
456 *
457 * PARAMETERS: string - Command buffer
458 * next - Return value, end of next token
459 *
460 * RETURN: Pointer to the start of the next token.
461 *
462 * DESCRIPTION: Command line parsing. Get the next token on the command line
463 *
464 ******************************************************************************/
465
466char *acpi_db_get_next_token(char *string,
467 char **next, acpi_object_type * return_type)
468{
469 char *start;
470 u32 depth;
471 acpi_object_type type = ACPI_TYPE_INTEGER;
472
473 /* At end of buffer? */
474
475 if (!string || !(*string)) {
476 return (NULL);
477 }
478
479 /* Remove any spaces at the beginning */
480
481 if (*string == ' ') {
482 while (*string && (*string == ' ')) {
483 string++;
484 }
485
486 if (!(*string)) {
487 return (NULL);
488 }
489 }
490
491 switch (*string) {
492 case '"':
493
494 /* This is a quoted string, scan until closing quote */
495
496 string++;
497 start = string;
498 type = ACPI_TYPE_STRING;
499
500 /* Find end of string */
501
502 while (*string && (*string != '"')) {
503 string++;
504 }
505 break;
506
507 case '(':
508
509 /* This is the start of a buffer, scan until closing paren */
510
511 string++;
512 start = string;
513 type = ACPI_TYPE_BUFFER;
514
515 /* Find end of buffer */
516
517 while (*string && (*string != ')')) {
518 string++;
519 }
520 break;
521
522 case '[':
523
524 /* This is the start of a package, scan until closing bracket */
525
526 string++;
527 depth = 1;
528 start = string;
529 type = ACPI_TYPE_PACKAGE;
530
531 /* Find end of package (closing bracket) */
532
533 while (*string) {
534
535 /* Handle String package elements */
536
537 if (*string == '"') {
538 /* Find end of string */
539
540 string++;
541 while (*string && (*string != '"')) {
542 string++;
543 }
544 if (!(*string)) {
545 break;
546 }
547 } else if (*string == '[') {
548 depth++; /* A nested package declaration */
549 } else if (*string == ']') {
550 depth--;
551 if (depth == 0) { /* Found final package closing bracket */
552 break;
553 }
554 }
555
556 string++;
557 }
558 break;
559
560 default:
561
562 start = string;
563
564 /* Find end of token */
565
566 while (*string && (*string != ' ')) {
567 string++;
568 }
569 break;
570 }
571
572 if (!(*string)) {
573 *next = NULL;
574 } else {
575 *string = 0;
576 *next = string + 1;
577 }
578
579 *return_type = type;
580 return (start);
581}
582
583/*******************************************************************************
584 *
585 * FUNCTION: acpi_db_get_line
586 *
587 * PARAMETERS: input_buffer - Command line buffer
588 *
589 * RETURN: Count of arguments to the command
590 *
591 * DESCRIPTION: Get the next command line from the user. Gets entire line
592 * up to the next newline
593 *
594 ******************************************************************************/
595
596static u32 acpi_db_get_line(char *input_buffer)
597{
598 u32 i;
599 u32 count;
600 char *next;
601 char *this;
602
603 if (acpi_ut_safe_strcpy
604 (acpi_gbl_db_parsed_buf, sizeof(acpi_gbl_db_parsed_buf),
605 input_buffer)) {
606 acpi_os_printf
607 ("Buffer overflow while parsing input line (max %u characters)\n",
608 sizeof(acpi_gbl_db_parsed_buf));
609 return (0);
610 }
611
612 this = acpi_gbl_db_parsed_buf;
613 for (i = 0; i < ACPI_DEBUGGER_MAX_ARGS; i++) {
614 acpi_gbl_db_args[i] = acpi_db_get_next_token(this, &next,
615 &acpi_gbl_db_arg_types
616 [i]);
617 if (!acpi_gbl_db_args[i]) {
618 break;
619 }
620
621 this = next;
622 }
623
624 /* Uppercase the actual command */
625
626 if (acpi_gbl_db_args[0]) {
627 acpi_ut_strupr(acpi_gbl_db_args[0]);
628 }
629
630 count = i;
631 if (count) {
632 count--; /* Number of args only */
633 }
634
635 return (count);
636}
637
638/*******************************************************************************
639 *
640 * FUNCTION: acpi_db_match_command
641 *
642 * PARAMETERS: user_command - User command line
643 *
644 * RETURN: Index into command array, -1 if not found
645 *
646 * DESCRIPTION: Search command array for a command match
647 *
648 ******************************************************************************/
649
650static u32 acpi_db_match_command(char *user_command)
651{
652 u32 i;
653
654 if (!user_command || user_command[0] == 0) {
655 return (CMD_NULL);
656 }
657
658 for (i = CMD_FIRST_VALID; acpi_gbl_db_commands[i].name; i++) {
659 if (strstr(acpi_gbl_db_commands[i].name, user_command) ==
660 acpi_gbl_db_commands[i].name) {
661 return (i);
662 }
663 }
664
665 /* Command not recognized */
666
667 return (CMD_NOT_FOUND);
668}
669
670/*******************************************************************************
671 *
672 * FUNCTION: acpi_db_command_dispatch
673 *
674 * PARAMETERS: input_buffer - Command line buffer
675 * walk_state - Current walk
676 * op - Current (executing) parse op
677 *
678 * RETURN: Status
679 *
680 * DESCRIPTION: Command dispatcher.
681 *
682 ******************************************************************************/
683
684acpi_status
685acpi_db_command_dispatch(char *input_buffer,
686 struct acpi_walk_state * walk_state,
687 union acpi_parse_object * op)
688{
689 u32 temp;
690 u32 command_index;
691 u32 param_count;
692 char *command_line;
693 acpi_status status = AE_CTRL_TRUE;
694
695 /* If acpi_terminate has been called, terminate this thread */
696
Lv Zhengaf08f9c2015-10-19 10:25:32 +0800697 if (acpi_gbl_db_terminate_loop) {
Lv Zheng99575102015-10-19 10:25:20 +0800698 return (AE_CTRL_TERMINATE);
699 }
700
701 /* Find command and add to the history buffer */
702
703 param_count = acpi_db_get_line(input_buffer);
704 command_index = acpi_db_match_command(acpi_gbl_db_args[0]);
705 temp = 0;
706
707 /*
708 * We don't want to add the !! command to the history buffer. It
709 * would cause an infinite loop because it would always be the
710 * previous command.
711 */
712 if (command_index != CMD_HISTORY_LAST) {
713 acpi_db_add_to_history(input_buffer);
714 }
715
716 /* Verify that we have the minimum number of params */
717
718 if (param_count < acpi_gbl_db_commands[command_index].min_args) {
719 acpi_os_printf
720 ("%u parameters entered, [%s] requires %u parameters\n",
721 param_count, acpi_gbl_db_commands[command_index].name,
722 acpi_gbl_db_commands[command_index].min_args);
723
724 acpi_db_display_command_info(acpi_gbl_db_commands
725 [command_index].name, FALSE);
726 return (AE_CTRL_TRUE);
727 }
728
729 /* Decode and dispatch the command */
730
731 switch (command_index) {
732 case CMD_NULL:
733
734 if (op) {
735 return (AE_OK);
736 }
737 break;
738
739 case CMD_ALLOCATIONS:
740
741#ifdef ACPI_DBG_TRACK_ALLOCATIONS
742 acpi_ut_dump_allocations((u32)-1, NULL);
743#endif
744 break;
745
746 case CMD_ARGS:
747 case CMD_ARGUMENTS:
748
749 acpi_db_display_arguments();
750 break;
751
752 case CMD_BREAKPOINT:
753
754 acpi_db_set_method_breakpoint(acpi_gbl_db_args[1], walk_state,
755 op);
756 break;
757
758 case CMD_BUSINFO:
759
760 acpi_db_get_bus_info();
761 break;
762
763 case CMD_CALL:
764
765 acpi_db_set_method_call_breakpoint(op);
766 status = AE_OK;
767 break;
768
769 case CMD_DEBUG:
770
771 acpi_db_execute(acpi_gbl_db_args[1],
772 &acpi_gbl_db_args[2], &acpi_gbl_db_arg_types[2],
773 EX_SINGLE_STEP);
774 break;
775
776 case CMD_DISASSEMBLE:
777 case CMD_DISASM:
778
779 (void)acpi_db_disassemble_method(acpi_gbl_db_args[1]);
780 break;
781
782 case CMD_DUMP:
783
784 acpi_db_decode_and_display_object(acpi_gbl_db_args[1],
785 acpi_gbl_db_args[2]);
786 break;
787
788 case CMD_EVALUATE:
789 case CMD_EXECUTE:
790
791 acpi_db_execute(acpi_gbl_db_args[1],
792 &acpi_gbl_db_args[2], &acpi_gbl_db_arg_types[2],
793 EX_NO_SINGLE_STEP);
794 break;
795
796 case CMD_FIND:
797
798 status = acpi_db_find_name_in_namespace(acpi_gbl_db_args[1]);
799 break;
800
801 case CMD_GO:
802
803 acpi_gbl_cm_single_step = FALSE;
804 return (AE_OK);
805
806 case CMD_HANDLERS:
807
808 acpi_db_display_handlers();
809 break;
810
811 case CMD_HELP:
812 case CMD_HELP2:
813
814 acpi_db_display_help(acpi_gbl_db_args[1]);
815 break;
816
817 case CMD_HISTORY:
818
819 acpi_db_display_history();
820 break;
821
822 case CMD_HISTORY_EXE: /* ! command */
823
824 command_line = acpi_db_get_from_history(acpi_gbl_db_args[1]);
825 if (!command_line) {
826 return (AE_CTRL_TRUE);
827 }
828
829 status = acpi_db_command_dispatch(command_line, walk_state, op);
830 return (status);
831
832 case CMD_HISTORY_LAST: /* !! command */
833
834 command_line = acpi_db_get_from_history(NULL);
835 if (!command_line) {
836 return (AE_CTRL_TRUE);
837 }
838
839 status = acpi_db_command_dispatch(command_line, walk_state, op);
840 return (status);
841
842 case CMD_INFORMATION:
843
844 acpi_db_display_method_info(op);
845 break;
846
847 case CMD_INTEGRITY:
848
849 acpi_db_check_integrity();
850 break;
851
852 case CMD_INTO:
853
854 if (op) {
855 acpi_gbl_cm_single_step = TRUE;
856 return (AE_OK);
857 }
858 break;
859
860 case CMD_LEVEL:
861
862 if (param_count == 0) {
863 acpi_os_printf
864 ("Current debug level for file output is: %8.8lX\n",
865 acpi_gbl_db_debug_level);
866 acpi_os_printf
867 ("Current debug level for console output is: %8.8lX\n",
868 acpi_gbl_db_console_debug_level);
869 } else if (param_count == 2) {
870 temp = acpi_gbl_db_console_debug_level;
871 acpi_gbl_db_console_debug_level =
872 strtoul(acpi_gbl_db_args[1], NULL, 16);
873 acpi_os_printf
874 ("Debug Level for console output was %8.8lX, now %8.8lX\n",
875 temp, acpi_gbl_db_console_debug_level);
876 } else {
877 temp = acpi_gbl_db_debug_level;
878 acpi_gbl_db_debug_level =
879 strtoul(acpi_gbl_db_args[1], NULL, 16);
880 acpi_os_printf
881 ("Debug Level for file output was %8.8lX, now %8.8lX\n",
882 temp, acpi_gbl_db_debug_level);
883 }
884 break;
885
886 case CMD_LIST:
887
888 acpi_db_disassemble_aml(acpi_gbl_db_args[1], op);
889 break;
890
891 case CMD_LOCKS:
892
893 acpi_db_display_locks();
894 break;
895
896 case CMD_LOCALS:
897
898 acpi_db_display_locals();
899 break;
900
901 case CMD_METHODS:
902
903 status = acpi_db_display_objects("METHOD", acpi_gbl_db_args[1]);
904 break;
905
906 case CMD_NAMESPACE:
907
908 acpi_db_dump_namespace(acpi_gbl_db_args[1],
909 acpi_gbl_db_args[2]);
910 break;
911
912 case CMD_NOTIFY:
913
914 temp = strtoul(acpi_gbl_db_args[2], NULL, 0);
915 acpi_db_send_notify(acpi_gbl_db_args[1], temp);
916 break;
917
918 case CMD_OBJECTS:
919
920 acpi_ut_strupr(acpi_gbl_db_args[1]);
921 status =
922 acpi_db_display_objects(acpi_gbl_db_args[1],
923 acpi_gbl_db_args[2]);
924 break;
925
926 case CMD_OSI:
927
928 acpi_db_display_interfaces(acpi_gbl_db_args[1],
929 acpi_gbl_db_args[2]);
930 break;
931
932 case CMD_OWNER:
933
934 acpi_db_dump_namespace_by_owner(acpi_gbl_db_args[1],
935 acpi_gbl_db_args[2]);
936 break;
937
938 case CMD_PATHS:
939
940 acpi_db_dump_namespace_paths();
941 break;
942
943 case CMD_PREFIX:
944
945 acpi_db_set_scope(acpi_gbl_db_args[1]);
946 break;
947
948 case CMD_REFERENCES:
949
950 acpi_db_find_references(acpi_gbl_db_args[1]);
951 break;
952
953 case CMD_RESOURCES:
954
955 acpi_db_display_resources(acpi_gbl_db_args[1]);
956 break;
957
958 case CMD_RESULTS:
959
960 acpi_db_display_results();
961 break;
962
963 case CMD_SET:
964
965 acpi_db_set_method_data(acpi_gbl_db_args[1],
966 acpi_gbl_db_args[2],
967 acpi_gbl_db_args[3]);
968 break;
969
970 case CMD_STATS:
971
972 status = acpi_db_display_statistics(acpi_gbl_db_args[1]);
973 break;
974
975 case CMD_STOP:
976
977 return (AE_NOT_IMPLEMENTED);
978
979 case CMD_TABLES:
980
981 acpi_db_display_table_info(acpi_gbl_db_args[1]);
982 break;
983
984 case CMD_TEMPLATE:
985
986 acpi_db_display_template(acpi_gbl_db_args[1]);
987 break;
988
989 case CMD_TRACE:
990
991 acpi_db_trace(acpi_gbl_db_args[1], acpi_gbl_db_args[2],
992 acpi_gbl_db_args[3]);
993 break;
994
995 case CMD_TREE:
996
997 acpi_db_display_calling_tree();
998 break;
999
1000 case CMD_TYPE:
1001
1002 acpi_db_display_object_type(acpi_gbl_db_args[1]);
1003 break;
1004
1005#ifdef ACPI_APPLICATION
1006
1007 /* Hardware simulation commands. */
1008
1009 case CMD_ENABLEACPI:
1010#if (!ACPI_REDUCED_HARDWARE)
1011
1012 status = acpi_enable();
1013 if (ACPI_FAILURE(status)) {
1014 acpi_os_printf("AcpiEnable failed (Status=%X)\n",
1015 status);
1016 return (status);
1017 }
1018#endif /* !ACPI_REDUCED_HARDWARE */
1019 break;
1020
1021 case CMD_EVENT:
1022
1023 acpi_os_printf("Event command not implemented\n");
1024 break;
1025
1026 case CMD_GPE:
1027
1028 acpi_db_generate_gpe(acpi_gbl_db_args[1], acpi_gbl_db_args[2]);
1029 break;
1030
1031 case CMD_GPES:
1032
1033 acpi_db_display_gpes();
1034 break;
1035
1036 case CMD_SCI:
1037
1038 acpi_db_generate_sci();
1039 break;
1040
1041 case CMD_SLEEP:
1042
1043 status = acpi_db_sleep(acpi_gbl_db_args[1]);
1044 break;
1045
1046 /* File I/O commands. */
1047
1048 case CMD_CLOSE:
1049
1050 acpi_db_close_debug_file();
1051 break;
1052
1053 case CMD_LOAD:
1054
1055 status =
1056 acpi_db_get_table_from_file(acpi_gbl_db_args[1], NULL,
1057 FALSE);
1058 break;
1059
1060 case CMD_OPEN:
1061
1062 acpi_db_open_debug_file(acpi_gbl_db_args[1]);
1063 break;
1064
1065 /* User space commands. */
1066
1067 case CMD_TERMINATE:
1068
1069 acpi_db_set_output_destination(ACPI_DB_REDIRECTABLE_OUTPUT);
1070 acpi_ut_subsystem_shutdown();
1071
1072 /*
1073 * TBD: [Restructure] Need some way to re-initialize without
1074 * re-creating the semaphores!
1075 */
1076
Lv Zheng086ab742015-10-19 10:25:42 +08001077 acpi_gbl_db_terminate_loop = TRUE;
Lv Zheng99575102015-10-19 10:25:20 +08001078 /* acpi_initialize (NULL); */
1079 break;
1080
1081 case CMD_THREADS:
1082
1083 acpi_db_create_execution_threads(acpi_gbl_db_args[1],
1084 acpi_gbl_db_args[2],
1085 acpi_gbl_db_args[3]);
1086 break;
1087
1088 /* Debug test commands. */
1089
1090 case CMD_PREDEFINED:
1091
1092 acpi_db_check_predefined_names();
1093 break;
1094
1095 case CMD_TEST:
1096
1097 acpi_db_execute_test(acpi_gbl_db_args[1]);
1098 break;
1099
1100 case CMD_UNLOAD:
1101
1102 acpi_db_unload_acpi_table(acpi_gbl_db_args[1]);
1103 break;
1104#endif
1105
1106 case CMD_EXIT:
1107 case CMD_QUIT:
1108
1109 if (op) {
1110 acpi_os_printf("Method execution terminated\n");
1111 return (AE_CTRL_TERMINATE);
1112 }
1113
1114 if (!acpi_gbl_db_output_to_file) {
1115 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
1116 }
1117#ifdef ACPI_APPLICATION
1118 acpi_db_close_debug_file();
1119#endif
Lv Zhengaf08f9c2015-10-19 10:25:32 +08001120 acpi_gbl_db_terminate_loop = TRUE;
Lv Zheng99575102015-10-19 10:25:20 +08001121 return (AE_CTRL_TERMINATE);
1122
1123 case CMD_NOT_FOUND:
1124 default:
1125
1126 acpi_os_printf("%s: unknown command\n", acpi_gbl_db_args[0]);
1127 return (AE_CTRL_TRUE);
1128 }
1129
1130 if (ACPI_SUCCESS(status)) {
1131 status = AE_CTRL_TRUE;
1132 }
1133
1134 return (status);
1135}
1136
1137/*******************************************************************************
1138 *
1139 * FUNCTION: acpi_db_execute_thread
1140 *
1141 * PARAMETERS: context - Not used
1142 *
1143 * RETURN: None
1144 *
1145 * DESCRIPTION: Debugger execute thread. Waits for a command line, then
1146 * simply dispatches it.
1147 *
1148 ******************************************************************************/
1149
1150void ACPI_SYSTEM_XFACE acpi_db_execute_thread(void *context)
1151{
1152 acpi_status status = AE_OK;
1153 acpi_status Mstatus;
1154
Lv Zheng086ab742015-10-19 10:25:42 +08001155 while (status != AE_CTRL_TERMINATE && !acpi_gbl_db_terminate_loop) {
Lv Zheng99575102015-10-19 10:25:20 +08001156 acpi_gbl_method_executing = FALSE;
1157 acpi_gbl_step_to_next_call = FALSE;
1158
1159 Mstatus = acpi_os_acquire_mutex(acpi_gbl_db_command_ready,
1160 ACPI_WAIT_FOREVER);
1161 if (ACPI_FAILURE(Mstatus)) {
1162 return;
1163 }
1164
1165 status =
1166 acpi_db_command_dispatch(acpi_gbl_db_line_buf, NULL, NULL);
1167
1168 acpi_os_release_mutex(acpi_gbl_db_command_complete);
1169 }
Lv Zhengaf08f9c2015-10-19 10:25:32 +08001170 acpi_gbl_db_threads_terminated = TRUE;
Lv Zheng99575102015-10-19 10:25:20 +08001171}
1172
1173/*******************************************************************************
1174 *
1175 * FUNCTION: acpi_db_single_thread
1176 *
1177 * PARAMETERS: None
1178 *
1179 * RETURN: None
1180 *
1181 * DESCRIPTION: Debugger execute thread. Waits for a command line, then
1182 * simply dispatches it.
1183 *
1184 ******************************************************************************/
1185
1186static void acpi_db_single_thread(void)
1187{
1188
1189 acpi_gbl_method_executing = FALSE;
1190 acpi_gbl_step_to_next_call = FALSE;
1191
1192 (void)acpi_db_command_dispatch(acpi_gbl_db_line_buf, NULL, NULL);
1193}
1194
1195/*******************************************************************************
1196 *
1197 * FUNCTION: acpi_db_user_commands
1198 *
1199 * PARAMETERS: prompt - User prompt (depends on mode)
1200 * op - Current executing parse op
1201 *
1202 * RETURN: None
1203 *
1204 * DESCRIPTION: Command line execution for the AML debugger. Commands are
1205 * matched and dispatched here.
1206 *
1207 ******************************************************************************/
1208
1209acpi_status acpi_db_user_commands(char prompt, union acpi_parse_object *op)
1210{
1211 acpi_status status = AE_OK;
1212
1213 acpi_os_printf("\n");
1214
1215 /* TBD: [Restructure] Need a separate command line buffer for step mode */
1216
Lv Zhengaf08f9c2015-10-19 10:25:32 +08001217 while (!acpi_gbl_db_terminate_loop) {
Lv Zheng99575102015-10-19 10:25:20 +08001218
1219 /* Force output to console until a command is entered */
1220
1221 acpi_db_set_output_destination(ACPI_DB_CONSOLE_OUTPUT);
1222
1223 /* Different prompt if method is executing */
1224
1225 if (!acpi_gbl_method_executing) {
1226 acpi_os_printf("%1c ", ACPI_DEBUGGER_COMMAND_PROMPT);
1227 } else {
1228 acpi_os_printf("%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT);
1229 }
1230
1231 /* Get the user input line */
1232
1233 status = acpi_os_get_line(acpi_gbl_db_line_buf,
1234 ACPI_DB_LINE_BUFFER_SIZE, NULL);
1235 if (ACPI_FAILURE(status)) {
1236 ACPI_EXCEPTION((AE_INFO, status,
1237 "While parsing command line"));
1238 return (status);
1239 }
1240
1241 /* Check for single or multithreaded debug */
1242
1243 if (acpi_gbl_debugger_configuration & DEBUGGER_MULTI_THREADED) {
1244 /*
1245 * Signal the debug thread that we have a command to execute,
1246 * and wait for the command to complete.
1247 */
1248 acpi_os_release_mutex(acpi_gbl_db_command_ready);
1249 if (ACPI_FAILURE(status)) {
1250 return (status);
1251 }
1252
1253 status =
1254 acpi_os_acquire_mutex(acpi_gbl_db_command_complete,
1255 ACPI_WAIT_FOREVER);
1256 if (ACPI_FAILURE(status)) {
1257 return (status);
1258 }
1259 } else {
1260 /* Just call to the command line interpreter */
1261
1262 acpi_db_single_thread();
1263 }
1264 }
1265
Lv Zheng99575102015-10-19 10:25:20 +08001266 return (status);
1267}