drivers/acpi/acpica/dbinput.c

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