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