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