Updated to support passing PE/COFF and LZMA decompress up via HOBS. Currently turned...
[mirror_edk2.git] / 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