fix some minor warning
[mirror_edk2.git] / EdkUnixPkg / 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 (VOID**) &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 (VOID**) &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 (VOID**) &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 BdsStrCpy (
1060 OUT CHAR16 *Destination,
1061 IN CONST CHAR16 *Source
1062 )
1063 {
1064 CHAR16 *ReturnValue;
1065
1066 //
1067 // Destination cannot be NULL
1068 //
1069 ASSERT (Destination != NULL);
1070
1071 ReturnValue = Destination;
1072 while (*Source) {
1073 *(Destination++) = *(Source++);
1074 }
1075 *Destination = 0;
1076 return ReturnValue;
1077 }
1078
1079 CHAR16 *
1080 BOpt_AppendFileName (
1081 IN CHAR16 *Str1,
1082 IN CHAR16 *Str2
1083 )
1084 /*++
1085
1086 Routine Description
1087 Append file name to existing file name.
1088
1089 Arguments:
1090 Str1 - existing file name
1091 Str2 - file name to be appended
1092
1093 Returns:
1094 Allocate a new string to hold the appended result.
1095 Caller is responsible to free the returned string.
1096
1097 --*/
1098 {
1099 UINTN Size1;
1100 UINTN Size2;
1101 CHAR16 *Str;
1102 CHAR16 *Ptr;
1103 CHAR16 *LastSlash;
1104
1105 Size1 = StrSize (Str1);
1106 Size2 = StrSize (Str2);
1107 Str = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
1108 ASSERT (Str != NULL);
1109
1110 StrCat (Str, Str1);
1111 if (!((*Str == '\\') && (*(Str + 1) == 0))) {
1112 StrCat (Str, L"\\");
1113 }
1114
1115 StrCat (Str, Str2);
1116
1117 Ptr = Str;
1118 LastSlash = Str;
1119 while (*Ptr != 0) {
1120 if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '.' && *(Ptr + 3) != 0) {
1121 //
1122 // Convert "\Name\..\" to "\"
1123 // DO NOT convert the .. if it is at the end of the string. This will
1124 // break the .. behavior in changing directories.
1125 //
1126 BdsStrCpy (LastSlash, Ptr + 3);
1127 Ptr = LastSlash;
1128 } else if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '\\') {
1129 //
1130 // Convert a "\.\" to a "\"
1131 //
1132 BdsStrCpy (Ptr, Ptr + 2);
1133 Ptr = LastSlash;
1134 } else if (*Ptr == '\\') {
1135 LastSlash = Ptr;
1136 }
1137
1138 Ptr++;
1139 }
1140
1141 return Str;
1142 }
1143
1144 BOOLEAN
1145 BOpt_IsEfiImageName (
1146 IN UINT16 *FileName
1147 )
1148 /*++
1149
1150 Routine Description
1151 Check whether current FileName point to a valid
1152 Efi Image File.
1153
1154 Arguments:
1155 FileName - File need to be checked.
1156
1157 Returns:
1158 TRUE - Is Efi Image
1159 FALSE - Not a valid Efi Image
1160
1161 --*/
1162 {
1163 //
1164 // Search for ".efi" extension
1165 //
1166 while (*FileName) {
1167 if (FileName[0] == '.') {
1168 if (FileName[1] == 'e' || FileName[1] == 'E') {
1169 if (FileName[2] == 'f' || FileName[2] == 'F') {
1170 if (FileName[3] == 'i' || FileName[3] == 'I') {
1171 return TRUE;
1172 } else if (FileName[3] == 0x0000) {
1173 return FALSE;
1174 }
1175 } else if (FileName[2] == 0x0000) {
1176 return FALSE;
1177 }
1178 } else if (FileName[1] == 0x0000) {
1179 return FALSE;
1180 }
1181 }
1182
1183 FileName += 1;
1184 }
1185
1186 return FALSE;
1187 }
1188
1189
1190 RETURN_STATUS
1191 EFIAPI
1192 IsEfiAppReadFromFile (
1193 IN VOID *FileHandle,
1194 IN UINTN FileOffset,
1195 IN OUT UINTN *ReadSize,
1196 OUT VOID *Buffer
1197 )
1198 {
1199 EFI_STATUS Status;
1200 EFI_FILE_HANDLE File;
1201
1202 File = (EFI_FILE_HANDLE)FileHandle;
1203 Status = File->SetPosition (File, FileOffset);
1204 if (EFI_ERROR (Status)) {
1205 return Status;
1206 }
1207
1208 return File->Read (File, ReadSize, Buffer);
1209 }
1210
1211
1212
1213 BOOLEAN
1214 BOpt_IsEfiApp (
1215 IN EFI_FILE_HANDLE Dir,
1216 IN UINT16 *FileName
1217 )
1218 /*++
1219
1220 Routine Description:
1221 Check whether current FileName point to a valid Efi Application
1222
1223 Arguments:
1224 Dir - Pointer to current Directory
1225 FileName - Pointer to current File name.
1226
1227 Returns:
1228 TRUE - Is a valid Efi Application
1229 FALSE - not a valid Efi Application
1230
1231 --*/
1232 {
1233 EFI_STATUS Status;
1234 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
1235 EFI_FILE_HANDLE File;
1236
1237 Status = Dir->Open (Dir, &File, FileName, EFI_FILE_MODE_READ, 0);
1238 if (EFI_ERROR (Status)) {
1239 return FALSE;
1240 }
1241
1242 ZeroMem (&ImageContext, sizeof (ImageContext));
1243 ImageContext.Handle = (VOID *)File;
1244 ImageContext.ImageRead = IsEfiAppReadFromFile;
1245
1246 Status = PeCoffLoaderGetImageInfo (&ImageContext);
1247 File->Close (File);
1248 if (EFI_ERROR (Status)) {
1249 return FALSE;
1250 }
1251
1252 if (ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1253 return TRUE;
1254 } else {
1255 return FALSE;
1256 }
1257 }
1258
1259
1260 EFI_STATUS
1261 BOpt_FindDrivers (
1262 VOID
1263 )
1264 /*++
1265
1266 Routine Description
1267 Find drivers that will be added as Driver#### variables from handles
1268 in current system environment
1269 All valid handles in the system except those consume SimpleFs, LoadFile
1270 are stored in DriverMenu for future use.
1271
1272 Arguments:
1273 None
1274
1275 Returns:
1276 EFI_SUCCESS
1277 Others
1278
1279 --*/
1280 {
1281 UINTN NoDevicePathHandles;
1282 EFI_HANDLE *DevicePathHandle;
1283 UINTN Index;
1284 EFI_STATUS Status;
1285 BM_MENU_ENTRY *NewMenuEntry;
1286 BM_HANDLE_CONTEXT *NewHandleContext;
1287 EFI_HANDLE CurHandle;
1288 UINTN OptionNumber;
1289 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
1290 EFI_LOAD_FILE_PROTOCOL *LoadFile;
1291
1292 SimpleFs = NULL;
1293 LoadFile = NULL;
1294
1295 InitializeListHead (&DriverMenu.Head);
1296
1297 //
1298 // At first, get all handles that support Device Path
1299 // protocol which is the basic requirement for
1300 // Driver####
1301 //
1302 Status = gBS->LocateHandleBuffer (
1303 ByProtocol,
1304 &gEfiDevicePathProtocolGuid,
1305 NULL,
1306 &NoDevicePathHandles,
1307 &DevicePathHandle
1308 );
1309 if (EFI_ERROR (Status)) {
1310 return Status;
1311 }
1312
1313 OptionNumber = 0;
1314 for (Index = 0; Index < NoDevicePathHandles; Index++) {
1315 CurHandle = DevicePathHandle[Index];
1316
1317 //
1318 // Check whether this handle support
1319 // driver binding
1320 //
1321 Status = gBS->HandleProtocol (
1322 CurHandle,
1323 &gEfiSimpleFileSystemProtocolGuid,
1324 (VOID**) &SimpleFs
1325 );
1326 if (Status == EFI_SUCCESS) {
1327 continue;
1328 }
1329
1330 Status = gBS->HandleProtocol (
1331 CurHandle,
1332 &gEfiLoadFileProtocolGuid,
1333 (VOID**) &LoadFile
1334 );
1335 if (Status == EFI_SUCCESS) {
1336 continue;
1337 }
1338
1339 NewMenuEntry = BOpt_CreateMenuEntry (BM_HANDLE_CONTEXT_SELECT);
1340 if (NULL == NewMenuEntry) {
1341 return EFI_OUT_OF_RESOURCES;
1342 }
1343
1344 NewHandleContext = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1345 NewHandleContext->Handle = CurHandle;
1346 NewHandleContext->DevicePath = DevicePathFromHandle (CurHandle);
1347 NewMenuEntry->DisplayString = DevicePathToStr (NewHandleContext->DevicePath);
1348 NewMenuEntry->HelpString = NULL;
1349 NewMenuEntry->OptionNumber = OptionNumber;
1350 OptionNumber++;
1351 InsertTailList (&DriverMenu.Head, &NewMenuEntry->Link);
1352
1353 }
1354
1355 DriverMenu.MenuNumber = OptionNumber;
1356 return EFI_SUCCESS;
1357 }
1358
1359 UINT16
1360 BOpt_GetBootOptionNumber (
1361 VOID
1362 )
1363 /*++
1364
1365 Routine Description:
1366 Get the Option Number that does not used
1367
1368 Arguments:
1369
1370 Returns:
1371 The Option Number
1372
1373 --*/
1374 {
1375 BM_MENU_ENTRY *NewMenuEntry;
1376 UINT16 *BootOrderList;
1377 UINTN BootOrderListSize;
1378 UINT16 Number;
1379 UINTN Index;
1380 UINTN Index2;
1381 BOOLEAN Found;
1382 CHAR16 StrTemp[100];
1383 UINT16 *OptionBuffer;
1384 UINTN OptionSize;
1385
1386 BootOrderListSize = 0;
1387 BootOrderList = NULL;
1388
1389 BootOrderList = BdsLibGetVariableAndSize (
1390 L"BootOrder",
1391 &gEfiGlobalVariableGuid,
1392 &BootOrderListSize
1393 );
1394 if (BootOrderList) {
1395 //
1396 // already have Boot####
1397 //
1398 // AlreadyBootNumbers = BootOrderListSize / sizeof(UINT16);
1399 //
1400 for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
1401 Found = TRUE;
1402 for (Index2 = 0; Index2 < BootOptionMenu.MenuNumber; Index2++) {
1403 NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index2);
1404 if (Index == NewMenuEntry->OptionNumber) {
1405 Found = FALSE;
1406 break;
1407 }
1408 }
1409
1410 if (Found) {
1411 UnicodeSPrint (StrTemp, 100, L"Boot%04x", Index);
1412 DEBUG((EFI_D_ERROR,"INdex= %s\n", StrTemp));
1413 OptionBuffer = BdsLibGetVariableAndSize (
1414 StrTemp,
1415 &gEfiGlobalVariableGuid,
1416 &OptionSize
1417 );
1418 if (NULL == OptionBuffer)
1419 break;
1420 }
1421 }
1422 //
1423 // end for Index
1424 //
1425 Number = (UINT16) Index;
1426 } else {
1427 //
1428 // No Boot####
1429 //
1430 Number = 0;
1431 }
1432
1433 return Number;
1434 }
1435
1436 UINT16
1437 BOpt_GetDriverOptionNumber (
1438 VOID
1439 )
1440 /*++
1441
1442 Routine Description:
1443 Get the Option Number that does not used
1444
1445 Arguments:
1446
1447 Returns:
1448 The Option Number
1449
1450 --*/
1451 {
1452 BM_MENU_ENTRY *NewMenuEntry;
1453 UINT16 *DriverOrderList;
1454 UINTN DriverOrderListSize;
1455 UINT16 Number;
1456 UINTN Index;
1457 UINTN Index2;
1458 BOOLEAN Found;
1459
1460 DriverOrderListSize = 0;
1461 DriverOrderList = NULL;
1462
1463 DriverOrderList = BdsLibGetVariableAndSize (
1464 L"DriverOrder",
1465 &gEfiGlobalVariableGuid,
1466 &DriverOrderListSize
1467 );
1468 if (DriverOrderList) {
1469 //
1470 // already have Driver####
1471 //
1472 // AlreadyDriverNumbers = DriverOrderListSize / sizeof(UINT16);
1473 //
1474 for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1475 Found = TRUE;
1476 for (Index2 = 0; Index2 < DriverOptionMenu.MenuNumber; Index2++) {
1477 NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index2);
1478 if (Index == NewMenuEntry->OptionNumber) {
1479 Found = FALSE;
1480 break;
1481 }
1482 }
1483
1484 if (Found) {
1485 break;
1486 }
1487 }
1488 //
1489 // end for Index
1490 //
1491 Number = (UINT16) Index;
1492 } else {
1493 //
1494 // No Driver####
1495 //
1496 Number = 0;
1497 }
1498
1499 return Number;
1500 }
1501
1502 EFI_STATUS
1503 BOpt_GetDriverOptions (
1504 IN BMM_CALLBACK_DATA *CallbackData
1505 )
1506 /*++
1507
1508 Routine Description:
1509 Build up all DriverOptionMenu
1510
1511 Arguments:
1512
1513 Returns:
1514 The Option Number
1515
1516 --*/
1517 {
1518 UINTN Index;
1519 UINT16 DriverString[12];
1520 UINT8 *LoadOptionFromVar;
1521 UINT8 *LoadOption;
1522 UINTN DriverOptionSize;
1523
1524 UINT16 *DriverOrderList;
1525 UINTN DriverOrderListSize;
1526 BM_MENU_ENTRY *NewMenuEntry;
1527 BM_LOAD_CONTEXT *NewLoadContext;
1528 UINT8 *LoadOptionPtr;
1529 UINTN StringSize;
1530 UINTN OptionalDataSize;
1531 UINT8 *LoadOptionEnd;
1532
1533 DriverOrderListSize = 0;
1534 DriverOrderList = NULL;
1535 DriverOptionSize = 0;
1536 LoadOptionFromVar = NULL;
1537 BOpt_FreeMenu (&DriverOptionMenu);
1538 InitializeListHead (&DriverOptionMenu.Head);
1539 //
1540 // Get the DriverOrder from the Var
1541 //
1542 DriverOrderList = BdsLibGetVariableAndSize (
1543 L"DriverOrder",
1544 &gEfiGlobalVariableGuid,
1545 &DriverOrderListSize
1546 );
1547
1548 for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1549 UnicodeSPrint (
1550 DriverString,
1551 sizeof (DriverString),
1552 L"Driver%04x",
1553 DriverOrderList[Index]
1554 );
1555 //
1556 // Get all loadoptions from the VAR
1557 //
1558 LoadOptionFromVar = BdsLibGetVariableAndSize (
1559 DriverString,
1560 &gEfiGlobalVariableGuid,
1561 &DriverOptionSize
1562 );
1563 if (!LoadOptionFromVar) {
1564 continue;
1565 }
1566
1567 LoadOption = AllocateZeroPool (DriverOptionSize);
1568 if (!LoadOption) {
1569 continue;
1570 }
1571
1572 CopyMem (LoadOption, LoadOptionFromVar, DriverOptionSize);
1573 SafeFreePool (LoadOptionFromVar);
1574
1575 NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
1576 if (NULL == NewMenuEntry) {
1577 return EFI_OUT_OF_RESOURCES;
1578 }
1579
1580 NewLoadContext = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1581 LoadOptionPtr = LoadOption;
1582 LoadOptionEnd = LoadOption + DriverOptionSize;
1583 NewMenuEntry->OptionNumber = DriverOrderList[Index];
1584 NewLoadContext->LoadOptionModified = FALSE;
1585 NewLoadContext->Deleted = FALSE;
1586 NewLoadContext->IsLegacy = FALSE;
1587
1588 //
1589 // LoadOption is a pointer type of UINT8
1590 // for easy use with following LOAD_OPTION
1591 // embedded in this struct
1592 //
1593 NewLoadContext->LoadOption = LoadOption;
1594 NewLoadContext->LoadOptionSize = DriverOptionSize;
1595
1596 NewLoadContext->Attributes = *(UINT32 *) LoadOptionPtr;
1597 NewLoadContext->IsActive = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1598
1599 NewLoadContext->ForceReconnect = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1600
1601 LoadOptionPtr += sizeof (UINT32);
1602
1603 NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1604 LoadOptionPtr += sizeof (UINT16);
1605
1606 StringSize = StrSize ((UINT16 *) LoadOptionPtr);
1607 NewLoadContext->Description = AllocateZeroPool (StringSize);
1608 ASSERT (NewLoadContext->Description != NULL);
1609 CopyMem (
1610 NewLoadContext->Description,
1611 (UINT16 *) LoadOptionPtr,
1612 StringSize
1613 );
1614 NewMenuEntry->DisplayString = NewLoadContext->Description;
1615
1616 LoadOptionPtr += StringSize;
1617
1618 NewLoadContext->FilePathList = AllocateZeroPool (NewLoadContext->FilePathListLength);
1619 ASSERT (NewLoadContext->FilePathList != NULL);
1620 CopyMem (
1621 NewLoadContext->FilePathList,
1622 (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1623 NewLoadContext->FilePathListLength
1624 );
1625
1626 NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1627 NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1628 CallbackData,
1629 DriverOptionStrDepository
1630 );
1631 NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1632 CallbackData,
1633 DriverOptionHelpStrDepository
1634 );
1635 LoadOptionPtr += NewLoadContext->FilePathListLength;
1636
1637 if (LoadOptionPtr < LoadOptionEnd) {
1638 OptionalDataSize = DriverOptionSize -
1639 sizeof (UINT32) -
1640 sizeof (UINT16) -
1641 StringSize -
1642 NewLoadContext->FilePathListLength;
1643
1644 NewLoadContext->OptionalData = AllocateZeroPool (OptionalDataSize);
1645 ASSERT (NewLoadContext->OptionalData != NULL);
1646 CopyMem (
1647 NewLoadContext->OptionalData,
1648 LoadOptionPtr,
1649 OptionalDataSize
1650 );
1651
1652 NewLoadContext->OptionalDataSize = OptionalDataSize;
1653 }
1654
1655 InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
1656
1657 }
1658
1659 SafeFreePool (DriverOrderList);
1660 DriverOptionMenu.MenuNumber = Index;
1661 return EFI_SUCCESS;
1662
1663 }
1664
1665 VOID
1666 SafeFreePool (
1667 IN VOID *Buffer
1668 )
1669 /*++
1670
1671 Routine Description:
1672 Wrap original FreePool gBS call
1673 in order to decrease code length
1674
1675 Arguments:
1676
1677 Returns:
1678
1679 --*/
1680 {
1681 if (Buffer != NULL) {
1682 gBS->FreePool (Buffer);
1683 Buffer = NULL;
1684 }
1685 }