sys/contrib/dev/acpica/components/debugger/dbinput.c

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