35187bf58f5d4dada71b5936b56279518a02a5b2
[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 BOOLEAN
1169 BOpt_IsEfiApp (
1170 IN EFI_FILE_HANDLE Dir,
1171 IN UINT16 *FileName
1172 )
1173 /*++
1174
1175 Routine Description:
1176 Check whether current FileName point to a valid Efi Application
1177
1178 Arguments:
1179 Dir - Pointer to current Directory
1180 FileName - Pointer to current File name.
1181
1182 Returns:
1183 TRUE - Is a valid Efi Application
1184 FALSE - not a valid Efi Application
1185
1186 --*/
1187 {
1188 UINTN BufferSize;
1189 EFI_IMAGE_DOS_HEADER DosHdr;
1190 EFI_IMAGE_NT_HEADERS PeHdr;
1191 EFI_IMAGE_OPTIONAL_HEADER32 *PeOpt32;
1192 EFI_IMAGE_OPTIONAL_HEADER64 *PeOpt64;
1193 UINT16 Subsystem;
1194 EFI_FILE_HANDLE File;
1195 EFI_STATUS Status;
1196
1197 Status = Dir->Open (Dir, &File, FileName, EFI_FILE_MODE_READ, 0);
1198
1199 if (EFI_ERROR (Status)) {
1200 return FALSE;
1201 }
1202
1203 BufferSize = sizeof (EFI_IMAGE_DOS_HEADER);
1204 File->Read (File, &BufferSize, &DosHdr);
1205 if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {
1206 File->Close (File);
1207 return FALSE;
1208 }
1209
1210 File->SetPosition (File, DosHdr.e_lfanew);
1211 BufferSize = sizeof (EFI_IMAGE_NT_HEADERS);
1212 File->Read (File, &BufferSize, &PeHdr);
1213 if (PeHdr.Signature != EFI_IMAGE_NT_SIGNATURE) {
1214 File->Close (File);
1215 return FALSE;
1216 }
1217 //
1218 // Determine PE type and read subsytem
1219 // BugBug : We should be using EFI_IMAGE_MACHINE_TYPE_SUPPORTED (machine)
1220 // macro to detect the machine type.
1221 // We should not be using EFI_IMAGE_OPTIONAL_HEADER32 and
1222 // EFI_IMAGE_OPTIONAL_HEADER64
1223 //
1224 if (PeHdr.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
1225 PeOpt32 = (EFI_IMAGE_OPTIONAL_HEADER32 *) &(PeHdr.OptionalHeader);
1226 Subsystem = PeOpt32->Subsystem;
1227 } else if (PeHdr.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
1228 PeOpt64 = (EFI_IMAGE_OPTIONAL_HEADER64 *) &(PeHdr.OptionalHeader);
1229 Subsystem = PeOpt64->Subsystem;
1230 } else {
1231 return FALSE;
1232 }
1233
1234 if (Subsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1235 File->Close (File);
1236 return TRUE;
1237 } else {
1238 File->Close (File);
1239 return FALSE;
1240 }
1241 }
1242
1243 EFI_STATUS
1244 BOpt_FindDrivers (
1245 VOID
1246 )
1247 /*++
1248
1249 Routine Description
1250 Find drivers that will be added as Driver#### variables from handles
1251 in current system environment
1252 All valid handles in the system except those consume SimpleFs, LoadFile
1253 are stored in DriverMenu for future use.
1254
1255 Arguments:
1256 None
1257
1258 Returns:
1259 EFI_SUCCESS
1260 Others
1261
1262 --*/
1263 {
1264 UINTN NoDevicePathHandles;
1265 EFI_HANDLE *DevicePathHandle;
1266 UINTN Index;
1267 EFI_STATUS Status;
1268 BM_MENU_ENTRY *NewMenuEntry;
1269 BM_HANDLE_CONTEXT *NewHandleContext;
1270 EFI_HANDLE CurHandle;
1271 UINTN OptionNumber;
1272 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
1273 EFI_LOAD_FILE_PROTOCOL *LoadFile;
1274
1275 SimpleFs = NULL;
1276 LoadFile = NULL;
1277
1278 InitializeListHead (&DriverMenu.Head);
1279
1280 //
1281 // At first, get all handles that support Device Path
1282 // protocol which is the basic requirement for
1283 // Driver####
1284 //
1285 Status = gBS->LocateHandleBuffer (
1286 ByProtocol,
1287 &gEfiDevicePathProtocolGuid,
1288 NULL,
1289 &NoDevicePathHandles,
1290 &DevicePathHandle
1291 );
1292 if (EFI_ERROR (Status)) {
1293 return Status;
1294 }
1295
1296 OptionNumber = 0;
1297 for (Index = 0; Index < NoDevicePathHandles; Index++) {
1298 CurHandle = DevicePathHandle[Index];
1299
1300 //
1301 // Check whether this handle support
1302 // driver binding
1303 //
1304 Status = gBS->HandleProtocol (
1305 CurHandle,
1306 &gEfiSimpleFileSystemProtocolGuid,
1307 &SimpleFs
1308 );
1309 if (Status == EFI_SUCCESS) {
1310 continue;
1311 }
1312
1313 Status = gBS->HandleProtocol (
1314 CurHandle,
1315 &gEfiLoadFileProtocolGuid,
1316 &LoadFile
1317 );
1318 if (Status == EFI_SUCCESS) {
1319 continue;
1320 }
1321
1322 NewMenuEntry = BOpt_CreateMenuEntry (BM_HANDLE_CONTEXT_SELECT);
1323 if (NULL == NewMenuEntry) {
1324 return EFI_OUT_OF_RESOURCES;
1325 }
1326
1327 NewHandleContext = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1328 NewHandleContext->Handle = CurHandle;
1329 NewHandleContext->DevicePath = DevicePathFromHandle (CurHandle);
1330 NewMenuEntry->DisplayString = DevicePathToStr (NewHandleContext->DevicePath);
1331 NewMenuEntry->HelpString = NULL;
1332 NewMenuEntry->OptionNumber = OptionNumber;
1333 OptionNumber++;
1334 InsertTailList (&DriverMenu.Head, &NewMenuEntry->Link);
1335
1336 }
1337
1338 DriverMenu.MenuNumber = OptionNumber;
1339 return EFI_SUCCESS;
1340 }
1341
1342 UINT16
1343 BOpt_GetBootOptionNumber (
1344 VOID
1345 )
1346 /*++
1347
1348 Routine Description:
1349 Get the Option Number that does not used
1350
1351 Arguments:
1352
1353 Returns:
1354 The Option Number
1355
1356 --*/
1357 {
1358 BM_MENU_ENTRY *NewMenuEntry;
1359 UINT16 *BootOrderList;
1360 UINTN BootOrderListSize;
1361 UINT16 Number;
1362 UINTN Index;
1363 UINTN Index2;
1364 BOOLEAN Found;
1365
1366 BootOrderListSize = 0;
1367 BootOrderList = NULL;
1368
1369 BootOrderList = BdsLibGetVariableAndSize (
1370 L"BootOrder",
1371 &gEfiGlobalVariableGuid,
1372 &BootOrderListSize
1373 );
1374 if (BootOrderList) {
1375 //
1376 // already have Boot####
1377 //
1378 // AlreadyBootNumbers = BootOrderListSize / sizeof(UINT16);
1379 //
1380 for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
1381 Found = TRUE;
1382 for (Index2 = 0; Index2 < BootOptionMenu.MenuNumber; Index2++) {
1383 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index2);
1384 if (Index == NewMenuEntry->OptionNumber) {
1385 Found = FALSE;
1386 break;
1387 }
1388 }
1389
1390 if (Found) {
1391 break;
1392 }
1393 }
1394 //
1395 // end for Index
1396 //
1397 Number = (UINT16) Index;
1398 } else {
1399 //
1400 // No Boot####
1401 //
1402 Number = 0;
1403 }
1404
1405 return Number;
1406 }
1407
1408 UINT16
1409 BOpt_GetDriverOptionNumber (
1410 VOID
1411 )
1412 /*++
1413
1414 Routine Description:
1415 Get the Option Number that does not used
1416
1417 Arguments:
1418
1419 Returns:
1420 The Option Number
1421
1422 --*/
1423 {
1424 BM_MENU_ENTRY *NewMenuEntry;
1425 UINT16 *DriverOrderList;
1426 UINTN DriverOrderListSize;
1427 UINT16 Number;
1428 UINTN Index;
1429 UINTN Index2;
1430 BOOLEAN Found;
1431
1432 DriverOrderListSize = 0;
1433 DriverOrderList = NULL;
1434
1435 DriverOrderList = BdsLibGetVariableAndSize (
1436 L"DriverOrder",
1437 &gEfiGlobalVariableGuid,
1438 &DriverOrderListSize
1439 );
1440 if (DriverOrderList) {
1441 //
1442 // already have Driver####
1443 //
1444 // AlreadyDriverNumbers = DriverOrderListSize / sizeof(UINT16);
1445 //
1446 for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1447 Found = TRUE;
1448 for (Index2 = 0; Index2 < DriverOptionMenu.MenuNumber; Index2++) {
1449 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index2);
1450 if (Index == NewMenuEntry->OptionNumber) {
1451 Found = FALSE;
1452 break;
1453 }
1454 }
1455
1456 if (Found) {
1457 break;
1458 }
1459 }
1460 //
1461 // end for Index
1462 //
1463 Number = (UINT16) Index;
1464 } else {
1465 //
1466 // No Driver####
1467 //
1468 Number = 0;
1469 }
1470
1471 return Number;
1472 }
1473
1474 EFI_STATUS
1475 BOpt_GetDriverOptions (
1476 IN BMM_CALLBACK_DATA *CallbackData
1477 )
1478 /*++
1479
1480 Routine Description:
1481 Build up all DriverOptionMenu
1482
1483 Arguments:
1484
1485 Returns:
1486 The Option Number
1487
1488 --*/
1489 {
1490 UINTN Index;
1491 UINT16 DriverString[12];
1492 UINT8 *LoadOptionFromVar;
1493 UINT8 *LoadOption;
1494 UINTN DriverOptionSize;
1495
1496 UINT16 *DriverOrderList;
1497 UINTN DriverOrderListSize;
1498 BM_MENU_ENTRY *NewMenuEntry;
1499 BM_LOAD_CONTEXT *NewLoadContext;
1500 UINT8 *LoadOptionPtr;
1501 UINTN StringSize;
1502 UINTN OptionalDataSize;
1503 UINT8 *LoadOptionEnd;
1504
1505 DriverOrderListSize = 0;
1506 DriverOrderList = NULL;
1507 DriverOptionSize = 0;
1508 LoadOptionFromVar = NULL;
1509 BOpt_FreeMenu (&DriverOptionMenu);
1510 InitializeListHead (&DriverOptionMenu.Head);
1511 //
1512 // Get the DriverOrder from the Var
1513 //
1514 DriverOrderList = BdsLibGetVariableAndSize (
1515 L"DriverOrder",
1516 &gEfiGlobalVariableGuid,
1517 &DriverOrderListSize
1518 );
1519
1520 for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1521 UnicodeSPrint (
1522 DriverString,
1523 sizeof (DriverString),
1524 L"Driver%04x",
1525 DriverOrderList[Index]
1526 );
1527 //
1528 // Get all loadoptions from the VAR
1529 //
1530 LoadOptionFromVar = BdsLibGetVariableAndSize (
1531 DriverString,
1532 &gEfiGlobalVariableGuid,
1533 &DriverOptionSize
1534 );
1535 if (!LoadOptionFromVar) {
1536 continue;
1537 }
1538
1539 LoadOption = AllocateZeroPool (DriverOptionSize);
1540 if (!LoadOption) {
1541 continue;
1542 }
1543
1544 CopyMem (LoadOption, LoadOptionFromVar, DriverOptionSize);
1545 SafeFreePool (LoadOptionFromVar);
1546
1547 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
1548 if (NULL == NewMenuEntry) {
1549 return EFI_OUT_OF_RESOURCES;
1550 }
1551
1552 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1553 LoadOptionPtr = LoadOption;
1554 LoadOptionEnd = LoadOption + DriverOptionSize;
1555 NewMenuEntry->OptionNumber = DriverOrderList[Index];
1556 NewLoadContext->LoadOptionModified = FALSE;
1557 NewLoadContext->Deleted = FALSE;
1558 NewLoadContext->IsLegacy = FALSE;
1559
1560 //
1561 // LoadOption is a pointer type of UINT8
1562 // for easy use with following LOAD_OPTION
1563 // embedded in this struct
1564 //
1565 NewLoadContext->LoadOption = LoadOption;
1566 NewLoadContext->LoadOptionSize = DriverOptionSize;
1567
1568 NewLoadContext->Attributes = *(UINT32 *) LoadOptionPtr;
1569 NewLoadContext->IsActive = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1570
1571 NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1572
1573 LoadOptionPtr += sizeof (UINT32);
1574
1575 NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1576 LoadOptionPtr += sizeof (UINT16);
1577
1578 StringSize = StrSize ((UINT16 *) LoadOptionPtr);
1579 NewLoadContext->Description = AllocateZeroPool (StringSize);
1580 ASSERT (NewLoadContext->Description != NULL);
1581 CopyMem (
1582 NewLoadContext->Description,
1583 (UINT16 *) LoadOptionPtr,
1584 StringSize
1585 );
1586 NewMenuEntry->DisplayString = NewLoadContext->Description;
1587
1588 LoadOptionPtr += StringSize;
1589
1590 NewLoadContext->FilePathList = AllocateZeroPool (NewLoadContext->FilePathListLength);
1591 ASSERT (NewLoadContext->FilePathList != NULL);
1592 CopyMem (
1593 NewLoadContext->FilePathList,
1594 (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1595 NewLoadContext->FilePathListLength
1596 );
1597
1598 NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1599 NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1600 CallbackData,
1601 DriverOptionStrDepository
1602 );
1603 NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1604 CallbackData,
1605 DriverOptionHelpStrDepository
1606 );
1607 LoadOptionPtr += NewLoadContext->FilePathListLength;
1608
1609 if (LoadOptionPtr < LoadOptionEnd) {
1610 OptionalDataSize = DriverOptionSize -
1611 sizeof (UINT32) -
1612 sizeof (UINT16) -
1613 StringSize -
1614 NewLoadContext->FilePathListLength;
1615
1616 NewLoadContext->OptionalData = AllocateZeroPool (OptionalDataSize);
1617 ASSERT (NewLoadContext->OptionalData != NULL);
1618 CopyMem (
1619 NewLoadContext->OptionalData,
1620 LoadOptionPtr,
1621 OptionalDataSize
1622 );
1623
1624 NewLoadContext->OptionalDataSize = OptionalDataSize;
1625 }
1626
1627 InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
1628
1629 }
1630
1631 SafeFreePool (DriverOrderList);
1632 DriverOptionMenu.MenuNumber = Index;
1633 return EFI_SUCCESS;
1634
1635 }
1636
1637 VOID
1638 SafeFreePool (
1639 IN VOID *Buffer
1640 )
1641 /*++
1642
1643 Routine Description:
1644 Wrap original FreePool gBS call
1645 in order to decrease code length
1646
1647 Arguments:
1648
1649 Returns:
1650
1651 --*/
1652 {
1653 if (Buffer != NULL) {
1654 gBS->FreePool (Buffer);
1655 Buffer = NULL;
1656 }
1657 }