13e82759e12d5bee532b22b0cd73b709d42f45cc
[mirror_edk2.git] / EdkNt32Pkg / Dxe / PlatformBds / Generic / BootMaint / BootOption.c
1 /*++
2 Copyright (c) 2006, Intel Corporation
3 All rights reserved. This program and the accompanying materials
4 are licensed and made available under the terms and conditions of the BSD License
5 which accompanies this distribution. The full text of the license may be found at
6 http://opensource.org/licenses/bsd-license.php
7
8 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
9 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
10
11 Module Name:
12
13 bootoption.c
14
15 Abstract:
16
17 Provide boot option support for Application "BootMaint"
18
19 Include file system navigation, system handle selection
20
21 Boot option manipulation
22
23 Revision History
24
25 --*/
26
27 #include "bootmaint.h"
28 #include "BBSsupport.h"
29
30 BM_MENU_ENTRY *
31 BOpt_CreateMenuEntry (
32 UINTN MenuType
33 )
34 /*++
35
36 Routine Description
37 Create Menu Entry for future use, make all types together
38 in order to reduce code size
39
40 Arguments:
41 MenuType Use this parameter to identify current
42 Menu type
43
44 Returns:
45 NULL Cannot allocate memory for current menu
46 entry
47 Others A valid pointer pointing to the allocated
48 memory pool for current menu entry
49
50 --*/
51 {
52 BM_MENU_ENTRY *MenuEntry;
53 UINTN ContextSize;
54
55 switch (MenuType) {
56 case BM_LOAD_CONTEXT_SELECT:
57 ContextSize = sizeof (BM_LOAD_CONTEXT);
58 break;
59
60 case BM_FILE_CONTEXT_SELECT:
61 ContextSize = sizeof (BM_FILE_CONTEXT);
62 break;
63
64 case BM_CONSOLE_CONTEXT_SELECT:
65 ContextSize = sizeof (BM_CONSOLE_CONTEXT);
66 break;
67
68 case BM_TERMINAL_CONTEXT_SELECT:
69 ContextSize = sizeof (BM_TERMINAL_CONTEXT);
70 break;
71
72 case BM_HANDLE_CONTEXT_SELECT:
73 ContextSize = sizeof (BM_HANDLE_CONTEXT);
74 break;
75
76 case BM_LEGACY_DEV_CONTEXT_SELECT:
77 ContextSize = sizeof (BM_LEGACY_DEVICE_CONTEXT);
78 break;
79
80 default:
81 ContextSize = 0;
82 break;
83
84 }
85
86 if (0 == ContextSize) {
87 return NULL;
88 }
89
90 MenuEntry = AllocateZeroPool (sizeof (BM_MENU_ENTRY));
91 if (NULL == MenuEntry) {
92 return MenuEntry;
93 }
94
95 MenuEntry->VariableContext = AllocateZeroPool (ContextSize);
96 if (NULL == MenuEntry->VariableContext) {
97 SafeFreePool (MenuEntry);
98 MenuEntry = NULL;
99 return MenuEntry;
100 }
101
102 MenuEntry->Signature = BM_MENU_ENTRY_SIGNATURE;
103 MenuEntry->ContextSelection = MenuType;
104 return MenuEntry;
105 }
106
107 VOID
108 BOpt_DestroyMenuEntry (
109 BM_MENU_ENTRY *MenuEntry
110 )
111 /*++
112 Routine Description :
113 Destroy the menu entry passed in
114
115 Arguments :
116 The menu entry need to be destroyed
117
118 Returns :
119 None
120
121 --*/
122 {
123 BM_LOAD_CONTEXT *LoadContext;
124 BM_FILE_CONTEXT *FileContext;
125 BM_CONSOLE_CONTEXT *ConsoleContext;
126 BM_TERMINAL_CONTEXT *TerminalContext;
127 BM_HANDLE_CONTEXT *HandleContext;
128 BM_LEGACY_DEVICE_CONTEXT *LegacyDevContext;
129
130 //
131 // Select by the type in Menu entry for current context type
132 //
133 switch (MenuEntry->ContextSelection) {
134 case BM_LOAD_CONTEXT_SELECT:
135 LoadContext = (BM_LOAD_CONTEXT *) MenuEntry->VariableContext;
136 SafeFreePool (LoadContext->FilePathList);
137 SafeFreePool (LoadContext->LoadOption);
138 SafeFreePool (LoadContext->OptionalData);
139 SafeFreePool (LoadContext);
140 break;
141
142 case BM_FILE_CONTEXT_SELECT:
143 FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
144
145 if (!FileContext->IsRoot) {
146 SafeFreePool (FileContext->DevicePath);
147 } else {
148 if (FileContext->FHandle != NULL) {
149 FileContext->FHandle->Close (FileContext->FHandle);
150 }
151 }
152
153 SafeFreePool (FileContext->FileName);
154 SafeFreePool (FileContext->Info);
155 SafeFreePool (FileContext);
156 break;
157
158 case BM_CONSOLE_CONTEXT_SELECT:
159 ConsoleContext = (BM_CONSOLE_CONTEXT *) MenuEntry->VariableContext;
160 SafeFreePool (ConsoleContext->DevicePath);
161 SafeFreePool (ConsoleContext);
162 break;
163
164 case BM_TERMINAL_CONTEXT_SELECT:
165 TerminalContext = (BM_TERMINAL_CONTEXT *) MenuEntry->VariableContext;
166 SafeFreePool (TerminalContext->DevicePath);
167 SafeFreePool (TerminalContext);
168 break;
169
170 case BM_HANDLE_CONTEXT_SELECT:
171 HandleContext = (BM_HANDLE_CONTEXT *) MenuEntry->VariableContext;
172 SafeFreePool (HandleContext);
173 break;
174
175 case BM_LEGACY_DEV_CONTEXT_SELECT:
176 LegacyDevContext = (BM_LEGACY_DEVICE_CONTEXT *) MenuEntry->VariableContext;
177 SafeFreePool (LegacyDevContext);
178
179 default:
180 break;
181 }
182
183 SafeFreePool (MenuEntry->DisplayString);
184 if (NULL != MenuEntry->HelpString) {
185 SafeFreePool (MenuEntry->HelpString);
186 }
187
188 SafeFreePool (MenuEntry);
189 }
190
191 BM_MENU_ENTRY *
192 BOpt_GetMenuEntry (
193 BM_MENU_OPTION *MenuOption,
194 UINTN MenuNumber
195 )
196 /*++
197 Rountine Description :
198 Use this routine to get one particular menu entry in specified
199 menu
200
201 Arguments :
202 MenuOption The menu that we will search
203
204 MenuNumber The menunubmer that we want
205
206 Returns :
207 The desired menu entry
208
209 --*/
210 {
211 BM_MENU_ENTRY *NewMenuEntry;
212 UINTN Index;
213 LIST_ENTRY *List;
214
215 if (MenuNumber >= MenuOption->MenuNumber) {
216 return NULL;
217 }
218
219 List = MenuOption->Head.ForwardLink;
220 for (Index = 0; Index < MenuNumber; Index++) {
221 List = List->ForwardLink;
222 }
223
224 NewMenuEntry = CR (List, BM_MENU_ENTRY, Link, BM_MENU_ENTRY_SIGNATURE);
225
226 return NewMenuEntry;
227 }
228
229 EFI_STATUS
230 BOpt_FindFileSystem (
231 IN BMM_CALLBACK_DATA *CallbackData
232 )
233 /*++
234
235 Routine Description
236 Find file systems for current Extensible Firmware
237 Including Handles that support Simple File System
238 protocol, Load File protocol.
239
240 Building up the FileSystem Menu for user selection
241 All file system will be stored in FsOptionMenu
242 for future use.
243
244 Arguments:
245 CallbackData - BMM context data
246
247 Returns:
248 EFI_SUCCESS - Success find the file system
249 EFI_OUT_OF_RESOURCES - Can not create menu entry
250
251 --*/
252 {
253 UINTN NoSimpleFsHandles;
254 UINTN NoLoadFileHandles;
255 EFI_HANDLE *SimpleFsHandle;
256 EFI_HANDLE *LoadFileHandle;
257 UINT16 *VolumeLabel;
258 EFI_BLOCK_IO_PROTOCOL *BlkIo;
259 UINTN Index;
260 EFI_STATUS Status;
261 BM_MENU_ENTRY *MenuEntry;
262 BM_FILE_CONTEXT *FileContext;
263 UINT16 *TempStr;
264 UINTN OptionNumber;
265 EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
266 UINT16 DeviceType;
267 BBS_BBS_DEVICE_PATH BbsDevicePathNode;
268 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
269 BOOLEAN RemovableMedia;
270
271
272 NoSimpleFsHandles = 0;
273 NoLoadFileHandles = 0;
274 OptionNumber = 0;
275 InitializeListHead (&FsOptionMenu.Head);
276
277 //
278 // Locate Handles that support Simple File System protocol
279 //
280 Status = gBS->LocateHandleBuffer (
281 ByProtocol,
282 &gEfiSimpleFileSystemProtocolGuid,
283 NULL,
284 &NoSimpleFsHandles,
285 &SimpleFsHandle
286 );
287 if (!EFI_ERROR (Status)) {
288 //
289 // Find all the instances of the File System prototocol
290 //
291 for (Index = 0; Index < NoSimpleFsHandles; Index++) {
292 Status = gBS->HandleProtocol (
293 SimpleFsHandle[Index],
294 &gEfiBlockIoProtocolGuid,
295 &BlkIo
296 );
297 if (EFI_ERROR (Status)) {
298 //
299 // If no block IO exists assume it's NOT a removable media
300 //
301 RemovableMedia = FALSE;
302 } else {
303 //
304 // If block IO exists check to see if it's remobable media
305 //
306 RemovableMedia = BlkIo->Media->RemovableMedia;
307 }
308
309 //
310 // Allocate pool for this load option
311 //
312 MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
313 if (NULL == MenuEntry) {
314 SafeFreePool (SimpleFsHandle);
315 return EFI_OUT_OF_RESOURCES;
316 }
317
318 FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
319
320 FileContext->Handle = SimpleFsHandle[Index];
321 MenuEntry->OptionNumber = Index;
322 FileContext->FHandle = EfiLibOpenRoot (FileContext->Handle);
323 if (!FileContext->FHandle) {
324 BOpt_DestroyMenuEntry (MenuEntry);
325 continue;
326 }
327
328 MenuEntry->HelpString = DevicePathToStr (DevicePathFromHandle (FileContext->Handle));
329 FileContext->Info = EfiLibFileSystemVolumeLabelInfo (FileContext->FHandle);
330 FileContext->FileName = EfiStrDuplicate (L"\\");
331 FileContext->DevicePath = FileDevicePath (
332 FileContext->Handle,
333 FileContext->FileName
334 );
335 FileContext->IsDir = TRUE;
336 FileContext->IsRoot = TRUE;
337 FileContext->IsRemovableMedia = FALSE;
338 FileContext->IsLoadFile = FALSE;
339
340 //
341 // Get current file system's Volume Label
342 //
343 if (FileContext->Info == NULL) {
344 VolumeLabel = L"NO FILE SYSTEM INFO";
345 } else {
346 if (FileContext->Info->VolumeLabel == NULL) {
347 VolumeLabel = L"NULL VOLUME LABEL";
348 } else {
349 VolumeLabel = FileContext->Info->VolumeLabel;
350 if (*VolumeLabel == 0x0000) {
351 VolumeLabel = L"NO VOLUME LABEL";
352 }
353 }
354 }
355
356 TempStr = MenuEntry->HelpString;
357 MenuEntry->DisplayString = AllocateZeroPool (MAX_CHAR);
358 ASSERT (MenuEntry->DisplayString != NULL);
359 UnicodeSPrint (
360 MenuEntry->DisplayString,
361 MAX_CHAR,
362 L"%s, [%s]",
363 VolumeLabel,
364 TempStr
365 );
366 OptionNumber++;
367 InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
368 }
369 }
370
371 if (NoSimpleFsHandles != 0) {
372 SafeFreePool (SimpleFsHandle);
373 }
374 //
375 // Searching for handles that support Load File protocol
376 //
377 Status = gBS->LocateHandleBuffer (
378 ByProtocol,
379 &gEfiLoadFileProtocolGuid,
380 NULL,
381 &NoLoadFileHandles,
382 &LoadFileHandle
383 );
384
385 if (!EFI_ERROR (Status)) {
386 for (Index = 0; Index < NoLoadFileHandles; Index++) {
387 MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
388 if (NULL == MenuEntry) {
389 SafeFreePool (LoadFileHandle);
390 return EFI_OUT_OF_RESOURCES;
391 }
392
393 FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
394 FileContext->IsRemovableMedia = FALSE;
395 FileContext->IsLoadFile = TRUE;
396 FileContext->Handle = LoadFileHandle[Index];
397 FileContext->IsRoot = TRUE;
398
399 FileContext->DevicePath = DevicePathFromHandle (FileContext->Handle);
400
401 MenuEntry->HelpString = DevicePathToStr (FileContext->DevicePath);
402
403 TempStr = MenuEntry->HelpString;
404 MenuEntry->DisplayString = AllocateZeroPool (MAX_CHAR);
405 ASSERT (MenuEntry->DisplayString != NULL);
406 UnicodeSPrint (
407 MenuEntry->DisplayString,
408 MAX_CHAR,
409 L"Load File [%s]",
410 TempStr
411 );
412
413 MenuEntry->OptionNumber = OptionNumber;
414 OptionNumber++;
415 InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
416 }
417 }
418
419 if (NoLoadFileHandles != 0) {
420 SafeFreePool (LoadFileHandle);
421 }
422
423 //
424 // Add Legacy Boot Option Support Here
425 //
426 Status = gBS->LocateProtocol (
427 &gEfiLegacyBiosProtocolGuid,
428 NULL,
429 &LegacyBios
430 );
431 if (!EFI_ERROR (Status)) {
432
433 for (Index = BBS_TYPE_FLOPPY; Index <= BBS_TYPE_EMBEDDED_NETWORK; Index++) {
434 MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
435 if (NULL == MenuEntry) {
436 return EFI_OUT_OF_RESOURCES;
437 }
438
439 FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
440
441 FileContext->IsRemovableMedia = FALSE;
442 FileContext->IsLoadFile = TRUE;
443 FileContext->IsBootLegacy = TRUE;
444 DeviceType = (UINT16) Index;
445 BbsDevicePathNode.Header.Type = BBS_DEVICE_PATH;
446 BbsDevicePathNode.Header.SubType = BBS_BBS_DP;
447 SetDevicePathNodeLength (
448 &BbsDevicePathNode.Header,
449 sizeof (BBS_BBS_DEVICE_PATH)
450 );
451 BbsDevicePathNode.DeviceType = DeviceType;
452 BbsDevicePathNode.StatusFlag = 0;
453 BbsDevicePathNode.String[0] = 0;
454 DevicePath = AppendDevicePathNode (
455 EndDevicePath,
456 (EFI_DEVICE_PATH_PROTOCOL *) &BbsDevicePathNode
457 );
458
459 FileContext->DevicePath = DevicePath;
460 MenuEntry->HelpString = DevicePathToStr (FileContext->DevicePath);
461
462 TempStr = MenuEntry->HelpString;
463 MenuEntry->DisplayString = AllocateZeroPool (MAX_CHAR);
464 ASSERT (MenuEntry->DisplayString != NULL);
465 UnicodeSPrint (
466 MenuEntry->DisplayString,
467 MAX_CHAR,
468 L"Boot Legacy [%s]",
469 TempStr
470 );
471 MenuEntry->OptionNumber = OptionNumber;
472 OptionNumber++;
473 InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
474 }
475 }
476 //
477 // Remember how many file system options are here
478 //
479 FsOptionMenu.MenuNumber = OptionNumber;
480 return EFI_SUCCESS;
481 }
482
483 VOID
484 BOpt_FreeMenu (
485 BM_MENU_OPTION *FreeMenu
486 )
487 /*++
488
489 Routine Description
490 Free resources allocated in Allocate Rountine
491
492 Arguments:
493 FreeMenu Menu to be freed
494
495 Returns:
496 VOID
497
498 --*/
499 {
500 BM_MENU_ENTRY *MenuEntry;
501 while (!IsListEmpty (&FreeMenu->Head)) {
502 MenuEntry = CR (
503 FreeMenu->Head.ForwardLink,
504 BM_MENU_ENTRY,
505 Link,
506 BM_MENU_ENTRY_SIGNATURE
507 );
508 RemoveEntryList (&MenuEntry->Link);
509 BOpt_DestroyMenuEntry (MenuEntry);
510 }
511 }
512
513 EFI_STATUS
514 BOpt_FindFiles (
515 IN BMM_CALLBACK_DATA *CallbackData,
516 IN BM_MENU_ENTRY *MenuEntry
517 )
518 /*++
519
520 Routine Description
521 Find files under current directory
522 All files and sub-directories in current directory
523 will be stored in DirectoryMenu for future use.
524
525 Arguments:
526 FileOption -- Pointer for Dir to explore
527
528 Returns:
529 TRUE -- Get files from current dir successfully
530 FALSE -- Can't get files from current dir
531
532 --*/
533 {
534 EFI_FILE_HANDLE NewDir;
535 EFI_FILE_HANDLE Dir;
536 EFI_FILE_INFO *DirInfo;
537 UINTN BufferSize;
538 UINTN DirBufferSize;
539 BM_MENU_ENTRY *NewMenuEntry;
540 BM_FILE_CONTEXT *FileContext;
541 BM_FILE_CONTEXT *NewFileContext;
542 UINTN Pass;
543 EFI_STATUS Status;
544 UINTN OptionNumber;
545
546 FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
547 Dir = FileContext->FHandle;
548 OptionNumber = 0;
549 //
550 // Open current directory to get files from it
551 //
552 Status = Dir->Open (
553 Dir,
554 &NewDir,
555 FileContext->FileName,
556 EFI_FILE_READ_ONLY,
557 0
558 );
559 if (!FileContext->IsRoot) {
560 Dir->Close (Dir);
561 }
562
563 if (EFI_ERROR (Status)) {
564 return Status;
565 }
566
567 DirInfo = EfiLibFileInfo (NewDir);
568 if (!DirInfo) {
569 return EFI_NOT_FOUND;
570 }
571
572 if (!(DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
573 return EFI_INVALID_PARAMETER;
574 }
575
576 FileContext->DevicePath = FileDevicePath (
577 FileContext->Handle,
578 FileContext->FileName
579 );
580
581 DirBufferSize = sizeof (EFI_FILE_INFO) + 1024;
582 DirInfo = AllocateZeroPool (DirBufferSize);
583 if (!DirInfo) {
584 return EFI_OUT_OF_RESOURCES;
585 }
586 //
587 // Get all files in current directory
588 // Pass 1 to get Directories
589 // Pass 2 to get files that are EFI images
590 //
591 for (Pass = 1; Pass <= 2; Pass++) {
592 NewDir->SetPosition (NewDir, 0);
593 for (;;) {
594 BufferSize = DirBufferSize;
595 Status = NewDir->Read (NewDir, &BufferSize, DirInfo);
596 if (EFI_ERROR (Status) || BufferSize == 0) {
597 break;
598 }
599
600 if ((DirInfo->Attribute & EFI_FILE_DIRECTORY && Pass == 2) ||
601 (!(DirInfo->Attribute & EFI_FILE_DIRECTORY) && Pass == 1)
602 ) {
603 //
604 // Pass 1 is for Directories
605 // Pass 2 is for file names
606 //
607 continue;
608 }
609
610 if (!(BOpt_IsEfiImageName (DirInfo->FileName) || DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
611 //
612 // Slip file unless it is a directory entry or a .EFI file
613 //
614 continue;
615 }
616
617 NewMenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
618 if (NULL == NewMenuEntry) {
619 return EFI_OUT_OF_RESOURCES;
620 }
621
622 NewFileContext = (BM_FILE_CONTEXT *) NewMenuEntry->VariableContext;
623 NewFileContext->Handle = FileContext->Handle;
624 NewFileContext->FileName = BOpt_AppendFileName (
625 FileContext->FileName,
626 DirInfo->FileName
627 );
628 NewFileContext->FHandle = NewDir;
629 NewFileContext->DevicePath = FileDevicePath (
630 NewFileContext->Handle,
631 NewFileContext->FileName
632 );
633 NewMenuEntry->HelpString = NULL;
634
635 MenuEntry->DisplayStringToken = GetStringTokenFromDepository (
636 CallbackData,
637 FileOptionStrDepository
638 );
639
640 NewFileContext->IsDir = (BOOLEAN) ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY);
641
642 if (NewFileContext->IsDir) {
643 BufferSize = StrLen (DirInfo->FileName) * 2 + 6;
644 NewMenuEntry->DisplayString = AllocateZeroPool (BufferSize);
645
646 UnicodeSPrint (
647 NewMenuEntry->DisplayString,
648 BufferSize,
649 L"<%s>",
650 DirInfo->FileName
651 );
652
653 } else {
654 NewMenuEntry->DisplayString = EfiStrDuplicate (DirInfo->FileName);
655 }
656
657 NewFileContext->IsRoot = FALSE;
658 NewFileContext->IsLoadFile = FALSE;
659 NewFileContext->IsRemovableMedia = FALSE;
660
661 NewMenuEntry->OptionNumber = OptionNumber;
662 OptionNumber++;
663 InsertTailList (&DirectoryMenu.Head, &NewMenuEntry->Link);
664 }
665 }
666
667 DirectoryMenu.MenuNumber = OptionNumber;
668 SafeFreePool (DirInfo);
669 return TRUE;
670 }
671
672 EFI_STATUS
673 BOpt_GetLegacyOptions (
674 VOID
675 )
676 /*++
677 Routine Description:
678
679 Build the LegacyFDMenu LegacyHDMenu LegacyCDMenu according to LegacyBios.GetBbsInfo().
680
681 Arguments:
682 None
683
684 Returns:
685 The device info of legacy device.
686
687 --*/
688 {
689 BM_MENU_ENTRY *NewMenuEntry;
690 BM_LEGACY_DEVICE_CONTEXT *NewLegacyDevContext;
691 EFI_STATUS Status;
692 EFI_LEGACY_BIOS_PROTOCOL *LegacyBios;
693 UINT16 HddCount;
694 HDD_INFO *HddInfo;
695 UINT16 BbsCount;
696 BBS_TABLE *BbsTable;
697 UINTN Index;
698 CHAR16 DescString[100];
699 UINTN FDNum;
700 UINTN HDNum;
701 UINTN CDNum;
702 UINTN NETNum;
703 UINTN BEVNum;
704
705 NewMenuEntry = NULL;
706 HddInfo = NULL;
707 BbsTable = NULL;
708 BbsCount = 0;
709
710 //
711 // Initialize Bbs Table Context from BBS info data
712 //
713 InitializeListHead (&LegacyFDMenu.Head);
714 InitializeListHead (&LegacyHDMenu.Head);
715 InitializeListHead (&LegacyCDMenu.Head);
716 InitializeListHead (&LegacyNETMenu.Head);
717 InitializeListHead (&LegacyBEVMenu.Head);
718
719 Status = gBS->LocateProtocol (
720 &gEfiLegacyBiosProtocolGuid,
721 NULL,
722 &LegacyBios
723 );
724 if (!EFI_ERROR (Status)) {
725 Status = LegacyBios->GetBbsInfo (
726 LegacyBios,
727 &HddCount,
728 &HddInfo,
729 &BbsCount,
730 &BbsTable
731 );
732 if (EFI_ERROR (Status)) {
733 return Status;
734 }
735 }
736
737 FDNum = 0;
738 HDNum = 0;
739 CDNum = 0;
740 NETNum = 0;
741 BEVNum = 0;
742
743 for (Index = 0; Index < BbsCount; Index++) {
744 if ((BBS_IGNORE_ENTRY == BbsTable[Index].BootPriority) ||
745 (BBS_DO_NOT_BOOT_FROM == BbsTable[Index].BootPriority) ||
746 (BBS_LOWEST_PRIORITY == BbsTable[Index].BootPriority)
747 ) {
748 continue;
749 }
750
751 NewMenuEntry = BOpt_CreateMenuEntry (BM_LEGACY_DEV_CONTEXT_SELECT);
752 if (NULL == NewMenuEntry) {
753 break;
754 }
755
756 NewLegacyDevContext = (BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext;
757 NewLegacyDevContext->BbsTable = &BbsTable[Index];
758 NewLegacyDevContext->Index = Index;
759 NewLegacyDevContext->BbsCount = BbsCount;
760 BdsBuildLegacyDevNameString (
761 &BbsTable[Index],
762 Index,
763 sizeof (DescString),
764 DescString
765 );
766 NewLegacyDevContext->Description = AllocateZeroPool (StrSize (DescString));
767 if (NULL == NewLegacyDevContext->Description) {
768 break;
769 }
770
771 CopyMem (NewLegacyDevContext->Description, DescString, StrSize (DescString));
772 NewMenuEntry->DisplayString = NewLegacyDevContext->Description;
773 NewMenuEntry->HelpString = NULL;
774
775 switch (BbsTable[Index].DeviceType) {
776 case BBS_FLOPPY:
777 InsertTailList (&LegacyFDMenu.Head, &NewMenuEntry->Link);
778 FDNum++;
779 break;
780
781 case BBS_HARDDISK:
782 InsertTailList (&LegacyHDMenu.Head, &NewMenuEntry->Link);
783 HDNum++;
784 break;
785
786 case BBS_CDROM:
787 InsertTailList (&LegacyCDMenu.Head, &NewMenuEntry->Link);
788 CDNum++;
789 break;
790
791 case BBS_EMBED_NETWORK:
792 InsertTailList (&LegacyNETMenu.Head, &NewMenuEntry->Link);
793 NETNum++;
794 break;
795
796 case BBS_BEV_DEVICE:
797 InsertTailList (&LegacyBEVMenu.Head, &NewMenuEntry->Link);
798 BEVNum++;
799 break;
800 }
801 }
802
803 if (Index != BbsCount) {
804 BOpt_FreeLegacyOptions ();
805 return EFI_OUT_OF_RESOURCES;
806 }
807
808 LegacyFDMenu.MenuNumber = FDNum;
809 LegacyHDMenu.MenuNumber = HDNum;
810 LegacyCDMenu.MenuNumber = CDNum;
811 LegacyNETMenu.MenuNumber = NETNum;
812 LegacyBEVMenu.MenuNumber = BEVNum;
813 return EFI_SUCCESS;
814 }
815
816 VOID
817 BOpt_FreeLegacyOptions (
818 VOID
819 )
820 {
821 BOpt_FreeMenu (&LegacyFDMenu);
822 BOpt_FreeMenu (&LegacyHDMenu);
823 BOpt_FreeMenu (&LegacyCDMenu);
824 BOpt_FreeMenu (&LegacyNETMenu);
825 BOpt_FreeMenu (&LegacyBEVMenu);
826 }
827
828 EFI_STATUS
829 BOpt_GetBootOptions (
830 IN BMM_CALLBACK_DATA *CallbackData
831 )
832 /*++
833
834 Routine Description:
835
836 Build the BootOptionMenu according to BootOrder Variable.
837 This Routine will access the Boot#### to get EFI_LOAD_OPTION
838
839 Arguments:
840 None
841
842 Returns:
843 The number of the Var Boot####
844
845 --*/
846 {
847 UINTN Index;
848 UINT16 BootString[10];
849 UINT8 *LoadOptionFromVar;
850 UINT8 *LoadOption;
851 UINTN BootOptionSize;
852 BOOLEAN BootNextFlag;
853 UINT16 *BootOrderList;
854 UINTN BootOrderListSize;
855 UINT16 *BootNext;
856 UINTN BootNextSize;
857 BM_MENU_ENTRY *NewMenuEntry;
858 BM_LOAD_CONTEXT *NewLoadContext;
859 UINT8 *LoadOptionPtr;
860 UINTN StringSize;
861 UINTN OptionalDataSize;
862 UINT8 *LoadOptionEnd;
863 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
864 UINTN MenuCount;
865 UINT8 *Ptr;
866
867 MenuCount = 0;
868 BootOrderListSize = 0;
869 BootNextSize = 0;
870 BootOrderList = NULL;
871 BootNext = NULL;
872 LoadOptionFromVar = NULL;
873 BOpt_FreeMenu (&BootOptionMenu);
874 InitializeListHead (&BootOptionMenu.Head);
875
876 //
877 // Get the BootOrder from the Var
878 //
879 BootOrderList = BdsLibGetVariableAndSize (
880 L"BootOrder",
881 &gEfiGlobalVariableGuid,
882 &BootOrderListSize
883 );
884
885 //
886 // Get the BootNext from the Var
887 //
888 BootNext = BdsLibGetVariableAndSize (
889 L"BootNext",
890 &gEfiGlobalVariableGuid,
891 &BootNextSize
892 );
893
894 if (BootNext) {
895 if (BootNextSize != sizeof (UINT16)) {
896 SafeFreePool (BootNext);
897 BootNext = NULL;
898 }
899 }
900
901 for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
902 UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", BootOrderList[Index]);
903 //
904 // Get all loadoptions from the VAR
905 //
906 LoadOptionFromVar = BdsLibGetVariableAndSize (
907 BootString,
908 &gEfiGlobalVariableGuid,
909 &BootOptionSize
910 );
911 if (!LoadOptionFromVar) {
912 continue;
913 }
914
915 LoadOption = AllocateZeroPool (BootOptionSize);
916 if (!LoadOption) {
917 continue;
918 }
919
920 CopyMem (LoadOption, LoadOptionFromVar, BootOptionSize);
921 SafeFreePool (LoadOptionFromVar);
922
923 if (BootNext) {
924 BootNextFlag = (BOOLEAN) (*BootNext == BootOrderList[Index]);
925 } else {
926 BootNextFlag = FALSE;
927 }
928
929 if (0 == (*((UINT32 *) LoadOption) & LOAD_OPTION_ACTIVE)) {
930 SafeFreePool (LoadOption);
931 continue;
932 }
933 //
934 // BUGBUG: could not return EFI_OUT_OF_RESOURCES here directly.
935 // the buffer allocated already should be freed before returning.
936 //
937 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
938 if (NULL == NewMenuEntry) {
939 return EFI_OUT_OF_RESOURCES;
940 }
941
942 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
943
944 LoadOptionPtr = LoadOption;
945 LoadOptionEnd = LoadOption + BootOptionSize;
946
947 NewMenuEntry->OptionNumber = BootOrderList[Index];
948 NewLoadContext->LoadOptionModified = FALSE;
949 NewLoadContext->Deleted = FALSE;
950 NewLoadContext->IsBootNext = BootNextFlag;
951
952 //
953 // Is a Legacy Device?
954 //
955 Ptr = (UINT8 *) LoadOption;
956
957 //
958 // Attribute = *(UINT32 *)Ptr;
959 //
960 Ptr += sizeof (UINT32);
961
962 //
963 // FilePathSize = *(UINT16 *)Ptr;
964 //
965 Ptr += sizeof (UINT16);
966
967 //
968 // Description = (CHAR16 *)Ptr;
969 //
970 Ptr += StrSize ((CHAR16 *) Ptr);
971
972 //
973 // Now Ptr point to Device Path
974 //
975 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
976 if ((BBS_DEVICE_PATH == DevicePath->Type) && (BBS_BBS_DP == DevicePath->SubType)) {
977 NewLoadContext->IsLegacy = TRUE;
978 } else {
979 NewLoadContext->IsLegacy = FALSE;
980 }
981 //
982 // LoadOption is a pointer type of UINT8
983 // for easy use with following LOAD_OPTION
984 // embedded in this struct
985 //
986 NewLoadContext->LoadOption = LoadOption;
987 NewLoadContext->LoadOptionSize = BootOptionSize;
988
989 NewLoadContext->Attributes = *(UINT32 *) LoadOptionPtr;
990 NewLoadContext->IsActive = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
991
992 NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
993
994 LoadOptionPtr += sizeof (UINT32);
995
996 NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
997 LoadOptionPtr += sizeof (UINT16);
998
999 StringSize = StrSize ((UINT16 *) LoadOptionPtr);
1000 NewLoadContext->Description = AllocateZeroPool (StringSize);
1001 ASSERT (NewLoadContext->Description != NULL);
1002 CopyMem (
1003 NewLoadContext->Description,
1004 (UINT16 *) LoadOptionPtr,
1005 StringSize
1006 );
1007 NewMenuEntry->DisplayString = NewLoadContext->Description;
1008
1009 LoadOptionPtr += StringSize;
1010
1011 NewLoadContext->FilePathList = AllocateZeroPool (NewLoadContext->FilePathListLength);
1012 ASSERT (NewLoadContext->FilePathList != NULL);
1013 CopyMem (
1014 NewLoadContext->FilePathList,
1015 (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1016 NewLoadContext->FilePathListLength
1017 );
1018
1019 NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1020 NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1021 CallbackData,
1022 BootOptionStrDepository
1023 );
1024 NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1025 CallbackData,
1026 BootOptionHelpStrDepository
1027 );
1028 LoadOptionPtr += NewLoadContext->FilePathListLength;
1029
1030 if (LoadOptionPtr < LoadOptionEnd) {
1031 OptionalDataSize = BootOptionSize -
1032 sizeof (UINT32) -
1033 sizeof (UINT16) -
1034 StringSize -
1035 NewLoadContext->FilePathListLength;
1036
1037 NewLoadContext->OptionalData = AllocateZeroPool (OptionalDataSize);
1038 ASSERT (NewLoadContext->OptionalData != NULL);
1039 CopyMem (
1040 NewLoadContext->OptionalData,
1041 LoadOptionPtr,
1042 OptionalDataSize
1043 );
1044
1045 NewLoadContext->OptionalDataSize = OptionalDataSize;
1046 }
1047
1048 InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
1049 MenuCount++;
1050 }
1051
1052 SafeFreePool (BootNext);
1053 SafeFreePool (BootOrderList);
1054 BootOptionMenu.MenuNumber = MenuCount;
1055 return MenuCount;
1056 }
1057
1058 CHAR16 *
1059 BOpt_AppendFileName (
1060 IN CHAR16 *Str1,
1061 IN CHAR16 *Str2
1062 )
1063 /*++
1064
1065 Routine Description
1066 Append file name to existing file name.
1067
1068 Arguments:
1069 Str1 - existing file name
1070 Str2 - file name to be appended
1071
1072 Returns:
1073 Allocate a new string to hold the appended result.
1074 Caller is responsible to free the returned string.
1075
1076 --*/
1077 {
1078 UINTN Size1;
1079 UINTN Size2;
1080 CHAR16 *Str;
1081 CHAR16 *Ptr;
1082 CHAR16 *LastSlash;
1083
1084 Size1 = StrSize (Str1);
1085 Size2 = StrSize (Str2);
1086 Str = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
1087 ASSERT (Str != NULL);
1088
1089 StrCat (Str, Str1);
1090 if (!((*Str == '\\') && (*(Str + 1) == 0))) {
1091 StrCat (Str, L"\\");
1092 }
1093
1094 StrCat (Str, Str2);
1095
1096 Ptr = Str;
1097 LastSlash = Str;
1098 while (*Ptr != 0) {
1099 if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '.' && *(Ptr + 3) != 0) {
1100 //
1101 // Convert \Name\..\ to \
1102 // DO NOT convert the .. if it is at the end of the string. This will
1103 // break the .. behavior in changing directories.
1104 //
1105 StrCpy (LastSlash, Ptr + 3);
1106 Ptr = LastSlash;
1107 } else if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '\\') {
1108 //
1109 // Convert a \.\ to a \
1110 //
1111 StrCpy (Ptr, Ptr + 2);
1112 Ptr = LastSlash;
1113 } else if (*Ptr == '\\') {
1114 LastSlash = Ptr;
1115 }
1116
1117 Ptr++;
1118 }
1119
1120 return Str;
1121 }
1122
1123 BOOLEAN
1124 BOpt_IsEfiImageName (
1125 IN UINT16 *FileName
1126 )
1127 /*++
1128
1129 Routine Description
1130 Check whether current FileName point to a valid
1131 Efi Image File.
1132
1133 Arguments:
1134 FileName - File need to be checked.
1135
1136 Returns:
1137 TRUE - Is Efi Image
1138 FALSE - Not a valid Efi Image
1139
1140 --*/
1141 {
1142 //
1143 // Search for ".efi" extension
1144 //
1145 while (*FileName) {
1146 if (FileName[0] == '.') {
1147 if (FileName[1] == 'e' || FileName[1] == 'E') {
1148 if (FileName[2] == 'f' || FileName[2] == 'F') {
1149 if (FileName[3] == 'i' || FileName[3] == 'I') {
1150 return TRUE;
1151 } else if (FileName[3] == 0x0000) {
1152 return FALSE;
1153 }
1154 } else if (FileName[2] == 0x0000) {
1155 return FALSE;
1156 }
1157 } else if (FileName[1] == 0x0000) {
1158 return FALSE;
1159 }
1160 }
1161
1162 FileName += 1;
1163 }
1164
1165 return FALSE;
1166 }
1167
1168
1169 RETURN_STATUS
1170 EFIAPI
1171 IsEfiAppReadFromFile (
1172 IN VOID *FileHandle,
1173 IN UINTN FileOffset,
1174 IN OUT UINTN *ReadSize,
1175 OUT VOID *Buffer
1176 )
1177 {
1178 EFI_STATUS Status;
1179 EFI_FILE_HANDLE File;
1180
1181 File = (EFI_FILE_HANDLE)FileHandle;
1182 Status = File->SetPosition (File, FileOffset);
1183 if (EFI_ERROR (Status)) {
1184 return Status;
1185 }
1186
1187 return File->Read (File, ReadSize, Buffer);
1188 }
1189
1190
1191
1192 BOOLEAN
1193 BOpt_IsEfiApp (
1194 IN EFI_FILE_HANDLE Dir,
1195 IN UINT16 *FileName
1196 )
1197 /*++
1198
1199 Routine Description:
1200 Check whether current FileName point to a valid Efi Application
1201
1202 Arguments:
1203 Dir - Pointer to current Directory
1204 FileName - Pointer to current File name.
1205
1206 Returns:
1207 TRUE - Is a valid Efi Application
1208 FALSE - not a valid Efi Application
1209
1210 --*/
1211 {
1212 EFI_STATUS Status;
1213 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
1214 EFI_FILE_HANDLE File;
1215
1216 Status = Dir->Open (Dir, &File, FileName, EFI_FILE_MODE_READ, 0);
1217 if (EFI_ERROR (Status)) {
1218 return FALSE;
1219 }
1220
1221 ZeroMem (&ImageContext, sizeof (ImageContext));
1222 ImageContext.Handle = (VOID *)File;
1223 ImageContext.ImageRead = IsEfiAppReadFromFile;
1224
1225 Status = PeCoffLoaderGetImageInfo (&ImageContext);
1226 File->Close (File);
1227 if (EFI_ERROR (Status)) {
1228 return FALSE;
1229 }
1230
1231 if (ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1232 return TRUE;
1233 } else {
1234 return FALSE;
1235 }
1236 }
1237
1238
1239 EFI_STATUS
1240 BOpt_FindDrivers (
1241 VOID
1242 )
1243 /*++
1244
1245 Routine Description
1246 Find drivers that will be added as Driver#### variables from handles
1247 in current system environment
1248 All valid handles in the system except those consume SimpleFs, LoadFile
1249 are stored in DriverMenu for future use.
1250
1251 Arguments:
1252 None
1253
1254 Returns:
1255 EFI_SUCCESS
1256 Others
1257
1258 --*/
1259 {
1260 UINTN NoDevicePathHandles;
1261 EFI_HANDLE *DevicePathHandle;
1262 UINTN Index;
1263 EFI_STATUS Status;
1264 BM_MENU_ENTRY *NewMenuEntry;
1265 BM_HANDLE_CONTEXT *NewHandleContext;
1266 EFI_HANDLE CurHandle;
1267 UINTN OptionNumber;
1268 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
1269 EFI_LOAD_FILE_PROTOCOL *LoadFile;
1270
1271 SimpleFs = NULL;
1272 LoadFile = NULL;
1273
1274 InitializeListHead (&DriverMenu.Head);
1275
1276 //
1277 // At first, get all handles that support Device Path
1278 // protocol which is the basic requirement for
1279 // Driver####
1280 //
1281 Status = gBS->LocateHandleBuffer (
1282 ByProtocol,
1283 &gEfiDevicePathProtocolGuid,
1284 NULL,
1285 &NoDevicePathHandles,
1286 &DevicePathHandle
1287 );
1288 if (EFI_ERROR (Status)) {
1289 return Status;
1290 }
1291
1292 OptionNumber = 0;
1293 for (Index = 0; Index < NoDevicePathHandles; Index++) {
1294 CurHandle = DevicePathHandle[Index];
1295
1296 //
1297 // Check whether this handle support
1298 // driver binding
1299 //
1300 Status = gBS->HandleProtocol (
1301 CurHandle,
1302 &gEfiSimpleFileSystemProtocolGuid,
1303 &SimpleFs
1304 );
1305 if (Status == EFI_SUCCESS) {
1306 continue;
1307 }
1308
1309 Status = gBS->HandleProtocol (
1310 CurHandle,
1311 &gEfiLoadFileProtocolGuid,
1312 &LoadFile
1313 );
1314 if (Status == EFI_SUCCESS) {
1315 continue;
1316 }
1317
1318 NewMenuEntry = BOpt_CreateMenuEntry (BM_HANDLE_CONTEXT_SELECT);
1319 if (NULL == NewMenuEntry) {
1320 return EFI_OUT_OF_RESOURCES;
1321 }
1322
1323 NewHandleContext = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1324 NewHandleContext->Handle = CurHandle;
1325 NewHandleContext->DevicePath = DevicePathFromHandle (CurHandle);
1326 NewMenuEntry->DisplayString = DevicePathToStr (NewHandleContext->DevicePath);
1327 NewMenuEntry->HelpString = NULL;
1328 NewMenuEntry->OptionNumber = OptionNumber;
1329 OptionNumber++;
1330 InsertTailList (&DriverMenu.Head, &NewMenuEntry->Link);
1331
1332 }
1333
1334 DriverMenu.MenuNumber = OptionNumber;
1335 return EFI_SUCCESS;
1336 }
1337
1338 UINT16
1339 BOpt_GetBootOptionNumber (
1340 VOID
1341 )
1342 /*++
1343
1344 Routine Description:
1345 Get the Option Number that does not used
1346
1347 Arguments:
1348
1349 Returns:
1350 The Option Number
1351
1352 --*/
1353 {
1354 BM_MENU_ENTRY *NewMenuEntry;
1355 UINT16 *BootOrderList;
1356 UINTN BootOrderListSize;
1357 UINT16 Number;
1358 UINTN Index;
1359 UINTN Index2;
1360 BOOLEAN Found;
1361 CHAR16 StrTemp[100];
1362 UINT16 *OptionBuffer;
1363 UINTN OptionSize;
1364
1365 BootOrderListSize = 0;
1366 BootOrderList = NULL;
1367
1368 BootOrderList = BdsLibGetVariableAndSize (
1369 L"BootOrder",
1370 &gEfiGlobalVariableGuid,
1371 &BootOrderListSize
1372 );
1373 if (BootOrderList) {
1374 //
1375 // already have Boot####
1376 //
1377 // AlreadyBootNumbers = BootOrderListSize / sizeof(UINT16);
1378 //
1379 for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
1380 Found = TRUE;
1381 for (Index2 = 0; Index2 < BootOptionMenu.MenuNumber; Index2++) {
1382 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index2);
1383 if (Index == NewMenuEntry->OptionNumber) {
1384 Found = FALSE;
1385 break;
1386 }
1387 }
1388
1389 if (Found) {
1390 UnicodeSPrint (StrTemp, 100, L"Boot%04x", Index);
1391 DEBUG((EFI_D_ERROR,"INdex= %s\n", StrTemp));
1392 OptionBuffer = BdsLibGetVariableAndSize (
1393 StrTemp,
1394 &gEfiGlobalVariableGuid,
1395 &OptionSize
1396 );
1397 if (NULL == OptionBuffer)
1398 break;
1399 }
1400 }
1401 //
1402 // end for Index
1403 //
1404 Number = (UINT16) Index;
1405 } else {
1406 //
1407 // No Boot####
1408 //
1409 Number = 0;
1410 }
1411
1412 return Number;
1413 }
1414
1415 UINT16
1416 BOpt_GetDriverOptionNumber (
1417 VOID
1418 )
1419 /*++
1420
1421 Routine Description:
1422 Get the Option Number that does not used
1423
1424 Arguments:
1425
1426 Returns:
1427 The Option Number
1428
1429 --*/
1430 {
1431 BM_MENU_ENTRY *NewMenuEntry;
1432 UINT16 *DriverOrderList;
1433 UINTN DriverOrderListSize;
1434 UINT16 Number;
1435 UINTN Index;
1436 UINTN Index2;
1437 BOOLEAN Found;
1438
1439 DriverOrderListSize = 0;
1440 DriverOrderList = NULL;
1441
1442 DriverOrderList = BdsLibGetVariableAndSize (
1443 L"DriverOrder",
1444 &gEfiGlobalVariableGuid,
1445 &DriverOrderListSize
1446 );
1447 if (DriverOrderList) {
1448 //
1449 // already have Driver####
1450 //
1451 // AlreadyDriverNumbers = DriverOrderListSize / sizeof(UINT16);
1452 //
1453 for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1454 Found = TRUE;
1455 for (Index2 = 0; Index2 < DriverOptionMenu.MenuNumber; Index2++) {
1456 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index2);
1457 if (Index == NewMenuEntry->OptionNumber) {
1458 Found = FALSE;
1459 break;
1460 }
1461 }
1462
1463 if (Found) {
1464 break;
1465 }
1466 }
1467 //
1468 // end for Index
1469 //
1470 Number = (UINT16) Index;
1471 } else {
1472 //
1473 // No Driver####
1474 //
1475 Number = 0;
1476 }
1477
1478 return Number;
1479 }
1480
1481 EFI_STATUS
1482 BOpt_GetDriverOptions (
1483 IN BMM_CALLBACK_DATA *CallbackData
1484 )
1485 /*++
1486
1487 Routine Description:
1488 Build up all DriverOptionMenu
1489
1490 Arguments:
1491
1492 Returns:
1493 The Option Number
1494
1495 --*/
1496 {
1497 UINTN Index;
1498 UINT16 DriverString[12];
1499 UINT8 *LoadOptionFromVar;
1500 UINT8 *LoadOption;
1501 UINTN DriverOptionSize;
1502
1503 UINT16 *DriverOrderList;
1504 UINTN DriverOrderListSize;
1505 BM_MENU_ENTRY *NewMenuEntry;
1506 BM_LOAD_CONTEXT *NewLoadContext;
1507 UINT8 *LoadOptionPtr;
1508 UINTN StringSize;
1509 UINTN OptionalDataSize;
1510 UINT8 *LoadOptionEnd;
1511
1512 DriverOrderListSize = 0;
1513 DriverOrderList = NULL;
1514 DriverOptionSize = 0;
1515 LoadOptionFromVar = NULL;
1516 BOpt_FreeMenu (&DriverOptionMenu);
1517 InitializeListHead (&DriverOptionMenu.Head);
1518 //
1519 // Get the DriverOrder from the Var
1520 //
1521 DriverOrderList = BdsLibGetVariableAndSize (
1522 L"DriverOrder",
1523 &gEfiGlobalVariableGuid,
1524 &DriverOrderListSize
1525 );
1526
1527 for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1528 UnicodeSPrint (
1529 DriverString,
1530 sizeof (DriverString),
1531 L"Driver%04x",
1532 DriverOrderList[Index]
1533 );
1534 //
1535 // Get all loadoptions from the VAR
1536 //
1537 LoadOptionFromVar = BdsLibGetVariableAndSize (
1538 DriverString,
1539 &gEfiGlobalVariableGuid,
1540 &DriverOptionSize
1541 );
1542 if (!LoadOptionFromVar) {
1543 continue;
1544 }
1545
1546 LoadOption = AllocateZeroPool (DriverOptionSize);
1547 if (!LoadOption) {
1548 continue;
1549 }
1550
1551 CopyMem (LoadOption, LoadOptionFromVar, DriverOptionSize);
1552 SafeFreePool (LoadOptionFromVar);
1553
1554 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
1555 if (NULL == NewMenuEntry) {
1556 return EFI_OUT_OF_RESOURCES;
1557 }
1558
1559 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1560 LoadOptionPtr = LoadOption;
1561 LoadOptionEnd = LoadOption + DriverOptionSize;
1562 NewMenuEntry->OptionNumber = DriverOrderList[Index];
1563 NewLoadContext->LoadOptionModified = FALSE;
1564 NewLoadContext->Deleted = FALSE;
1565 NewLoadContext->IsLegacy = FALSE;
1566
1567 //
1568 // LoadOption is a pointer type of UINT8
1569 // for easy use with following LOAD_OPTION
1570 // embedded in this struct
1571 //
1572 NewLoadContext->LoadOption = LoadOption;
1573 NewLoadContext->LoadOptionSize = DriverOptionSize;
1574
1575 NewLoadContext->Attributes = *(UINT32 *) LoadOptionPtr;
1576 NewLoadContext->IsActive = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1577
1578 NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1579
1580 LoadOptionPtr += sizeof (UINT32);
1581
1582 NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1583 LoadOptionPtr += sizeof (UINT16);
1584
1585 StringSize = StrSize ((UINT16 *) LoadOptionPtr);
1586 NewLoadContext->Description = AllocateZeroPool (StringSize);
1587 ASSERT (NewLoadContext->Description != NULL);
1588 CopyMem (
1589 NewLoadContext->Description,
1590 (UINT16 *) LoadOptionPtr,
1591 StringSize
1592 );
1593 NewMenuEntry->DisplayString = NewLoadContext->Description;
1594
1595 LoadOptionPtr += StringSize;
1596
1597 NewLoadContext->FilePathList = AllocateZeroPool (NewLoadContext->FilePathListLength);
1598 ASSERT (NewLoadContext->FilePathList != NULL);
1599 CopyMem (
1600 NewLoadContext->FilePathList,
1601 (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1602 NewLoadContext->FilePathListLength
1603 );
1604
1605 NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1606 NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1607 CallbackData,
1608 DriverOptionStrDepository
1609 );
1610 NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1611 CallbackData,
1612 DriverOptionHelpStrDepository
1613 );
1614 LoadOptionPtr += NewLoadContext->FilePathListLength;
1615
1616 if (LoadOptionPtr < LoadOptionEnd) {
1617 OptionalDataSize = DriverOptionSize -
1618 sizeof (UINT32) -
1619 sizeof (UINT16) -
1620 StringSize -
1621 NewLoadContext->FilePathListLength;
1622
1623 NewLoadContext->OptionalData = AllocateZeroPool (OptionalDataSize);
1624 ASSERT (NewLoadContext->OptionalData != NULL);
1625 CopyMem (
1626 NewLoadContext->OptionalData,
1627 LoadOptionPtr,
1628 OptionalDataSize
1629 );
1630
1631 NewLoadContext->OptionalDataSize = OptionalDataSize;
1632 }
1633
1634 InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
1635
1636 }
1637
1638 SafeFreePool (DriverOrderList);
1639 DriverOptionMenu.MenuNumber = Index;
1640 return EFI_SUCCESS;
1641
1642 }
1643
1644 VOID
1645 SafeFreePool (
1646 IN VOID *Buffer
1647 )
1648 /*++
1649
1650 Routine Description:
1651 Wrap original FreePool gBS call
1652 in order to decrease code length
1653
1654 Arguments:
1655
1656 Returns:
1657
1658 --*/
1659 {
1660 if (Buffer != NULL) {
1661 gBS->FreePool (Buffer);
1662 Buffer = NULL;
1663 }
1664 }