EmbeddedPkg/Ebl/Main.c

   1 /** @file
   2   Basic command line parser for EBL (Embedded Boot Loader)
   3
   4   Copyright (c) 2007, Intel Corporation<BR>
   5   Portions copyright (c) 2008-2009, Apple Inc. All rights reserved.
   6
   7   All rights reserved. This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15
  16 **/
  17
  18 #include "Ebl.h"
  19
  20 // Globals for command history processing
  21 INTN mCmdHistoryEnd     = -1;
  22 INTN mCmdHistoryStart   = -1;
  23 INTN mCmdHistoryCurrent = -1;
  24 CHAR8 mCmdHistory[MAX_CMD_HISTORY][MAX_CMD_LINE];
  25 CHAR8 *mCmdBlank = "";
  26
  27 // Globals to remember current screen geometry
  28 UINTN gScreenColumns;
  29 UINTN gScreenRows;
  30
  31 // Global to turn on/off breaking commands with prompts before they scroll the screen
  32 BOOLEAN gPageBreak = TRUE;
  33
  34 VOID
  35 RingBufferIncrement (
  36   IN  INTN  *Value
  37   )
  38 {
  39   *Value = *Value + 1;
  40
  41   if (*Value >= MAX_CMD_HISTORY) {
  42     *Value = 0;
  43   }
  44 }
  45
  46 VOID
  47 RingBufferDecrement (
  48   IN  INTN  *Value
  49   )
  50 {
  51   *Value = *Value - 1;
  52
  53   if (*Value < 0) {
  54     *Value = MAX_CMD_HISTORY - 1;
  55   }
  56 }
  57
  58 /**
  59   Save this command in the circular history buffer. Older commands are
  60   overwritten with newer commands.
  61
  62   @param  Cmd   Command line to archive the history of.
  63
  64   @return None
  65
  66 **/
  67 VOID
  68 SetCmdHistory (
  69   IN  CHAR8 *Cmd
  70   )
  71 {
  72   // Don't bother adding empty commands to the list
  73   if (AsciiStrLen(Cmd) != 0) {
  74
  75     // First entry
  76     if (mCmdHistoryStart == -1) {
  77       mCmdHistoryStart   = 0;
  78       mCmdHistoryEnd     = 0;
  79     } else {
  80       // Record the new command at the next index
  81       RingBufferIncrement(&mCmdHistoryStart);
  82
  83       // If the next index runs into the end index, shuffle end back by one
  84       if (mCmdHistoryStart == mCmdHistoryEnd) {
  85         RingBufferIncrement(&mCmdHistoryEnd);
  86       }
  87     }
  88
  89     // Copy the new command line into the ring buffer
  90     AsciiStrnCpy(&mCmdHistory[mCmdHistoryStart][0], Cmd, MAX_CMD_LINE);
  91   }
  92
  93   // Reset the command history for the next up arrow press
  94   mCmdHistoryCurrent = mCmdHistoryStart;
  95 }
  96
  97
  98 /**
  99   Retreave data from the Command History buffer. Direction maps into up arrow
 100   an down arrow on the command line
 101
 102   @param  Direction  Command forward or back
 103
 104   @return The Command history based on the Direction
 105
 106 **/
 107 CHAR8 *
 108 GetCmdHistory (
 109   IN UINT16   Direction
 110   )
 111 {
 112   CHAR8 *HistoricalCommand = NULL;
 113
 114   // No history yet?
 115   if (mCmdHistoryCurrent == -1) {
 116     HistoricalCommand = mCmdBlank;
 117     goto Exit;
 118   }
 119
 120   if (Direction == SCAN_UP) {
 121     HistoricalCommand = &mCmdHistory[mCmdHistoryCurrent][0];
 122
 123     // if we just echoed the last command, hang out there, don't wrap around
 124     if (mCmdHistoryCurrent == mCmdHistoryEnd) {
 125       goto Exit;
 126     }
 127
 128     // otherwise, back up by one
 129     RingBufferDecrement(&mCmdHistoryCurrent);
 130
 131   } else if (Direction == SCAN_DOWN) {
 132
 133     // if we last echoed the start command, put a blank prompt out
 134     if (mCmdHistoryCurrent == mCmdHistoryStart) {
 135       HistoricalCommand = mCmdBlank;
 136       goto Exit;
 137     }
 138
 139     // otherwise increment the current pointer and return that command
 140     RingBufferIncrement(&mCmdHistoryCurrent);
 141     RingBufferIncrement(&mCmdHistoryCurrent);
 142
 143     HistoricalCommand = &mCmdHistory[mCmdHistoryCurrent][0];
 144     RingBufferDecrement(&mCmdHistoryCurrent);
 145   }
 146
 147 Exit:
 148   return HistoricalCommand;
 149 }
 150
 151
 152 /**
 153   Parse the CmdLine and break it up into Argc (arg count) and Argv (array of
 154   pointers to each argument). The Cmd buffer is altered and seperators are
 155   converted to string terminators. This allows Argv to point into CmdLine.
 156   A CmdLine can support multiple commands. The next command in the command line
 157   is returned if it exists.
 158
 159   @param  CmdLine String to parse for a set of commands
 160   @param  Argc    Returns the number of arguments in the CmdLine current command
 161   @param  Argv    Argc pointers to each string in CmdLine
 162
 163   @return Next Command in the command line or NULL if non exists
 164 **/
 165 CHAR8 *
 166 ParseArguments (
 167   IN  CHAR8  *CmdLine,
 168   OUT UINTN  *Argc,
 169   OUT CHAR8  **Argv
 170   )
 171 {
 172   UINTN   Arg;
 173   CHAR8   *Char;
 174   BOOLEAN LookingForArg;
 175   BOOLEAN InQuote;
 176
 177   *Argc = 0;
 178   if (AsciiStrLen (CmdLine) == 0) {
 179     return NULL;
 180   }
 181
 182   // Walk a single command line. A CMD_SEPERATOR allows mult commands on a single line
 183   InQuote       = FALSE;
 184   LookingForArg = TRUE;
 185   for (Char = CmdLine, Arg = 0; *Char != '\0'; Char++) {
 186     if (!InQuote && *Char == CMD_SEPERATOR) {
 187       break;
 188     }
 189
 190     // Perform any text coversion here
 191     if (*Char == '\t') {
 192       // TAB to space
 193       *Char = ' ';
 194     }
 195
 196     if (LookingForArg) {
 197       // Look for the beging of an Argv[] entry
 198       if (*Char == '"') {
 199         Argv[Arg++] = ++Char;
 200         LookingForArg = FALSE;
 201         InQuote = TRUE;
 202       } else if (*Char != ' ') {
 203         Argv[Arg++] = Char;
 204         LookingForArg = FALSE;
 205       }
 206     } else {
 207       // Looking for the terminator of an Argv[] entry
 208       if ((InQuote && (*Char == '"')) || (!InQuote && (*Char == ' '))) {
 209         *Char = '\0';
 210         LookingForArg = TRUE;
 211       }
 212     }
 213   }
 214
 215   *Argc = Arg;
 216
 217   if (*Char == CMD_SEPERATOR) {
 218     // Replace the command delimeter with null and return pointer to next command line
 219     *Char = '\0';
 220     return ++Char;
 221   }
 222
 223   return NULL;
 224 }
 225
 226
 227 /**
 228   Return a keypress or optionally timeout if a timeout value was passed in.
 229   An optional callback funciton is called evey second when waiting for a
 230   timeout.
 231
 232   @param  Key           EFI Key information returned
 233   @param  TimeoutInSec  Number of seconds to wait to timeout
 234   @param  CallBack      Callback called every second during the timeout wait
 235
 236   @return EFI_SUCCESS  Key was returned
 237   @return EFI_TIMEOUT  If the TimoutInSec expired
 238
 239 **/
 240 EFI_STATUS
 241 EblGetCharKey (
 242   IN OUT EFI_INPUT_KEY            *Key,
 243   IN     UINTN                    TimeoutInSec,
 244   IN     EBL_GET_CHAR_CALL_BACK   CallBack   OPTIONAL
 245   )
 246 {
 247   EFI_STATUS    Status;
 248   UINTN         WaitCount;
 249   UINTN         WaitIndex;
 250   EFI_EVENT     WaitList[2];
 251
 252   WaitCount   = 1;
 253   WaitList[0] = gST->ConIn->WaitForKey;
 254   if (TimeoutInSec != 0) {
 255     // Create a time event for 1 sec duration if we have a timeout
 256     gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[1]);
 257     gBS->SetTimer (WaitList[1], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);
 258     WaitCount++;
 259   }
 260
 261   for (;;) {
 262     Status = gBS->WaitForEvent (WaitCount, WaitList, &WaitIndex);
 263     ASSERT_EFI_ERROR (Status);
 264
 265     switch (WaitIndex) {
 266     case 0:
 267       // Key event signaled
 268       Status = gST->ConIn->ReadKeyStroke (gST->ConIn, Key);
 269       if (!EFI_ERROR (Status)) {
 270         if (WaitCount == 2) {
 271           gBS->CloseEvent (WaitList[1]);
 272         }
 273         return EFI_SUCCESS;
 274       }
 275       break;
 276
 277     case 1:
 278       // Periodic 1 sec timer signaled
 279       TimeoutInSec--;
 280       if (CallBack != NULL) {
 281         // Call the users callback function if registered
 282         CallBack (TimeoutInSec);
 283       }
 284       if (TimeoutInSec == 0) {
 285         gBS->CloseEvent (WaitList[1]);
 286         return EFI_TIMEOUT;
 287       }
 288       break;
 289     default:
 290       ASSERT (FALSE);
 291     }
 292   }
 293 }
 294
 295
 296 /**
 297   This routine is used prevent command output data from scrolling off the end
 298   of the screen. The global gPageBreak is used to turn on or off this feature.
 299   If the CurrentRow is near the end of the screen pause and print out a prompt
 300   If the use hits Q to quit return TRUE else for any other key return FALSE.
 301   PrefixNewline is used to figure out if a newline is needed before the prompt
 302   string. This depends on the last print done before calling this function.
 303   CurrentRow is updated by one on a call or set back to zero if a prompt is
 304   needed.
 305
 306   @param  CurrentRow  Used to figure out if its the end of the page and updated
 307   @param  PrefixNewline  Did previous print issue a newline
 308
 309   @return TRUE if Q was hit to quit, FALSE in all other cases.
 310
 311 **/
 312 BOOLEAN
 313 EblAnyKeyToContinueQtoQuit (
 314   IN  UINTN   *CurrentRow,
 315   IN  BOOLEAN PrefixNewline
 316   )
 317 {
 318   EFI_INPUT_KEY     InputKey;
 319
 320   if (!gPageBreak) {
 321     // global disable for this feature
 322     return FALSE;
 323   }
 324
 325   if (*CurrentRow >= (gScreenRows - 2)) {
 326     if (PrefixNewline) {
 327       AsciiPrint ("\n");
 328     }
 329     AsciiPrint ("Any key to continue (Q to quit): ");
 330     EblGetCharKey (&InputKey, 0, NULL);
 331     AsciiPrint ("\n");
 332
 333     // Time to promt to stop the screen. We have to leave space for the prompt string
 334     *CurrentRow = 0;
 335     if (InputKey.UnicodeChar == 'Q' || InputKey.UnicodeChar == 'q') {
 336       return TRUE;
 337     }
 338   } else {
 339     *CurrentRow += 1;
 340   }
 341
 342   return FALSE;
 343 }
 344
 345
 346 /**
 347   Set the text color of the EFI Console. If a zero is passed in reset to
 348   default text/background color.
 349
 350   @param  Attribute   For text and background color
 351
 352 **/
 353 VOID
 354 EblSetTextColor (
 355   UINTN   Attribute
 356   )
 357 {
 358   if (Attribute == 0) {
 359     // Set the text color back to default
 360     Attribute = (UINTN)PcdGet32 (PcdEmbeddedDefaultTextColor);
 361   }
 362
 363   gST->ConOut->SetAttribute (gST->ConOut, Attribute);
 364 }
 365
 366
 367 /**
 368   Collect the keyboard input for a cmd line. Carage Return, New Line, or ESC
 369   terminates the command line. You can edit the command line via left arrow,
 370   delete and backspace and they all back up and erase the command line.
 371   No edit of commnad line is possible without deletion at this time!
 372   The up arrow and down arrow fill Cmd with information from the history
 373   buffer.
 374
 375   @param  Cmd         Command line to return
 376   @param  CmdMaxSize  Maximum size of Cmd
 377
 378   @return The Status of EblGetCharKey()
 379
 380 **/
 381 EFI_STATUS
 382 GetCmd (
 383   IN OUT  CHAR8   *Cmd,
 384   IN      UINTN   CmdMaxSize
 385   )
 386 {
 387   EFI_STATUS    Status;
 388   UINTN         Index;
 389   UINTN         Index2;
 390   CHAR8         Char;
 391   CHAR8         *History;
 392   EFI_INPUT_KEY Key;
 393
 394   for (Index = 0; Index < CmdMaxSize - 1;) {
 395     Status = EblGetCharKey (&Key, 0, NULL);
 396     if (EFI_ERROR (Status)) {
 397       Cmd[Index] = '\0';
 398       AsciiPrint ("\n");
 399       return Status;
 400     }
 401
 402     Char = (CHAR8)Key.UnicodeChar;
 403     if ((Char == '\n') || (Char == '\r') || (Char == 0x7f)) {
 404       Cmd[Index] = '\0';
 405       if (FixedPcdGetBool(PcdEmbeddedShellCharacterEcho) == TRUE) {
 406         AsciiPrint ("\n\r");
 407       }
 408       return EFI_SUCCESS;
 409     } else if ((Char == '\b') || (Key.ScanCode == SCAN_LEFT) || (Key.ScanCode == SCAN_DELETE)){
 410       if (Index != 0) {
 411         Index--;
 412         //
 413         // Update the display
 414         //
 415         AsciiPrint ("\b \b");
 416       }
 417     } else if ((Key.ScanCode == SCAN_UP) || Key.ScanCode == SCAN_DOWN) {
 418       History = GetCmdHistory (Key.ScanCode);
 419       //
 420       // Clear display line
 421       //
 422       for (Index2 = 0; Index2 < Index; Index2++) {
 423         AsciiPrint ("\b \b");
 424       }
 425       AsciiPrint (History);
 426       Index = AsciiStrLen (History);
 427       AsciiStrnCpy (Cmd, History, CmdMaxSize);
 428     } else {
 429       Cmd[Index++] = Char;
 430       if (FixedPcdGetBool(PcdEmbeddedShellCharacterEcho) == TRUE) {
 431         AsciiPrint ("%c", Char);
 432       }
 433     }
 434   }
 435
 436   return EFI_SUCCESS;
 437 }
 438
 439
 440 /**
 441   Print the boot up banner for the EBL.
 442 **/
 443 VOID
 444 EblPrintStartupBanner (
 445   VOID
 446   )
 447 {
 448   AsciiPrint ("Embedded Boot Loader (");
 449   EblSetTextColor (EFI_YELLOW);
 450   AsciiPrint ("EBL");
 451   EblSetTextColor (0);
 452   AsciiPrint (") prototype. Built at %a on %a\n",__TIME__, __DATE__);
 453   AsciiPrint ("THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN 'AS IS' BASIS,\nWITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\n");
 454   AsciiPrint ("Please send feedback to dev@edk2.tianocore.org\n");
 455 }
 456
 457
 458 /**
 459   Print the prompt for the EBL.
 460 **/
 461 VOID
 462 EblPrompt (
 463   VOID
 464   )
 465 {
 466   EblSetTextColor (EFI_YELLOW);
 467   AsciiPrint ((CHAR8 *)PcdGetPtr (PcdEmbeddedPrompt));
 468   EblSetTextColor (0);
 469   AsciiPrint ("%a", ">");
 470 }
 471
 472
 473
 474 /**
 475   Parse a command line and execute the commands. The ; seperator allows
 476   multiple commands for each command line. Stop processing if one of the
 477   commands returns an error.
 478
 479   @param  CmdLine          Command Line to process.
 480   @param  MaxCmdLineSize   MaxSize of the Command line
 481
 482   @return EFI status of the Command
 483
 484 **/
 485 EFI_STATUS
 486 ProcessCmdLine (
 487   IN CHAR8      *CmdLine,
 488   IN UINTN      MaxCmdLineSize
 489   )
 490 {
 491   EFI_STATUS          Status;
 492   EBL_COMMAND_TABLE   *Cmd;
 493   CHAR8               *Ptr;
 494   UINTN               Argc;
 495   CHAR8               *Argv[MAX_ARGS];
 496
 497   // Parse the command line. The loop processes commands seperated by ;
 498   for (Ptr = CmdLine, Status = EFI_SUCCESS; Ptr != NULL;) {
 499     Ptr = ParseArguments (Ptr, &Argc, Argv);
 500     if (Argc != 0) {
 501       Cmd = EblGetCommand (Argv[0]);
 502       if (Cmd != NULL) {
 503         // Execute the Command!
 504         Status = Cmd->Command (Argc, Argv);
 505         if (Status == EFI_ABORTED) {
 506           // exit command so lets exit
 507           break;
 508         } else if (Status == EFI_TIMEOUT) {
 509           // pause command got imput so don't process any more cmd on this cmd line
 510           break;
 511         } else if (EFI_ERROR (Status)) {
 512           AsciiPrint ("%a returned %r error\n", Cmd->Name, Status);
 513           // if any command fails stop processing CmdLine
 514           break;
 515         }
 516       }
 517     }
 518   }
 519
 520   return Status;
 521 }
 522
 523
 524
 525 /**
 526   Embedded Boot Loader (EBL) - A simple EFI command line application for embedded
 527   devices. PcdEmbeddedAutomaticBootCommand is a complied in commnad line that
 528   gets executed automatically. The ; seperator allows multiple commands
 529   for each command line.
 530
 531   @param  ImageHandle   EFI ImageHandle for this application.
 532   @param  SystemTable   EFI system table
 533
 534   @return EFI status of the applicaiton
 535
 536 **/
 537 EFI_STATUS
 538 EFIAPI
 539 EdkBootLoaderEntry (
 540   IN EFI_HANDLE                            ImageHandle,
 541   IN EFI_SYSTEM_TABLE                      *SystemTable
 542   )
 543 {
 544   EFI_STATUS  Status;
 545   CHAR8       CmdLine[MAX_CMD_LINE];
 546   CHAR16      *CommandLineVariable = NULL;
 547   CHAR16      *CommandLineVariableName = L"default-cmdline";
 548   UINTN       CommandLineVariableSize = 0;
 549   EFI_GUID    VendorGuid;
 550
 551   // Initialize tables of commnads
 552   EblInitializeCmdTable ();
 553   EblInitializeDeviceCmd ();
 554   EblInitializemdHwDebugCmds ();
 555   EblInitializemdHwIoDebugCmds ();
 556   EblInitializeDirCmd ();
 557   EblInitializeHobCmd ();
 558   EblInitializeScriptCmd ();
 559   EblInitializeExternalCmd ();
 560   EblInitializeNetworkCmd();
 561
 562   if (FeaturePcdGet (PcdEmbeddedMacBoot)) {
 563     // A MAC will boot in graphics mode, so turn it back to text here
 564     // This protocol was removed from edk2. It is only an edk thing. We need to make our own copy.
 565     // DisableQuietBoot ();
 566
 567     // Enable the biggest output screen size possible
 568     gST->ConOut->SetMode (gST->ConOut, (UINTN)gST->ConOut->Mode->MaxMode - 1);
 569
 570     // Disable the 5 minute EFI watchdog time so we don't get automatically reset
 571     gBS->SetWatchdogTimer (0, 0, 0, NULL);
 572   }
 573
 574   // Save current screen mode
 575   gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &gScreenColumns, &gScreenRows);
 576
 577   EblPrintStartupBanner ();
 578
 579   // Parse command line and handle commands seperated by ;
 580   // The loop prints the prompt gets user input and saves history
 581
 582   // Look for a variable with a default command line, otherwise use the Pcd
 583   ZeroMem(&VendorGuid, sizeof(EFI_GUID));
 584
 585   Status = gRT->GetVariable(CommandLineVariableName, &VendorGuid, NULL, &CommandLineVariableSize, CommandLineVariable);
 586   if (Status == EFI_BUFFER_TOO_SMALL) {
 587     CommandLineVariable = AllocatePool(CommandLineVariableSize);
 588
 589     Status = gRT->GetVariable(CommandLineVariableName, &VendorGuid, NULL, &CommandLineVariableSize, CommandLineVariable);
 590     if (!EFI_ERROR(Status)) {
 591       UnicodeStrToAsciiStr(CommandLineVariable, CmdLine);
 592     }
 593
 594     FreePool(CommandLineVariable);
 595   }
 596
 597   if (EFI_ERROR(Status)) {
 598     AsciiStrCpy (CmdLine, (CHAR8 *)PcdGetPtr (PcdEmbeddedAutomaticBootCommand));
 599   }
 600
 601   for (;;) {
 602     Status = ProcessCmdLine (CmdLine, MAX_CMD_LINE);
 603     if (Status == EFI_ABORTED) {
 604       // if a command returns EFI_ABORTED then exit the EBL
 605       EblShutdownExternalCmdTable ();
 606       return EFI_SUCCESS;
 607     }
 608
 609     // get the command line from the user
 610     EblPrompt ();
 611     GetCmd (CmdLine, MAX_CMD_LINE);
 612     SetCmdHistory (CmdLine);
 613   }
 614 }
 615
 616