]> git.proxmox.com Git - mirror_edk2.git/blob - ShellPkg/Application/Shell/ConsoleLogger.c
projects / mirror_edk2.git / blob
? search:


074e0cf04654105c8fbe1ea74285109fcef203b3
[mirror_edk2.git] / ShellPkg / Application / Shell / ConsoleLogger.c
1 /** @file
2 Provides interface to shell console logger.
3
4 (C) Copyright 2013 Hewlett-Packard Development Company, L.P.<BR>
5 Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
6 (C) Copyright 2016 Hewlett-Packard Development Company, L.P.<BR>
7 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 #include "Shell.h"
17
18 /**
19 Install our intermediate ConOut into the system table to
20 keep a log of all the info that is displayed to the user.
21
22 @param[in] ScreensToSave Sets how many screen-worths of data to save.
23 @param[out] ConsoleInfo The object to pass into later functions.
24
25 @retval EFI_SUCCESS The operation was successful.
26 @return other The operation failed.
27
28 @sa ConsoleLoggerResetBuffers
29 @sa InstallProtocolInterface
30 **/
31 EFI_STATUS
32 ConsoleLoggerInstall(
33 IN CONST UINTN ScreensToSave,
34 OUT CONSOLE_LOGGER_PRIVATE_DATA **ConsoleInfo
35 )
36 {
37 EFI_STATUS Status;
38 ASSERT(ConsoleInfo != NULL);
39
40 (*ConsoleInfo) = AllocateZeroPool(sizeof(CONSOLE_LOGGER_PRIVATE_DATA));
41 if ((*ConsoleInfo) == NULL) {
42 return (EFI_OUT_OF_RESOURCES);
43 }
44
45 (*ConsoleInfo)->Signature = CONSOLE_LOGGER_PRIVATE_DATA_SIGNATURE;
46 (*ConsoleInfo)->OldConOut = gST->ConOut;
47 (*ConsoleInfo)->OldConHandle = gST->ConsoleOutHandle;
48 (*ConsoleInfo)->Buffer = NULL;
49 (*ConsoleInfo)->BufferSize = 0;
50 (*ConsoleInfo)->OriginalStartRow = 0;
51 (*ConsoleInfo)->CurrentStartRow = 0;
52 (*ConsoleInfo)->RowsPerScreen = 0;
53 (*ConsoleInfo)->ColsPerScreen = 0;
54 (*ConsoleInfo)->Attributes = NULL;
55 (*ConsoleInfo)->AttribSize = 0;
56 (*ConsoleInfo)->ScreenCount = ScreensToSave;
57 (*ConsoleInfo)->HistoryMode.MaxMode = 1;
58 (*ConsoleInfo)->HistoryMode.Mode = 0;
59 (*ConsoleInfo)->HistoryMode.Attribute = 0;
60 (*ConsoleInfo)->HistoryMode.CursorColumn = 0;
61 (*ConsoleInfo)->HistoryMode.CursorRow = 0;
62 (*ConsoleInfo)->HistoryMode.CursorVisible = FALSE;
63 (*ConsoleInfo)->OurConOut.Reset = ConsoleLoggerReset;
64 (*ConsoleInfo)->OurConOut.OutputString = ConsoleLoggerOutputString;
65 (*ConsoleInfo)->OurConOut.TestString = ConsoleLoggerTestString;
66 (*ConsoleInfo)->OurConOut.QueryMode = ConsoleLoggerQueryMode;
67 (*ConsoleInfo)->OurConOut.SetMode = ConsoleLoggerSetMode;
68 (*ConsoleInfo)->OurConOut.SetAttribute = ConsoleLoggerSetAttribute;
69 (*ConsoleInfo)->OurConOut.ClearScreen = ConsoleLoggerClearScreen;
70 (*ConsoleInfo)->OurConOut.SetCursorPosition = ConsoleLoggerSetCursorPosition;
71 (*ConsoleInfo)->OurConOut.EnableCursor = ConsoleLoggerEnableCursor;
72 (*ConsoleInfo)->OurConOut.Mode = gST->ConOut->Mode;
73 (*ConsoleInfo)->Enabled = TRUE;
74
75 Status = ConsoleLoggerResetBuffers(*ConsoleInfo);
76 if (EFI_ERROR(Status)) {
77 SHELL_FREE_NON_NULL((*ConsoleInfo));
78 *ConsoleInfo = NULL;
79 return (Status);
80 }
81
82 Status = gBS->InstallProtocolInterface(&gImageHandle, &gEfiSimpleTextOutProtocolGuid, EFI_NATIVE_INTERFACE, (VOID*)&((*ConsoleInfo)->OurConOut));
83 if (EFI_ERROR(Status)) {
84 SHELL_FREE_NON_NULL((*ConsoleInfo)->Buffer);
85 SHELL_FREE_NON_NULL((*ConsoleInfo)->Attributes);
86 SHELL_FREE_NON_NULL((*ConsoleInfo));
87 *ConsoleInfo = NULL;
88 return (Status);
89 }
90
91 gST->ConsoleOutHandle = gImageHandle;
92 gST->ConOut = &(*ConsoleInfo)->OurConOut;
93
94 //
95 // Update the CRC32 in the EFI System Table header
96 //
97 gST->Hdr.CRC32 = 0;
98 gBS->CalculateCrc32 (
99 (UINT8 *)&gST->Hdr,
100 gST->Hdr.HeaderSize,
101 &gST->Hdr.CRC32
102 );
103 return (Status);
104 }
105
106 /**
107 Return the system to the state it was before InstallConsoleLogger
108 was installed.
109
110 @param[in] ConsoleInfo The object from the install function.
111
112 @retval EFI_SUCCESS The operation was successful
113 @return other The operation failed. This was from UninstallProtocolInterface.
114 **/
115 EFI_STATUS
116 ConsoleLoggerUninstall(
117 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
118 )
119 {
120 ASSERT(ConsoleInfo != NULL);
121 ASSERT(ConsoleInfo->OldConOut != NULL);
122
123 if (ConsoleInfo->Buffer != NULL) {
124 FreePool(ConsoleInfo->Buffer);
125 DEBUG_CODE(ConsoleInfo->Buffer = NULL;);
126 DEBUG_CODE(ConsoleInfo->BufferSize = 0;);
127 }
128 if (ConsoleInfo->Attributes != NULL) {
129 FreePool(ConsoleInfo->Attributes);
130 DEBUG_CODE(ConsoleInfo->Attributes = NULL;);
131 DEBUG_CODE(ConsoleInfo->AttribSize = 0;);
132 }
133
134 gST->ConsoleOutHandle = ConsoleInfo->OldConHandle;
135 gST->ConOut = ConsoleInfo->OldConOut;
136
137 //
138 // Update the CRC32 in the EFI System Table header
139 //
140 gST->Hdr.CRC32 = 0;
141 gBS->CalculateCrc32 (
142 (UINT8 *)&gST->Hdr,
143 gST->Hdr.HeaderSize,
144 &gST->Hdr.CRC32
145 );
146
147 return (gBS->UninstallProtocolInterface(gImageHandle, &gEfiSimpleTextOutProtocolGuid, (VOID*)&ConsoleInfo->OurConOut));
148 }
149
150 /**
151 Displays previously logged output back to the screen.
152
153 This will scroll the screen forwards and backwards through the log of previous
154 output. If Rows is 0 then the size of 1/2 the screen will be scrolled. If Rows
155 is (UINTN)(-1) then the size of the screen will be scrolled.
156
157 @param[in] Forward If TRUE then the log will be displayed forwards (scroll to newer).
158 If FALSE then the log will be displayed backwards (scroll to older).
159 @param[in] Rows Determines how many rows the log should scroll.
160 @param[in] ConsoleInfo The pointer to the instance of the console logger information.
161 **/
162 EFI_STATUS
163 ConsoleLoggerDisplayHistory(
164 IN CONST BOOLEAN Forward,
165 IN CONST UINTN Rows,
166 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
167 )
168 {
169 UINTN RowChange;
170
171 ASSERT(ConsoleInfo != NULL);
172
173 //
174 // Calculate the row number change
175 //
176 switch (Rows) {
177 case ((UINTN)(-1)):
178 RowChange = ConsoleInfo->RowsPerScreen;
179 break;
180 case (0):
181 RowChange = ConsoleInfo->RowsPerScreen / 2;
182 break;
183 default:
184 RowChange = Rows;
185 break;
186 }
187
188 //
189 // Do the math for direction
190 //
191 if (Forward) {
192 if ((ConsoleInfo->OriginalStartRow - ConsoleInfo->CurrentStartRow) < RowChange) {
193 RowChange = ConsoleInfo->OriginalStartRow - ConsoleInfo->CurrentStartRow;
194 }
195 } else {
196 if (ConsoleInfo->CurrentStartRow < RowChange) {
197 RowChange = ConsoleInfo->CurrentStartRow;
198 }
199 }
200
201 //
202 // If we are already at one end or the other
203 //
204 if (RowChange == 0) {
205 return (EFI_SUCCESS);
206 }
207
208 //
209 // Clear the screen
210 //
211 ConsoleInfo->OldConOut->ClearScreen(ConsoleInfo->OldConOut);
212
213 //
214 // Set the new start row
215 //
216 if (Forward) {
217 ConsoleInfo->CurrentStartRow += RowChange;
218 } else {
219 ConsoleInfo->CurrentStartRow -= RowChange;
220 }
221
222 //
223 // Change the screen
224 //
225 return (UpdateDisplayFromHistory(ConsoleInfo));
226 }
227
228 /**
229 Function to return to normal output whent he scrolling is complete.
230 @param[in] ConsoleInfo The pointer to the instance of the console logger information.
231
232 @retval EFI_SUCCESS The operation was successful.
233 @return other The operation failed. See UpdateDisplayFromHistory.
234
235 @sa UpdateDisplayFromHistory
236 **/
237 EFI_STATUS
238 ConsoleLoggerStopHistory(
239 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
240 )
241 {
242 ASSERT(ConsoleInfo != NULL);
243 if (ConsoleInfo->CurrentStartRow == ConsoleInfo->OriginalStartRow) {
244 return (EFI_SUCCESS);
245 }
246
247 //
248 // Clear the screen
249 //
250 ConsoleInfo->OldConOut->ClearScreen(ConsoleInfo->OldConOut);
251
252 ConsoleInfo->CurrentStartRow = ConsoleInfo->OriginalStartRow;
253 return (UpdateDisplayFromHistory(ConsoleInfo));
254 }
255
256 /**
257 Updates the hidden ConOut to be displaying the correct stuff.
258 @param[in] ConsoleInfo The pointer to the instance of the console logger information.
259
260 @retval EFI_SUCCESS The operation was successful.
261 @return other The operation failed.
262 **/
263 EFI_STATUS
264 UpdateDisplayFromHistory(
265 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
266 )
267 {
268 EFI_STATUS Status;
269 EFI_STATUS RetVal;
270 CHAR16 *Screen;
271 INT32 *Attributes;
272 UINTN CurrentRow;
273 CHAR16 TempCharHolder;
274 UINTN Column;
275 INT32 CurrentAttrib;
276 UINTN CurrentColumn;
277 CHAR16 *StringSegment;
278 CHAR16 *StringSegmentEnd;
279 CHAR16 StringSegmentEndChar;
280 INT32 OrigAttribute;
281
282 ASSERT(ConsoleInfo != NULL);
283 TempCharHolder = CHAR_NULL;
284 RetVal = EFI_SUCCESS;
285 OrigAttribute = ConsoleInfo->OldConOut->Mode->Attribute;
286
287 //
288 // Disable cursor visibility and move it to the top left corner
289 //
290 ConsoleInfo->OldConOut->EnableCursor (ConsoleInfo->OldConOut, FALSE);
291 ConsoleInfo->OldConOut->SetCursorPosition (ConsoleInfo->OldConOut, 0, 0);
292
293 Screen = &ConsoleInfo->Buffer[(ConsoleInfo->ColsPerScreen + 2) * ConsoleInfo->CurrentStartRow];
294 Attributes = &ConsoleInfo->Attributes[ConsoleInfo->ColsPerScreen * ConsoleInfo->CurrentStartRow];
295 for ( CurrentRow = 0
296 ; CurrentRow < ConsoleInfo->RowsPerScreen
297 ; CurrentRow++
298 , Screen += (ConsoleInfo->ColsPerScreen + 2)
299 , Attributes += ConsoleInfo->ColsPerScreen
300 ){
301 //
302 // dont use the last char - prevents screen scroll
303 //
304 if (CurrentRow == (ConsoleInfo->RowsPerScreen-1)){
305 TempCharHolder = Screen[ConsoleInfo->ColsPerScreen - 1];
306 Screen[ConsoleInfo->ColsPerScreen - 1] = CHAR_NULL;
307 }
308
309 for ( Column = 0
310 ; Column < ConsoleInfo->ColsPerScreen
311 ; Column++
312 ){
313 if (Screen[Column] != CHAR_NULL) {
314 CurrentAttrib = Attributes[Column];
315 CurrentColumn = Column;
316 StringSegment = &Screen[Column];
317
318 //
319 // Find the first char with a different arrribute and make that temporarily NULL
320 // so we can do fewer printout statements. (later) restore that one and we will
321 // start at that collumn on the next loop.
322 //
323 StringSegmentEndChar = CHAR_NULL;
324 for ( StringSegmentEnd = StringSegment
325 ; *StringSegmentEnd != CHAR_NULL
326 ; StringSegmentEnd++
327 , Column++
328 ){
329 if (Attributes[Column] != CurrentAttrib) {
330 StringSegmentEndChar = *StringSegmentEnd;
331 *StringSegmentEnd = CHAR_NULL;
332 break;
333 }
334 } // StringSegmentEnd loop
335
336 //
337 // Now write out as much as had the same Attributes
338 //
339
340 ConsoleInfo->OldConOut->SetAttribute(ConsoleInfo->OldConOut, CurrentAttrib);
341 ConsoleInfo->OldConOut->SetCursorPosition(ConsoleInfo->OldConOut, CurrentColumn, CurrentRow);
342 Status = ConsoleInfo->OldConOut->OutputString(ConsoleInfo->OldConOut, StringSegment);
343
344 if (EFI_ERROR(Status)) {
345 ASSERT(FALSE);
346 RetVal = Status;
347 }
348
349 //
350 // If we found a change in attribute put the character back and decrement the column
351 // so when it increments it will point at that character and we will start printing
352 // a segment with that new attribute
353 //
354 if (StringSegmentEndChar != CHAR_NULL) {
355 *StringSegmentEnd = StringSegmentEndChar;
356 StringSegmentEndChar = CHAR_NULL;
357 Column--;
358 }
359 }
360 } // column for loop
361
362 //
363 // If we removed the last char and this was the last row put it back
364 //
365 if (TempCharHolder != CHAR_NULL) {
366 Screen[ConsoleInfo->ColsPerScreen - 1] = TempCharHolder;
367 TempCharHolder = CHAR_NULL;
368 }
369 } // row for loop
370
371 //
372 // If we are setting the screen back to original turn on the cursor and make it visible
373 // and set the attributes back to what they were
374 //
375 if (ConsoleInfo->CurrentStartRow == ConsoleInfo->OriginalStartRow) {
376 ConsoleInfo->OldConOut->SetAttribute (
377 ConsoleInfo->OldConOut,
378 ConsoleInfo->HistoryMode.Attribute
379 );
380 ConsoleInfo->OldConOut->SetCursorPosition (
381 ConsoleInfo->OldConOut,
382 ConsoleInfo->HistoryMode.CursorColumn,
383 ConsoleInfo->HistoryMode.CursorRow - ConsoleInfo->OriginalStartRow
384 );
385
386 Status = ConsoleInfo->OldConOut->EnableCursor (
387 ConsoleInfo->OldConOut,
388 ConsoleInfo->HistoryMode.CursorVisible
389 );
390 if (EFI_ERROR (Status)) {
391 RetVal = Status;
392 }
393 } else {
394 ConsoleInfo->OldConOut->SetAttribute (
395 ConsoleInfo->OldConOut,
396 OrigAttribute
397 );
398 }
399
400 return (RetVal);
401 }
402
403 /**
404 Reset the text output device hardware and optionaly run diagnostics
405
406 @param This pointer to EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
407 @param ExtendedVerification Indicates that a more extensive test may be performed
408
409 @retval EFI_SUCCESS The text output device was reset.
410 @retval EFI_DEVICE_ERROR The text output device is not functioning correctly and
411 could not be reset.
412 **/
413 EFI_STATUS
414 EFIAPI
415 ConsoleLoggerReset (
416 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
417 IN BOOLEAN ExtendedVerification
418 )
419 {
420 EFI_STATUS Status;
421 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
422 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
423
424 //
425 // Forward the request to the original ConOut
426 //
427 Status = ConsoleInfo->OldConOut->Reset (ConsoleInfo->OldConOut, ExtendedVerification);
428
429 //
430 // Check that the buffers are still correct for logging
431 //
432 if (!EFI_ERROR (Status)) {
433 ConsoleLoggerResetBuffers(ConsoleInfo);
434 if (ExtendedVerification) {
435 ConsoleInfo->OriginalStartRow = 0;
436 ConsoleInfo->CurrentStartRow = 0;
437 }
438 }
439
440 return Status;
441 }
442
443 /**
444 Appends a string to the history buffer. If the buffer is full then the oldest
445 information in the buffer will be dropped. Information is added in a line by
446 line manner such that an empty line takes up just as much space as a full line.
447
448 @param[in] String String pointer to add.
449 @param[in] ConsoleInfo The pointer to the instance of the console logger information.
450 **/
451 EFI_STATUS
452 AppendStringToHistory(
453 IN CONST CHAR16 *String,
454 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
455 )
456 {
457 CONST CHAR16 *Walker;
458 UINTN CopySize;
459 UINTN PrintIndex;
460 UINTN Index;
461
462 ASSERT(ConsoleInfo != NULL);
463
464 for ( Walker = String
465 ; Walker != NULL && *Walker != CHAR_NULL
466 ; Walker++
467 ){
468 switch (*Walker) {
469 case (CHAR_BACKSPACE):
470 if (ConsoleInfo->HistoryMode.CursorColumn > 0) {
471 ConsoleInfo->HistoryMode.CursorColumn--;
472 }
473 break;
474 case (CHAR_LINEFEED):
475 if (ConsoleInfo->HistoryMode.CursorRow >= (INT32)((ConsoleInfo->RowsPerScreen * ConsoleInfo->ScreenCount)-1)) {
476 //
477 // Should never be bigger
478 //
479 ASSERT(ConsoleInfo->HistoryMode.CursorRow == (INT32)((ConsoleInfo->RowsPerScreen * ConsoleInfo->ScreenCount)-1));
480
481 //
482 // scroll history attributes 'up' 1 row and set the last row to default attribute
483 //
484 CopySize = ConsoleInfo->ColsPerScreen
485 * ((ConsoleInfo->RowsPerScreen * ConsoleInfo->ScreenCount) - 1)
486 * sizeof(ConsoleInfo->Attributes[0]);
487 ASSERT(CopySize < ConsoleInfo->AttribSize);
488 CopyMem(
489 ConsoleInfo->Attributes,
490 ConsoleInfo->Attributes + ConsoleInfo->ColsPerScreen,
491 CopySize
492 );
493
494 for ( Index = 0
495 ; Index < ConsoleInfo->ColsPerScreen
496 ; Index++
497 ){
498 *(ConsoleInfo->Attributes + (CopySize/sizeof(ConsoleInfo->Attributes[0])) + Index) = ConsoleInfo->HistoryMode.Attribute;
499 }
500
501 //
502 // scroll history buffer 'up' 1 row and set the last row to spaces (L' ')
503 //
504 CopySize = (ConsoleInfo->ColsPerScreen + 2)
505 * ((ConsoleInfo->RowsPerScreen * ConsoleInfo->ScreenCount) - 1)
506 * sizeof(ConsoleInfo->Buffer[0]);
507 ASSERT(CopySize < ConsoleInfo->BufferSize);
508 CopyMem(
509 ConsoleInfo->Buffer,
510 ConsoleInfo->Buffer + (ConsoleInfo->ColsPerScreen + 2),
511 CopySize
512 );
513
514 //
515 // Set that last row of chars to spaces
516 //
517 SetMem16(((UINT8*)ConsoleInfo->Buffer)+CopySize, ConsoleInfo->ColsPerScreen*sizeof(CHAR16), L' ');
518 } else {
519 //
520 // we are not on the last row
521 //
522
523 //
524 // We should not be scrolling history
525 //
526 ASSERT (ConsoleInfo->OriginalStartRow == ConsoleInfo->CurrentStartRow);
527 //
528 // are we at the end of a row?
529 //
530 if (ConsoleInfo->HistoryMode.CursorRow == (INT32) (ConsoleInfo->OriginalStartRow + ConsoleInfo->RowsPerScreen - 1)) {
531 ConsoleInfo->OriginalStartRow++;
532 ConsoleInfo->CurrentStartRow++;
533 }
534 ConsoleInfo->HistoryMode.CursorRow++;
535 }
536 break;
537 case (CHAR_CARRIAGE_RETURN):
538 //
539 // Move the cursor to the beginning of the current row.
540 //
541 ConsoleInfo->HistoryMode.CursorColumn = 0;
542 break;
543 default:
544 //
545 // Acrtually print characters into the history buffer
546 //
547
548 PrintIndex = ConsoleInfo->HistoryMode.CursorRow * ConsoleInfo->ColsPerScreen + ConsoleInfo->HistoryMode.CursorColumn;
549
550 for ( // no initializer needed
551 ; ConsoleInfo->HistoryMode.CursorColumn < (INT32) ConsoleInfo->ColsPerScreen
552 ; ConsoleInfo->HistoryMode.CursorColumn++
553 , PrintIndex++
554 , Walker++
555 ){
556 if (*Walker == CHAR_NULL
557 ||*Walker == CHAR_BACKSPACE
558 ||*Walker == CHAR_LINEFEED
559 ||*Walker == CHAR_CARRIAGE_RETURN
560 ){
561 Walker--;
562 break;
563 }
564 //
565 // The buffer is 2*CursorRow more since it has that many \r\n characters at the end of each row.
566 //
567
568 ASSERT(PrintIndex + ConsoleInfo->HistoryMode.CursorRow < ConsoleInfo->BufferSize);
569 ConsoleInfo->Buffer[PrintIndex + (2*ConsoleInfo->HistoryMode.CursorRow)] = *Walker;
570 ASSERT(PrintIndex < ConsoleInfo->AttribSize);
571 ConsoleInfo->Attributes[PrintIndex] = ConsoleInfo->HistoryMode.Attribute;
572 } // for loop
573
574 //
575 // Add the carriage return and line feed at the end of the lines
576 //
577 if (ConsoleInfo->HistoryMode.CursorColumn >= (INT32)ConsoleInfo->ColsPerScreen) {
578 AppendStringToHistory(L"\r\n", ConsoleInfo);
579 Walker--;
580 }
581
582 break;
583 } // switch for character
584 } // for loop
585
586 return (EFI_SUCCESS);
587 }
588
589 /**
590 Worker function to handle printing the output to the screen
591 and the history buffer
592
593 @param[in] String The string to output
594 @param[in] ConsoleInfo The pointer to the instance of the console logger information.
595
596 @retval EFI_SUCCESS The string was printed
597 @retval EFI_DEVICE_ERROR The device reported an error while attempting to output
598 the text.
599 @retval EFI_UNSUPPORTED The output device's mode is not currently in a
600 defined text mode.
601 @retval EFI_WARN_UNKNOWN_GLYPH This warning code indicates that some of the
602 characters in the Unicode string could not be
603 rendered and were skipped.
604 **/
605 EFI_STATUS
606 ConsoleLoggerOutputStringSplit(
607 IN CONST CHAR16 *String,
608 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
609 )
610 {
611 EFI_STATUS Status;
612
613 //
614 // Forward the request to the original ConOut
615 //
616 Status = ConsoleInfo->OldConOut->OutputString (ConsoleInfo->OldConOut, (CHAR16*)String);
617
618 if (EFI_ERROR(Status)) {
619 return (Status);
620 }
621
622 return (AppendStringToHistory(String, ConsoleInfo));
623 }
624
625 /**
626 Function to handle page break mode.
627
628 This function will prompt for continue or break.
629
630 @retval EFI_SUCCESS Continue was choosen
631 @return other Break was choosen
632 **/
633 EFI_STATUS
634 ConsoleLoggerDoPageBreak(
635 VOID
636 )
637 {
638 SHELL_PROMPT_RESPONSE *Resp;
639 EFI_STATUS Status;
640
641 Resp = NULL;
642 ASSERT(ShellInfoObject.PageBreakEnabled);
643 ShellInfoObject.PageBreakEnabled = FALSE;
644 Status = ShellPromptForResponseHii(ShellPromptResponseTypeQuitContinue, STRING_TOKEN(STR_SHELL_QUIT_CONT), ShellInfoObject.HiiHandle, (VOID**)&Resp);
645 ShellInfoObject.PageBreakEnabled = TRUE;
646 ASSERT(Resp != NULL);
647 if (Resp == NULL) {
648 return (EFI_NOT_FOUND);
649 }
650 if (EFI_ERROR(Status)) {
651 if (Resp != NULL) {
652 FreePool(Resp);
653 }
654 return (Status);
655 }
656 if (*Resp == ShellPromptResponseContinue) {
657 FreePool(Resp);
658 ShellInfoObject.ConsoleInfo->RowCounter = 0;
659 // ShellInfoObject.ConsoleInfo->OurConOut.Mode->CursorRow = 0;
660 // ShellInfoObject.ConsoleInfo->OurConOut.Mode->CursorColumn = 0;
661
662 return (EFI_SUCCESS);
663 } else if (*Resp == ShellPromptResponseQuit) {
664 FreePool(Resp);
665 ShellInfoObject.ConsoleInfo->Enabled = FALSE;
666 //
667 // When user wants to quit, the shell should stop running the command.
668 //
669 gBS->SignalEvent (ShellInfoObject.NewEfiShellProtocol->ExecutionBreak);
670 return (EFI_DEVICE_ERROR);
671 } else {
672 ASSERT(FALSE);
673 }
674 return (EFI_SUCCESS);
675 }
676 /**
677 Worker function to handle printing the output with page breaks.
678
679 @param[in] String The string to output
680 @param[in] ConsoleInfo The pointer to the instance of the console logger information.
681
682 @retval EFI_SUCCESS The string was printed
683 @retval EFI_DEVICE_ERROR The device reported an error while attempting to output
684 the text.
685 @retval EFI_UNSUPPORTED The output device's mode is not currently in a
686 defined text mode.
687 @retval EFI_WARN_UNKNOWN_GLYPH This warning code indicates that some of the
688 characters in the Unicode string could not be
689 rendered and were skipped.
690 **/
691 EFI_STATUS
692 ConsoleLoggerPrintWithPageBreak(
693 IN CONST CHAR16 *String,
694 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
695 )
696 {
697 CONST CHAR16 *Walker;
698 CONST CHAR16 *LineStart;
699 CHAR16 *StringCopy;
700 CHAR16 TempChar;
701
702 StringCopy = NULL;
703 StringCopy = StrnCatGrow(&StringCopy, NULL, String, 0);
704 if (StringCopy == NULL) {
705 return (EFI_OUT_OF_RESOURCES);
706 }
707
708 for ( Walker = StringCopy
709 , LineStart = StringCopy
710 ; Walker != NULL && *Walker != CHAR_NULL
711 ; Walker++
712 ){
713 switch (*Walker) {
714 case (CHAR_BACKSPACE):
715 if (ConsoleInfo->OurConOut.Mode->CursorColumn > 0) {
716 ConsoleInfo->OurConOut.Mode->CursorColumn--;
717 }
718 break;
719 case (CHAR_LINEFEED):
720 //
721 // add a temp NULL terminator
722 //
723 TempChar = *(Walker + 1);
724 *((CHAR16*)(Walker+1)) = CHAR_NULL;
725
726 //
727 // output the string
728 //
729 ConsoleLoggerOutputStringSplit (LineStart, ConsoleInfo);
730
731 //
732 // restore the temp NULL terminator to it's original character
733 //
734 *((CHAR16*)(Walker+1)) = TempChar;
735
736 //
737 // Update LineStart Variable
738 //
739 LineStart = Walker + 1;
740
741 //
742 // increment row count
743 //
744 ShellInfoObject.ConsoleInfo->RowCounter++;
745 ConsoleInfo->OurConOut.Mode->CursorRow++;
746
747 break;
748 case (CHAR_CARRIAGE_RETURN):
749 //
750 // Move the cursor to the beginning of the current row.
751 //
752 ConsoleInfo->OurConOut.Mode->CursorColumn = 0;
753 break;
754 default:
755 //
756 // increment column count
757 //
758 ConsoleInfo->OurConOut.Mode->CursorColumn++;
759 //
760 // check if that is the last column
761 //
762 if ((INTN)ConsoleInfo->ColsPerScreen == ConsoleInfo->OurConOut.Mode->CursorColumn + 1) {
763 //
764 // output a line similar to the linefeed character.
765 //
766
767 //
768 // add a temp NULL terminator
769 //
770 TempChar = *(Walker + 1);
771 *((CHAR16*)(Walker+1)) = CHAR_NULL;
772
773 //
774 // output the string
775 //
776 ConsoleLoggerOutputStringSplit (LineStart, ConsoleInfo);
777
778 //
779 // restore the temp NULL terminator to it's original character
780 //
781 *((CHAR16*)(Walker+1)) = TempChar;
782
783 //
784 // Update LineStart Variable
785 //
786 LineStart = Walker + 1;
787
788 //
789 // increment row count and zero the column
790 //
791 ShellInfoObject.ConsoleInfo->RowCounter++;
792 ConsoleInfo->OurConOut.Mode->CursorRow++;
793 ConsoleInfo->OurConOut.Mode->CursorColumn = 0;
794 } // last column on line
795 break;
796 } // switch for character
797
798 //
799 // check if that was the last printable row. If yes handle PageBreak mode
800 //
801 if ((ConsoleInfo->RowsPerScreen) -1 == ShellInfoObject.ConsoleInfo->RowCounter) {
802 if (EFI_ERROR(ConsoleLoggerDoPageBreak())) {
803 //
804 // We got an error which means 'break' and halt the printing
805 //
806 SHELL_FREE_NON_NULL(StringCopy);
807 return (EFI_DEVICE_ERROR);
808 }
809 }
810 } // for loop
811
812 if (LineStart != NULL && *LineStart != CHAR_NULL) {
813 ConsoleLoggerOutputStringSplit (LineStart, ConsoleInfo);
814 }
815
816 SHELL_FREE_NON_NULL(StringCopy);
817 return (EFI_SUCCESS);
818 }
819
820 /**
821 Write a Unicode string to the output device.
822
823 @param[in] This Protocol instance pointer.
824 @param[in] WString The NULL-terminated Unicode string to be displayed on the output
825 device(s). All output devices must also support the Unicode
826 drawing defined in this file.
827 @retval EFI_SUCCESS The string was output to the device.
828 @retval EFI_DEVICE_ERROR The device reported an error while attempting to output
829 the text.
830 @retval EFI_UNSUPPORTED The output device's mode is not currently in a
831 defined text mode.
832 @retval EFI_WARN_UNKNOWN_GLYPH This warning code indicates that some of the
833 characters in the Unicode string could not be
834 rendered and were skipped.
835 **/
836 EFI_STATUS
837 EFIAPI
838 ConsoleLoggerOutputString (
839 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
840 IN CHAR16 *WString
841 )
842 {
843 EFI_STATUS Status;
844 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx;
845 EFI_KEY_DATA KeyData;
846 UINTN EventIndex;
847 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
848
849 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
850 if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut) {
851 return (EFI_UNSUPPORTED);
852 }
853 ASSERT(ShellInfoObject.ConsoleInfo == ConsoleInfo);
854
855 Status = gBS->HandleProtocol (gST->ConsoleInHandle, &gEfiSimpleTextInputExProtocolGuid, (VOID **) &TxtInEx);
856 if (!EFI_ERROR (Status)) {
857 while (ShellInfoObject.HaltOutput) {
858
859 ShellInfoObject.HaltOutput = FALSE;
860 //
861 // just get some key
862 //
863 Status = gBS->WaitForEvent (1, &TxtInEx->WaitForKeyEx, &EventIndex);
864 ASSERT_EFI_ERROR (Status);
865 Status = TxtInEx->ReadKeyStrokeEx (TxtInEx, &KeyData);
866 if (EFI_ERROR(Status)) {
867 break;
868 }
869
870 if ((KeyData.Key.UnicodeChar == L's') && (KeyData.Key.ScanCode == SCAN_NULL) &&
871 ((KeyData.KeyState.KeyShiftState == (EFI_SHIFT_STATE_VALID | EFI_LEFT_CONTROL_PRESSED)) ||
872 (KeyData.KeyState.KeyShiftState == (EFI_SHIFT_STATE_VALID | EFI_RIGHT_CONTROL_PRESSED))
873 )
874 ) {
875 ShellInfoObject.HaltOutput = TRUE;
876 }
877 }
878 }
879
880 if (!ShellInfoObject.ConsoleInfo->Enabled) {
881 return (EFI_DEVICE_ERROR);
882 } else if (ShellInfoObject.PageBreakEnabled) {
883 return (ConsoleLoggerPrintWithPageBreak(WString, ConsoleInfo));
884 } else {
885 return (ConsoleLoggerOutputStringSplit(WString, ConsoleInfo));
886 }
887 }
888
889 /**
890 Verifies that all characters in a Unicode string can be output to the
891 target device.
892
893 @param[in] This Protocol instance pointer.
894 @param[in] WString The NULL-terminated Unicode string to be examined for the output
895 device(s).
896
897 @retval EFI_SUCCESS The device(s) are capable of rendering the output string.
898 @retval EFI_UNSUPPORTED Some of the characters in the Unicode string cannot be
899 rendered by one or more of the output devices mapped
900 by the EFI handle.
901
902 **/
903 EFI_STATUS
904 EFIAPI
905 ConsoleLoggerTestString (
906 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
907 IN CHAR16 *WString
908 )
909 {
910 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
911 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
912 //
913 // Forward the request to the original ConOut
914 //
915 return (ConsoleInfo->OldConOut->TestString (ConsoleInfo->OldConOut, WString));
916 }
917
918 /**
919 Returns information for an available text mode that the output device(s)
920 supports.
921
922 @param[in] This Protocol instance pointer.
923 @param[in] ModeNumber The mode number to return information on.
924 @param[out] Columns Upon return, the number of columns in the selected geometry
925 @param[out] Rows Upon return, the number of rows in the selected geometry
926
927 @retval EFI_SUCCESS The requested mode information was returned.
928 @retval EFI_DEVICE_ERROR The device had an error and could not
929 complete the request.
930 @retval EFI_UNSUPPORTED The mode number was not valid.
931 **/
932 EFI_STATUS
933 EFIAPI
934 ConsoleLoggerQueryMode (
935 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
936 IN UINTN ModeNumber,
937 OUT UINTN *Columns,
938 OUT UINTN *Rows
939 )
940 {
941 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
942 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
943 //
944 // Forward the request to the original ConOut
945 //
946 return (ConsoleInfo->OldConOut->QueryMode (
947 ConsoleInfo->OldConOut,
948 ModeNumber,
949 Columns,
950 Rows
951 ));
952 }
953
954 /**
955 Sets the output device(s) to a specified mode.
956
957 @param[in] This Protocol instance pointer.
958 @param[in] ModeNumber The mode number to set.
959
960
961 @retval EFI_SUCCESS The requested text mode was set.
962 @retval EFI_DEVICE_ERROR The device had an error and
963 could not complete the request.
964 @retval EFI_UNSUPPORTED The mode number was not valid.
965 **/
966 EFI_STATUS
967 EFIAPI
968 ConsoleLoggerSetMode (
969 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
970 IN UINTN ModeNumber
971 )
972 {
973 EFI_STATUS Status;
974
975 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
976 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
977
978 //
979 // Forward the request to the original ConOut
980 //
981 Status = ConsoleInfo->OldConOut->SetMode (ConsoleInfo->OldConOut, ModeNumber);
982
983 //
984 // Check that the buffers are still correct for logging
985 //
986 if (!EFI_ERROR (Status)) {
987 ConsoleInfo->OurConOut.Mode = ConsoleInfo->OldConOut->Mode;
988 ConsoleLoggerResetBuffers(ConsoleInfo);
989 ConsoleInfo->OriginalStartRow = 0;
990 ConsoleInfo->CurrentStartRow = 0;
991 ConsoleInfo->OurConOut.ClearScreen (&ConsoleInfo->OurConOut);
992 }
993
994 return Status;
995 }
996
997 /**
998 Sets the background and foreground colors for the OutputString () and
999 ClearScreen () functions.
1000
1001 @param[in] This Protocol instance pointer.
1002 @param[in] Attribute The attribute to set. Bits 0..3 are the foreground color, and
1003 bits 4..6 are the background color. All other bits are undefined
1004 and must be zero. The valid Attributes are defined in this file.
1005
1006 @retval EFI_SUCCESS The attribute was set.
1007 @retval EFI_DEVICE_ERROR The device had an error and
1008 could not complete the request.
1009 @retval EFI_UNSUPPORTED The attribute requested is not defined.
1010
1011 **/
1012 EFI_STATUS
1013 EFIAPI
1014 ConsoleLoggerSetAttribute (
1015 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
1016 IN UINTN Attribute
1017 )
1018 {
1019 EFI_STATUS Status;
1020
1021 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
1022 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
1023
1024 //
1025 // Forward the request to the original ConOut
1026 //
1027 Status = ConsoleInfo->OldConOut->SetAttribute (ConsoleInfo->OldConOut, Attribute);
1028
1029 //
1030 // Record console output history
1031 //
1032 if (!EFI_ERROR (Status)) {
1033 ConsoleInfo->HistoryMode.Attribute = (INT32) Attribute;
1034 }
1035
1036 return Status;
1037 }
1038
1039 /**
1040 Clears the output device(s) display to the currently selected background
1041 color.
1042
1043 @param[in] This Protocol instance pointer.
1044
1045 @retval EFI_SUCCESS The operation completed successfully.
1046 @retval EFI_DEVICE_ERROR The device had an error and
1047 could not complete the request.
1048 @retval EFI_UNSUPPORTED The output device is not in a valid text mode.
1049 **/
1050 EFI_STATUS
1051 EFIAPI
1052 ConsoleLoggerClearScreen (
1053 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This
1054 )
1055 {
1056 EFI_STATUS Status;
1057 CHAR16 *Screen;
1058 INT32 *Attributes;
1059 UINTN Row;
1060 UINTN Column;
1061 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
1062
1063 if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut) {
1064 return (EFI_UNSUPPORTED);
1065 }
1066
1067 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
1068
1069 //
1070 // Forward the request to the original ConOut
1071 //
1072 Status = ConsoleInfo->OldConOut->ClearScreen (ConsoleInfo->OldConOut);
1073
1074 //
1075 // Record console output history
1076 //
1077 if (!EFI_ERROR (Status)) {
1078 Screen = &ConsoleInfo->Buffer[(ConsoleInfo->ColsPerScreen + 2) * ConsoleInfo->CurrentStartRow];
1079 Attributes = &ConsoleInfo->Attributes[ConsoleInfo->ColsPerScreen * ConsoleInfo->CurrentStartRow];
1080 for ( Row = ConsoleInfo->OriginalStartRow
1081 ; Row < (ConsoleInfo->RowsPerScreen * ConsoleInfo->ScreenCount)
1082 ; Row++
1083 ){
1084 for ( Column = 0
1085 ; Column < ConsoleInfo->ColsPerScreen
1086 ; Column++
1087 , Screen++
1088 , Attributes++
1089 ){
1090 *Screen = L' ';
1091 *Attributes = ConsoleInfo->OldConOut->Mode->Attribute;
1092 }
1093 //
1094 // Skip the NULL on each column end in text buffer only
1095 //
1096 Screen += 2;
1097 }
1098 ConsoleInfo->HistoryMode.CursorColumn = 0;
1099 ConsoleInfo->HistoryMode.CursorRow = 0;
1100 }
1101
1102 return Status;
1103 }
1104
1105 /**
1106 Sets the current coordinates of the cursor position
1107
1108 @param[in] This Protocol instance pointer.
1109 @param[in] Column Column to put the cursor in. Must be between zero and Column returned from QueryMode
1110 @param[in] Row Row to put the cursor in. Must be between zero and Row returned from QueryMode
1111
1112 @retval EFI_SUCCESS The operation completed successfully.
1113 @retval EFI_DEVICE_ERROR The device had an error and
1114 could not complete the request.
1115 @retval EFI_UNSUPPORTED The output device is not in a valid text mode, or the
1116 cursor position is invalid for the current mode.
1117 **/
1118 EFI_STATUS
1119 EFIAPI
1120 ConsoleLoggerSetCursorPosition (
1121 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
1122 IN UINTN Column,
1123 IN UINTN Row
1124 )
1125 {
1126 EFI_STATUS Status;
1127 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
1128
1129 if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut) {
1130 return (EFI_UNSUPPORTED);
1131 }
1132
1133 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
1134 //
1135 // Forward the request to the original ConOut
1136 //
1137 Status = ConsoleInfo->OldConOut->SetCursorPosition (
1138 ConsoleInfo->OldConOut,
1139 Column,
1140 Row
1141 );
1142
1143 //
1144 // Record console output history
1145 //
1146 if (!EFI_ERROR (Status)) {
1147 ConsoleInfo->HistoryMode.CursorColumn = (INT32)Column;
1148 ConsoleInfo->HistoryMode.CursorRow = (INT32)(ConsoleInfo->OriginalStartRow + Row);
1149 }
1150
1151 return Status;
1152 }
1153
1154 /**
1155 Makes the cursor visible or invisible
1156
1157 @param[in] This Protocol instance pointer.
1158 @param[in] Visible If TRUE, the cursor is set to be visible. If FALSE, the cursor is
1159 set to be invisible.
1160
1161 @retval EFI_SUCCESS The operation completed successfully.
1162 @retval EFI_DEVICE_ERROR The device had an error and could not complete the
1163 request, or the device does not support changing
1164 the cursor mode.
1165 @retval EFI_UNSUPPORTED The output device is not in a valid text mode.
1166 **/
1167 EFI_STATUS
1168 EFIAPI
1169 ConsoleLoggerEnableCursor (
1170 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
1171 IN BOOLEAN Visible
1172 )
1173 {
1174 EFI_STATUS Status;
1175
1176 CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
1177 ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
1178 //
1179 // Forward the request to the original ConOut
1180 //
1181 Status = ConsoleInfo->OldConOut->EnableCursor (ConsoleInfo->OldConOut, Visible);
1182
1183 //
1184 // Record console output history
1185 //
1186 if (!EFI_ERROR (Status)) {
1187 ConsoleInfo->HistoryMode.CursorVisible = Visible;
1188 }
1189
1190 return Status;
1191 }
1192
1193 /**
1194 Function to update and verify that the current buffers are correct.
1195
1196 @param[in] ConsoleInfo The pointer to the instance of the console logger information.
1197
1198 This will be used when a mode has changed or a reset ocurred to verify all
1199 history buffers.
1200 **/
1201 EFI_STATUS
1202 ConsoleLoggerResetBuffers(
1203 IN CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo
1204 )
1205 {
1206 EFI_STATUS Status;
1207
1208 if (ConsoleInfo->Buffer != NULL) {
1209 FreePool(ConsoleInfo->Buffer);
1210 ConsoleInfo->Buffer = NULL;
1211 ConsoleInfo->BufferSize = 0;
1212 }
1213 if (ConsoleInfo->Attributes != NULL) {
1214 FreePool(ConsoleInfo->Attributes);
1215 ConsoleInfo->Attributes = NULL;
1216 ConsoleInfo->AttribSize = 0;
1217 }
1218
1219 Status = gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &ConsoleInfo->ColsPerScreen, &ConsoleInfo->RowsPerScreen);
1220 if (EFI_ERROR(Status)){
1221 return (Status);
1222 }
1223
1224 ConsoleInfo->BufferSize = (ConsoleInfo->ColsPerScreen + 2) * ConsoleInfo->RowsPerScreen * ConsoleInfo->ScreenCount * sizeof(ConsoleInfo->Buffer[0]);
1225 ConsoleInfo->AttribSize = ConsoleInfo->ColsPerScreen * ConsoleInfo->RowsPerScreen * ConsoleInfo->ScreenCount * sizeof(ConsoleInfo->Attributes[0]);
1226
1227 ConsoleInfo->Buffer = (CHAR16*)AllocateZeroPool(ConsoleInfo->BufferSize);
1228
1229 if (ConsoleInfo->Buffer == NULL) {
1230 return (EFI_OUT_OF_RESOURCES);
1231 }
1232
1233 ConsoleInfo->Attributes = (INT32*)AllocateZeroPool(ConsoleInfo->AttribSize);
1234 if (ConsoleInfo->Attributes == NULL) {
1235 FreePool(ConsoleInfo->Buffer);
1236 ConsoleInfo->Buffer = NULL;
1237 return (EFI_OUT_OF_RESOURCES);
1238 }
1239
1240 CopyMem (&ConsoleInfo->HistoryMode, ConsoleInfo->OldConOut->Mode, sizeof (EFI_SIMPLE_TEXT_OUTPUT_MODE));
1241
1242 return (EFI_SUCCESS);
1243 }
EFI Development Kit II mirror for PVE