MdeModulePkg/Universal/BdsDxe/BootMaint/BootOption.c

   1 /*++
   2 Copyright (c) 2004 - 2008, 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 = EfiAllocateZeroPool (sizeof (BM_MENU_ENTRY));
  91   if (NULL == MenuEntry) {
  92     return MenuEntry;
  93   }
  94
  95   MenuEntry->VariableContext = EfiAllocateZeroPool (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                     NoBlkIoHandles;
 254   UINTN                     NoSimpleFsHandles;
 255   UINTN                     NoLoadFileHandles;
 256   EFI_HANDLE                *BlkIoHandle;
 257   EFI_HANDLE                *SimpleFsHandle;
 258   EFI_HANDLE                *LoadFileHandle;
 259   UINT16                    *VolumeLabel;
 260   EFI_BLOCK_IO_PROTOCOL     *BlkIo;
 261   UINTN                     Index;
 262   EFI_STATUS                Status;
 263   BM_MENU_ENTRY             *MenuEntry;
 264   BM_FILE_CONTEXT           *FileContext;
 265   UINT16                    *TempStr;
 266   UINTN                     OptionNumber;
 267   VOID                      *Buffer;
 268   EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
 269   UINT16                    DeviceType;
 270   BBS_BBS_DEVICE_PATH       BbsDevicePathNode;
 271   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 272   BOOLEAN                   RemovableMedia;
 273
 274
 275   NoSimpleFsHandles = 0;
 276   NoLoadFileHandles = 0;
 277   OptionNumber      = 0;
 278   InitializeListHead (&FsOptionMenu.Head);
 279
 280   //
 281   // Locate Handles that support BlockIo protocol
 282   //
 283   Status = gBS->LocateHandleBuffer (
 284                   ByProtocol,
 285                   &gEfiBlockIoProtocolGuid,
 286                   NULL,
 287                   &NoBlkIoHandles,
 288                   &BlkIoHandle
 289                   );
 290   if (!EFI_ERROR (Status)) {
 291
 292     for (Index = 0; Index < NoBlkIoHandles; Index++) {
 293       Status = gBS->HandleProtocol (
 294                       BlkIoHandle[Index],
 295                       &gEfiBlockIoProtocolGuid,
 296                       (VOID **) &BlkIo
 297                       );
 298
 299       if (EFI_ERROR (Status)) {
 300         continue;
 301       }
 302
 303       //
 304       // Issue a dummy read to trigger reinstall of BlockIo protocol for removable media
 305       //
 306       if (BlkIo->Media->RemovableMedia) {
 307         Buffer = EfiAllocateZeroPool (BlkIo->Media->BlockSize);
 308         if (NULL == Buffer) {
 309           SafeFreePool (BlkIoHandle);
 310           return EFI_OUT_OF_RESOURCES;
 311         }
 312
 313         BlkIo->ReadBlocks (
 314                 BlkIo,
 315                 BlkIo->Media->MediaId,
 316                 0,
 317                 BlkIo->Media->BlockSize,
 318                 Buffer
 319                 );
 320         SafeFreePool (Buffer);
 321       }
 322     }
 323     SafeFreePool (BlkIoHandle);
 324   }
 325
 326   //
 327   // Locate Handles that support Simple File System protocol
 328   //
 329   Status = gBS->LocateHandleBuffer (
 330                   ByProtocol,
 331                   &gEfiSimpleFileSystemProtocolGuid,
 332                   NULL,
 333                   &NoSimpleFsHandles,
 334                   &SimpleFsHandle
 335                   );
 336   if (!EFI_ERROR (Status)) {
 337     //
 338     // Find all the instances of the File System prototocol
 339     //
 340     for (Index = 0; Index < NoSimpleFsHandles; Index++) {
 341       Status = gBS->HandleProtocol (
 342                       SimpleFsHandle[Index],
 343                       &gEfiBlockIoProtocolGuid,
 344                       (VOID **) &BlkIo
 345                       );
 346       if (EFI_ERROR (Status)) {
 347         //
 348         // If no block IO exists assume it's NOT a removable media
 349         //
 350         RemovableMedia = FALSE;
 351       } else {
 352         //
 353         // If block IO exists check to see if it's remobable media
 354         //
 355         RemovableMedia = BlkIo->Media->RemovableMedia;
 356       }
 357
 358       //
 359       // Allocate pool for this load option
 360       //
 361       MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 362       if (NULL == MenuEntry) {
 363         SafeFreePool (SimpleFsHandle);
 364         return EFI_OUT_OF_RESOURCES;
 365       }
 366
 367       FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 368
 369       FileContext->Handle     = SimpleFsHandle[Index];
 370       MenuEntry->OptionNumber = Index;
 371       FileContext->FHandle    = EfiLibOpenRoot (FileContext->Handle);
 372       if (!FileContext->FHandle) {
 373         BOpt_DestroyMenuEntry (MenuEntry);
 374         continue;
 375       }
 376
 377       MenuEntry->HelpString = DevicePathToStr (DevicePathFromHandle (FileContext->Handle));
 378       FileContext->Info = EfiLibFileSystemVolumeLabelInfo (FileContext->FHandle);
 379       FileContext->FileName = EfiStrDuplicate (L"\\");
 380       FileContext->DevicePath = FileDevicePath (
 381                                   FileContext->Handle,
 382                                   FileContext->FileName
 383                                   );
 384       FileContext->IsDir            = TRUE;
 385       FileContext->IsRoot           = TRUE;
 386       FileContext->IsRemovableMedia = RemovableMedia;
 387       FileContext->IsLoadFile       = FALSE;
 388
 389       //
 390       // Get current file system's Volume Label
 391       //
 392       if (FileContext->Info == NULL) {
 393         VolumeLabel = L"NO FILE SYSTEM INFO";
 394       } else {
 395         if (FileContext->Info->VolumeLabel == NULL) {
 396           VolumeLabel = L"NULL VOLUME LABEL";
 397         } else {
 398           VolumeLabel = FileContext->Info->VolumeLabel;
 399           if (*VolumeLabel == 0x0000) {
 400             VolumeLabel = L"NO VOLUME LABEL";
 401           }
 402         }
 403       }
 404
 405       TempStr                   = MenuEntry->HelpString;
 406       MenuEntry->DisplayString  = EfiAllocateZeroPool (MAX_CHAR);
 407       ASSERT (MenuEntry->DisplayString != NULL);
 408       UnicodeSPrint (
 409         MenuEntry->DisplayString,
 410         MAX_CHAR,
 411         L"%s, [%s]",
 412         VolumeLabel,
 413         TempStr
 414         );
 415       OptionNumber++;
 416       InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
 417     }
 418   }
 419
 420   if (NoSimpleFsHandles != 0) {
 421     SafeFreePool (SimpleFsHandle);
 422   }
 423   //
 424   // Searching for handles that support Load File protocol
 425   //
 426   Status = gBS->LocateHandleBuffer (
 427                   ByProtocol,
 428                   &gEfiLoadFileProtocolGuid,
 429                   NULL,
 430                   &NoLoadFileHandles,
 431                   &LoadFileHandle
 432                   );
 433
 434   if (!EFI_ERROR (Status)) {
 435     for (Index = 0; Index < NoLoadFileHandles; Index++) {
 436       MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 437       if (NULL == MenuEntry) {
 438         SafeFreePool (LoadFileHandle);
 439         return EFI_OUT_OF_RESOURCES;
 440       }
 441
 442       FileContext                   = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 443       FileContext->IsRemovableMedia = FALSE;
 444       FileContext->IsLoadFile       = TRUE;
 445       FileContext->Handle           = LoadFileHandle[Index];
 446       FileContext->IsRoot           = TRUE;
 447
 448       FileContext->DevicePath = DevicePathFromHandle (FileContext->Handle);
 449
 450       MenuEntry->HelpString     = DevicePathToStr (FileContext->DevicePath);
 451
 452       TempStr                   = MenuEntry->HelpString;
 453       MenuEntry->DisplayString  = EfiAllocateZeroPool (MAX_CHAR);
 454       ASSERT (MenuEntry->DisplayString != NULL);
 455       UnicodeSPrint (
 456         MenuEntry->DisplayString,
 457         MAX_CHAR,
 458         L"Load File [%s]",
 459         TempStr
 460         );
 461
 462       MenuEntry->OptionNumber = OptionNumber;
 463       OptionNumber++;
 464       InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
 465     }
 466   }
 467
 468   if (NoLoadFileHandles != 0) {
 469     SafeFreePool (LoadFileHandle);
 470   }
 471
 472   //
 473   // Add Legacy Boot Option Support Here
 474   //
 475   Status = gBS->LocateProtocol (
 476                   &gEfiLegacyBiosProtocolGuid,
 477                   NULL,
 478                   (VOID **) &LegacyBios
 479                   );
 480   if (!EFI_ERROR (Status)) {
 481
 482     for (Index = BBS_TYPE_FLOPPY; Index <= BBS_TYPE_EMBEDDED_NETWORK; Index++) {
 483       MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 484       if (NULL == MenuEntry) {
 485         return EFI_OUT_OF_RESOURCES;
 486       }
 487
 488       FileContext                       = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 489
 490       FileContext->IsRemovableMedia     = FALSE;
 491       FileContext->IsLoadFile           = TRUE;
 492       FileContext->IsBootLegacy         = TRUE;
 493       DeviceType                        = (UINT16) Index;
 494       BbsDevicePathNode.Header.Type     = BBS_DEVICE_PATH;
 495       BbsDevicePathNode.Header.SubType  = BBS_BBS_DP;
 496       SetDevicePathNodeLength (
 497         &BbsDevicePathNode.Header,
 498         sizeof (BBS_BBS_DEVICE_PATH)
 499         );
 500       BbsDevicePathNode.DeviceType  = DeviceType;
 501       BbsDevicePathNode.StatusFlag  = 0;
 502       BbsDevicePathNode.String[0]   = 0;
 503       DevicePath = AppendDevicePathNode (
 504                     EndDevicePath,
 505                     (EFI_DEVICE_PATH_PROTOCOL *) &BbsDevicePathNode
 506                     );
 507
 508       FileContext->DevicePath   = DevicePath;
 509       MenuEntry->HelpString     = DevicePathToStr (FileContext->DevicePath);
 510
 511       TempStr                   = MenuEntry->HelpString;
 512       MenuEntry->DisplayString  = EfiAllocateZeroPool (MAX_CHAR);
 513       ASSERT (MenuEntry->DisplayString != NULL);
 514       UnicodeSPrint (
 515         MenuEntry->DisplayString,
 516         MAX_CHAR,
 517         L"Boot Legacy [%s]",
 518         TempStr
 519         );
 520       MenuEntry->OptionNumber = OptionNumber;
 521       OptionNumber++;
 522       InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
 523     }
 524   }
 525   //
 526   // Remember how many file system options are here
 527   //
 528   FsOptionMenu.MenuNumber = OptionNumber;
 529   return EFI_SUCCESS;
 530 }
 531
 532 VOID
 533 BOpt_FreeMenu (
 534   BM_MENU_OPTION        *FreeMenu
 535   )
 536 /*++
 537
 538 Routine Description
 539   Free resources allocated in Allocate Rountine
 540
 541 Arguments:
 542   FreeMenu        Menu to be freed
 543
 544 Returns:
 545   VOID
 546
 547 --*/
 548 {
 549   BM_MENU_ENTRY *MenuEntry;
 550   while (!IsListEmpty (&FreeMenu->Head)) {
 551     MenuEntry = CR (
 552                   FreeMenu->Head.ForwardLink,
 553                   BM_MENU_ENTRY,
 554                   Link,
 555                   BM_MENU_ENTRY_SIGNATURE
 556                   );
 557     RemoveEntryList (&MenuEntry->Link);
 558     BOpt_DestroyMenuEntry (MenuEntry);
 559   }
 560 }
 561
 562 EFI_STATUS
 563 BOpt_FindFiles (
 564   IN BMM_CALLBACK_DATA          *CallbackData,
 565   IN BM_MENU_ENTRY              *MenuEntry
 566   )
 567 /*++
 568
 569 Routine Description
 570   Find files under current directory
 571   All files and sub-directories in current directory
 572   will be stored in DirectoryMenu for future use.
 573
 574 Arguments:
 575   FileOption   -- Pointer for Dir to explore
 576
 577 Returns:
 578   TRUE         -- Get files from current dir successfully
 579   FALSE        -- Can't get files from current dir
 580
 581 --*/
 582 {
 583   EFI_FILE_HANDLE NewDir;
 584   EFI_FILE_HANDLE Dir;
 585   EFI_FILE_INFO   *DirInfo;
 586   UINTN           BufferSize;
 587   UINTN           DirBufferSize;
 588   BM_MENU_ENTRY   *NewMenuEntry;
 589   BM_FILE_CONTEXT *FileContext;
 590   BM_FILE_CONTEXT *NewFileContext;
 591   UINTN           Pass;
 592   EFI_STATUS      Status;
 593   UINTN           OptionNumber;
 594
 595   FileContext   = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 596   Dir           = FileContext->FHandle;
 597   OptionNumber  = 0;
 598   //
 599   // Open current directory to get files from it
 600   //
 601   Status = Dir->Open (
 602                   Dir,
 603                   &NewDir,
 604                   FileContext->FileName,
 605                   EFI_FILE_READ_ONLY,
 606                   0
 607                   );
 608   if (!FileContext->IsRoot) {
 609     Dir->Close (Dir);
 610   }
 611
 612   if (EFI_ERROR (Status)) {
 613     return Status;
 614   }
 615
 616   DirInfo = EfiLibFileInfo (NewDir);
 617   if (!DirInfo) {
 618     return EFI_NOT_FOUND;
 619   }
 620
 621   if (!(DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
 622     return EFI_INVALID_PARAMETER;
 623   }
 624
 625   FileContext->DevicePath = FileDevicePath (
 626                               FileContext->Handle,
 627                               FileContext->FileName
 628                               );
 629
 630   DirBufferSize = sizeof (EFI_FILE_INFO) + 1024;
 631   DirInfo       = EfiAllocateZeroPool (DirBufferSize);
 632   if (!DirInfo) {
 633     return EFI_OUT_OF_RESOURCES;
 634   }
 635   //
 636   // Get all files in current directory
 637   // Pass 1 to get Directories
 638   // Pass 2 to get files that are EFI images
 639   //
 640   for (Pass = 1; Pass <= 2; Pass++) {
 641     NewDir->SetPosition (NewDir, 0);
 642     for (;;) {
 643       BufferSize  = DirBufferSize;
 644       Status      = NewDir->Read (NewDir, &BufferSize, DirInfo);
 645       if (EFI_ERROR (Status) || BufferSize == 0) {
 646         break;
 647       }
 648
 649       if ((DirInfo->Attribute & EFI_FILE_DIRECTORY && Pass == 2) ||
 650           (!(DirInfo->Attribute & EFI_FILE_DIRECTORY) && Pass == 1)
 651           ) {
 652         //
 653         // Pass 1 is for Directories
 654         // Pass 2 is for file names
 655         //
 656         continue;
 657       }
 658
 659       if (!(BOpt_IsEfiImageName (DirInfo->FileName) || DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
 660         //
 661         // Slip file unless it is a directory entry or a .EFI file
 662         //
 663         continue;
 664       }
 665
 666       NewMenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 667       if (NULL == NewMenuEntry) {
 668         return EFI_OUT_OF_RESOURCES;
 669       }
 670
 671       NewFileContext          = (BM_FILE_CONTEXT *) NewMenuEntry->VariableContext;
 672       NewFileContext->Handle  = FileContext->Handle;
 673       NewFileContext->FileName = BOpt_AppendFileName (
 674                                   FileContext->FileName,
 675                                   DirInfo->FileName
 676                                   );
 677       NewFileContext->FHandle = NewDir;
 678       NewFileContext->DevicePath = FileDevicePath (
 679                                     NewFileContext->Handle,
 680                                     NewFileContext->FileName
 681                                     );
 682       NewMenuEntry->HelpString = NULL;
 683
 684       MenuEntry->DisplayStringToken = GetStringTokenFromDepository (
 685                                         CallbackData,
 686                                         FileOptionStrDepository
 687                                         );
 688
 689       NewFileContext->IsDir = (BOOLEAN) ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY);
 690
 691       if (NewFileContext->IsDir) {
 692         BufferSize                  = StrLen (DirInfo->FileName) * 2 + 6;
 693         NewMenuEntry->DisplayString = EfiAllocateZeroPool (BufferSize);
 694
 695         UnicodeSPrint (
 696           NewMenuEntry->DisplayString,
 697           BufferSize,
 698           L"<%s>",
 699           DirInfo->FileName
 700           );
 701
 702       } else {
 703         NewMenuEntry->DisplayString = EfiStrDuplicate (DirInfo->FileName);
 704       }
 705
 706       NewFileContext->IsRoot            = FALSE;
 707       NewFileContext->IsLoadFile        = FALSE;
 708       NewFileContext->IsRemovableMedia  = FALSE;
 709
 710       NewMenuEntry->OptionNumber        = OptionNumber;
 711       OptionNumber++;
 712       InsertTailList (&DirectoryMenu.Head, &NewMenuEntry->Link);
 713     }
 714   }
 715
 716   DirectoryMenu.MenuNumber = OptionNumber;
 717   SafeFreePool (DirInfo);
 718   return EFI_SUCCESS;
 719 }
 720
 721 EFI_STATUS
 722 BOpt_GetLegacyOptions (
 723   VOID
 724   )
 725 /*++
 726 Routine Description:
 727
 728   Build the LegacyFDMenu LegacyHDMenu LegacyCDMenu according to LegacyBios.GetBbsInfo().
 729
 730 Arguments:
 731   None
 732
 733 Returns:
 734   The device info of legacy device.
 735
 736 --*/
 737 {
 738   BM_MENU_ENTRY             *NewMenuEntry;
 739   BM_LEGACY_DEVICE_CONTEXT  *NewLegacyDevContext;
 740   EFI_STATUS                Status;
 741   EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
 742   UINT16                    HddCount;
 743   HDD_INFO                  *HddInfo;
 744   UINT16                    BbsCount;
 745   BBS_TABLE                 *BbsTable;
 746   UINTN                     Index;
 747   CHAR16                    DescString[100];
 748   UINTN                     FDNum;
 749   UINTN                     HDNum;
 750   UINTN                     CDNum;
 751   UINTN                     NETNum;
 752   UINTN                     BEVNum;
 753
 754   NewMenuEntry  = NULL;
 755   HddInfo       = NULL;
 756   BbsTable      = NULL;
 757   BbsCount      = 0;
 758
 759   //
 760   // Initialize Bbs Table Context from BBS info data
 761   //
 762   InitializeListHead (&LegacyFDMenu.Head);
 763   InitializeListHead (&LegacyHDMenu.Head);
 764   InitializeListHead (&LegacyCDMenu.Head);
 765   InitializeListHead (&LegacyNETMenu.Head);
 766   InitializeListHead (&LegacyBEVMenu.Head);
 767
 768   Status = gBS->LocateProtocol (
 769                   &gEfiLegacyBiosProtocolGuid,
 770                   NULL,
 771                   (VOID **) &LegacyBios
 772                   );
 773   if (!EFI_ERROR (Status)) {
 774     Status = LegacyBios->GetBbsInfo (
 775                           LegacyBios,
 776                           &HddCount,
 777                           &HddInfo,
 778                           &BbsCount,
 779                           &BbsTable
 780                           );
 781     if (EFI_ERROR (Status)) {
 782       return Status;
 783     }
 784   }
 785
 786   FDNum   = 0;
 787   HDNum   = 0;
 788   CDNum   = 0;
 789   NETNum  = 0;
 790   BEVNum  = 0;
 791
 792   for (Index = 0; Index < BbsCount; Index++) {
 793     if ((BBS_IGNORE_ENTRY == BbsTable[Index].BootPriority) ||
 794         (BBS_DO_NOT_BOOT_FROM == BbsTable[Index].BootPriority)
 795         ) {
 796       continue;
 797     }
 798
 799     NewMenuEntry = BOpt_CreateMenuEntry (BM_LEGACY_DEV_CONTEXT_SELECT);
 800     if (NULL == NewMenuEntry) {
 801       break;
 802     }
 803
 804     NewLegacyDevContext           = (BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext;
 805     NewLegacyDevContext->BbsTable = &BbsTable[Index];
 806     NewLegacyDevContext->Index    = Index;
 807     NewLegacyDevContext->BbsCount = BbsCount;
 808     BdsBuildLegacyDevNameString (
 809       &BbsTable[Index],
 810       Index,
 811       sizeof (DescString),
 812       DescString
 813       );
 814     NewLegacyDevContext->Description = EfiAllocateZeroPool (StrSize (DescString));
 815     if (NULL == NewLegacyDevContext->Description) {
 816       break;
 817     }
 818
 819     CopyMem (NewLegacyDevContext->Description, DescString, StrSize (DescString));
 820     NewMenuEntry->DisplayString = NewLegacyDevContext->Description;
 821     NewMenuEntry->HelpString    = NULL;
 822
 823     switch (BbsTable[Index].DeviceType) {
 824     case BBS_FLOPPY:
 825       InsertTailList (&LegacyFDMenu.Head, &NewMenuEntry->Link);
 826       FDNum++;
 827       break;
 828
 829     case BBS_HARDDISK:
 830       InsertTailList (&LegacyHDMenu.Head, &NewMenuEntry->Link);
 831       HDNum++;
 832       break;
 833
 834     case BBS_CDROM:
 835       InsertTailList (&LegacyCDMenu.Head, &NewMenuEntry->Link);
 836       CDNum++;
 837       break;
 838
 839     case BBS_EMBED_NETWORK:
 840       InsertTailList (&LegacyNETMenu.Head, &NewMenuEntry->Link);
 841       NETNum++;
 842       break;
 843
 844     case BBS_BEV_DEVICE:
 845       InsertTailList (&LegacyBEVMenu.Head, &NewMenuEntry->Link);
 846       BEVNum++;
 847       break;
 848     }
 849   }
 850
 851   if (Index != BbsCount) {
 852     BOpt_FreeLegacyOptions ();
 853     return EFI_OUT_OF_RESOURCES;
 854   }
 855
 856   LegacyFDMenu.MenuNumber   = FDNum;
 857   LegacyHDMenu.MenuNumber   = HDNum;
 858   LegacyCDMenu.MenuNumber   = CDNum;
 859   LegacyNETMenu.MenuNumber  = NETNum;
 860   LegacyBEVMenu.MenuNumber  = BEVNum;
 861   return EFI_SUCCESS;
 862 }
 863
 864 VOID
 865 BOpt_FreeLegacyOptions (
 866   VOID
 867   )
 868 {
 869   BOpt_FreeMenu (&LegacyFDMenu);
 870   BOpt_FreeMenu (&LegacyHDMenu);
 871   BOpt_FreeMenu (&LegacyCDMenu);
 872   BOpt_FreeMenu (&LegacyNETMenu);
 873   BOpt_FreeMenu (&LegacyBEVMenu);
 874 }
 875
 876 EFI_STATUS
 877 BOpt_GetBootOptions (
 878   IN  BMM_CALLBACK_DATA         *CallbackData
 879   )
 880 /*++
 881
 882 Routine Description:
 883
 884   Build the BootOptionMenu according to BootOrder Variable.
 885   This Routine will access the Boot#### to get EFI_LOAD_OPTION
 886
 887 Arguments:
 888   None
 889
 890 Returns:
 891   The number of the Var Boot####
 892
 893 --*/
 894 {
 895   UINTN                     Index;
 896   UINT16                    BootString[10];
 897   UINT8                     *LoadOptionFromVar;
 898   UINT8                     *LoadOption;
 899   UINTN                     BootOptionSize;
 900   BOOLEAN                   BootNextFlag;
 901   UINT16                    *BootOrderList;
 902   UINTN                     BootOrderListSize;
 903   UINT16                    *BootNext;
 904   UINTN                     BootNextSize;
 905   BM_MENU_ENTRY             *NewMenuEntry;
 906   BM_LOAD_CONTEXT           *NewLoadContext;
 907   UINT8                     *LoadOptionPtr;
 908   UINTN                     StringSize;
 909   UINTN                     OptionalDataSize;
 910   UINT8                     *LoadOptionEnd;
 911   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 912   UINTN                     MenuCount;
 913   UINT8                     *Ptr;
 914
 915   MenuCount         = 0;
 916   BootOrderListSize = 0;
 917   BootNextSize      = 0;
 918   BootOrderList     = NULL;
 919   BootNext          = NULL;
 920   LoadOptionFromVar = NULL;
 921   BOpt_FreeMenu (&BootOptionMenu);
 922   InitializeListHead (&BootOptionMenu.Head);
 923
 924   //
 925   // Get the BootOrder from the Var
 926   //
 927   BootOrderList = BdsLibGetVariableAndSize (
 928                     L"BootOrder",
 929                     &gEfiGlobalVariableGuid,
 930                     &BootOrderListSize
 931                     );
 932
 933   //
 934   // Get the BootNext from the Var
 935   //
 936   BootNext = BdsLibGetVariableAndSize (
 937               L"BootNext",
 938               &gEfiGlobalVariableGuid,
 939               &BootNextSize
 940               );
 941
 942   if (BootNext) {
 943     if (BootNextSize != sizeof (UINT16)) {
 944       SafeFreePool (BootNext);
 945       BootNext = NULL;
 946     }
 947   }
 948
 949   for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
 950     UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", BootOrderList[Index]);
 951     //
 952     //  Get all loadoptions from the VAR
 953     //
 954     LoadOptionFromVar = BdsLibGetVariableAndSize (
 955                           BootString,
 956                           &gEfiGlobalVariableGuid,
 957                           &BootOptionSize
 958                           );
 959     if (!LoadOptionFromVar) {
 960       continue;
 961     }
 962
 963     LoadOption = EfiAllocateZeroPool (BootOptionSize);
 964     if (!LoadOption) {
 965       continue;
 966     }
 967
 968     CopyMem (LoadOption, LoadOptionFromVar, BootOptionSize);
 969     SafeFreePool (LoadOptionFromVar);
 970
 971     if (BootNext) {
 972       BootNextFlag = (BOOLEAN) (*BootNext == BootOrderList[Index]);
 973     } else {
 974       BootNextFlag = FALSE;
 975     }
 976
 977     if (0 == (*((UINT32 *) LoadOption) & LOAD_OPTION_ACTIVE)) {
 978       SafeFreePool (LoadOption);
 979       continue;
 980     }
 981     //
 982     // BUGBUG: could not return EFI_OUT_OF_RESOURCES here directly.
 983     // the buffer allocated already should be freed before returning.
 984     //
 985     NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 986     if (NULL == NewMenuEntry) {
 987       return EFI_OUT_OF_RESOURCES;
 988     }
 989
 990     NewLoadContext                      = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 991
 992     LoadOptionPtr                       = LoadOption;
 993     LoadOptionEnd                       = LoadOption + BootOptionSize;
 994
 995     NewMenuEntry->OptionNumber          = BootOrderList[Index];
 996     NewLoadContext->LoadOptionModified  = FALSE;
 997     NewLoadContext->Deleted             = FALSE;
 998     NewLoadContext->IsBootNext          = BootNextFlag;
 999
1000     //
1001     // Is a Legacy Device?
1002     //
1003     Ptr = (UINT8 *) LoadOption;
1004
1005     //
1006     // Attribute = *(UINT32 *)Ptr;
1007     //
1008     Ptr += sizeof (UINT32);
1009
1010     //
1011     // FilePathSize = *(UINT16 *)Ptr;
1012     //
1013     Ptr += sizeof (UINT16);
1014
1015     //
1016     // Description = (CHAR16 *)Ptr;
1017     //
1018     Ptr += StrSize ((CHAR16 *) Ptr);
1019
1020     //
1021     // Now Ptr point to Device Path
1022     //
1023     DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
1024     if ((BBS_DEVICE_PATH == DevicePath->Type) && (BBS_BBS_DP == DevicePath->SubType)) {
1025       NewLoadContext->IsLegacy = TRUE;
1026     } else {
1027       NewLoadContext->IsLegacy = FALSE;
1028     }
1029     //
1030     // LoadOption is a pointer type of UINT8
1031     // for easy use with following LOAD_OPTION
1032     // embedded in this struct
1033     //
1034     NewLoadContext->LoadOption      = LoadOption;
1035     NewLoadContext->LoadOptionSize  = BootOptionSize;
1036
1037     NewLoadContext->Attributes      = *(UINT32 *) LoadOptionPtr;
1038     NewLoadContext->IsActive        = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1039
1040     NewLoadContext->ForceReconnect  = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1041
1042     LoadOptionPtr += sizeof (UINT32);
1043
1044     NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1045     LoadOptionPtr += sizeof (UINT16);
1046
1047     StringSize                  = StrSize ((UINT16 *) LoadOptionPtr);
1048     NewLoadContext->Description = EfiAllocateZeroPool (StringSize);
1049     ASSERT (NewLoadContext->Description != NULL);
1050     CopyMem (
1051       NewLoadContext->Description,
1052       (UINT16 *) LoadOptionPtr,
1053       StringSize
1054       );
1055     NewMenuEntry->DisplayString = NewLoadContext->Description;
1056
1057     LoadOptionPtr += StringSize;
1058
1059     NewLoadContext->FilePathList = EfiAllocateZeroPool (NewLoadContext->FilePathListLength);
1060     ASSERT (NewLoadContext->FilePathList != NULL);
1061     CopyMem (
1062       NewLoadContext->FilePathList,
1063       (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1064       NewLoadContext->FilePathListLength
1065       );
1066
1067     NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1068     NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1069                                         CallbackData,
1070                                         BootOptionStrDepository
1071                                         );
1072     NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1073                                       CallbackData,
1074                                       BootOptionHelpStrDepository
1075                                       );
1076     LoadOptionPtr += NewLoadContext->FilePathListLength;
1077
1078     if (LoadOptionPtr < LoadOptionEnd) {
1079       OptionalDataSize = BootOptionSize -
1080         sizeof (UINT32) -
1081         sizeof (UINT16) -
1082         StringSize -
1083         NewLoadContext->FilePathListLength;
1084
1085       NewLoadContext->OptionalData = EfiAllocateZeroPool (OptionalDataSize);
1086       ASSERT (NewLoadContext->OptionalData != NULL);
1087       CopyMem (
1088         NewLoadContext->OptionalData,
1089         LoadOptionPtr,
1090         OptionalDataSize
1091         );
1092
1093       NewLoadContext->OptionalDataSize = OptionalDataSize;
1094     }
1095
1096     InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
1097     MenuCount++;
1098   }
1099
1100   SafeFreePool (BootNext);
1101   SafeFreePool (BootOrderList);
1102   BootOptionMenu.MenuNumber = MenuCount;
1103   return MenuCount;
1104 }
1105
1106 CHAR16 *
1107 BdsStrCpy (
1108   OUT     CHAR16                    *Destination,
1109   IN      CONST CHAR16              *Source
1110   )
1111 {
1112   CHAR16                            *ReturnValue;
1113
1114   //
1115   // Destination cannot be NULL
1116   //
1117   ASSERT (Destination != NULL);
1118
1119   ReturnValue = Destination;
1120   while (*Source) {
1121     *(Destination++) = *(Source++);
1122   }
1123   *Destination = 0;
1124   return ReturnValue;
1125 }
1126
1127 CHAR16 *
1128 BOpt_AppendFileName (
1129   IN  CHAR16  *Str1,
1130   IN  CHAR16  *Str2
1131   )
1132 /*++
1133
1134 Routine Description
1135   Append file name to existing file name.
1136
1137 Arguments:
1138   Str1  -   existing file name
1139   Str2  -   file name to be appended
1140
1141 Returns:
1142   Allocate a new string to hold the appended result.
1143   Caller is responsible to free the returned string.
1144
1145 --*/
1146 {
1147   UINTN   Size1;
1148   UINTN   Size2;
1149   CHAR16  *Str;
1150   CHAR16  *Ptr;
1151   CHAR16  *LastSlash;
1152
1153   Size1 = StrSize (Str1);
1154   Size2 = StrSize (Str2);
1155   Str   = EfiAllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
1156   ASSERT (Str != NULL);
1157
1158   StrCat (Str, Str1);
1159   if (!((*Str == '\\') && (*(Str + 1) == 0))) {
1160     StrCat (Str, L"\\");
1161   }
1162
1163   StrCat (Str, Str2);
1164
1165   Ptr       = Str;
1166   LastSlash = Str;
1167   while (*Ptr != 0) {
1168     if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '.' && *(Ptr + 3) != 0) {
1169       //
1170       // Convert \Name\..\ to \
1171       // DO NOT convert the .. if it is at the end of the string. This will
1172       // break the .. behavior in changing directories.
1173       //
1174       BdsStrCpy (LastSlash, Ptr + 3);
1175       Ptr = LastSlash;
1176     } else if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '\\') {
1177       //
1178       // Convert a \.\ to a \
1179       //
1180       BdsStrCpy (Ptr, Ptr + 2);
1181       Ptr = LastSlash;
1182     } else if (*Ptr == '\\') {
1183       LastSlash = Ptr;
1184     }
1185
1186     Ptr++;
1187   }
1188
1189   return Str;
1190 }
1191
1192 BOOLEAN
1193 BOpt_IsEfiImageName (
1194   IN UINT16  *FileName
1195   )
1196 /*++
1197
1198 Routine Description
1199   Check whether current FileName point to a valid
1200   Efi Image File.
1201
1202 Arguments:
1203   FileName  -   File need to be checked.
1204
1205 Returns:
1206   TRUE  -   Is Efi Image
1207   FALSE -   Not a valid Efi Image
1208
1209 --*/
1210 {
1211   //
1212   // Search for ".efi" extension
1213   //
1214   while (*FileName) {
1215     if (FileName[0] == '.') {
1216       if (FileName[1] == 'e' || FileName[1] == 'E') {
1217         if (FileName[2] == 'f' || FileName[2] == 'F') {
1218           if (FileName[3] == 'i' || FileName[3] == 'I') {
1219             return TRUE;
1220           } else if (FileName[3] == 0x0000) {
1221             return FALSE;
1222           }
1223         } else if (FileName[2] == 0x0000) {
1224           return FALSE;
1225         }
1226       } else if (FileName[1] == 0x0000) {
1227         return FALSE;
1228       }
1229     }
1230
1231     FileName += 1;
1232   }
1233
1234   return FALSE;
1235 }
1236
1237 BOOLEAN
1238 BOpt_IsEfiApp (
1239   IN EFI_FILE_HANDLE Dir,
1240   IN UINT16          *FileName
1241   )
1242 /*++
1243
1244 Routine Description:
1245   Check whether current FileName point to a valid Efi Application
1246
1247 Arguments:
1248   Dir       -   Pointer to current Directory
1249   FileName  -   Pointer to current File name.
1250
1251 Returns:
1252   TRUE      -   Is a valid Efi Application
1253   FALSE     -   not a valid Efi Application
1254
1255 --*/
1256 {
1257   UINTN                       BufferSize;
1258   EFI_IMAGE_DOS_HEADER        DosHdr;
1259   UINT16                      Subsystem;
1260   EFI_FILE_HANDLE             File;
1261   EFI_STATUS                  Status;
1262   EFI_IMAGE_OPTIONAL_HEADER_UNION PeHdr;
1263
1264   Status = Dir->Open (Dir, &File, FileName, EFI_FILE_MODE_READ, 0);
1265
1266   if (EFI_ERROR (Status)) {
1267     return FALSE;
1268   }
1269
1270   BufferSize = sizeof (EFI_IMAGE_DOS_HEADER);
1271   File->Read (File, &BufferSize, &DosHdr);
1272   if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {
1273     File->Close (File);
1274     return FALSE;
1275   }
1276
1277   File->SetPosition (File, DosHdr.e_lfanew);
1278   BufferSize = sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION);
1279   File->Read (File, &BufferSize, &PeHdr);
1280   if (PeHdr.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {
1281     File->Close (File);
1282     return FALSE;
1283   }
1284   //
1285   // Determine PE type and read subsytem
1286   //
1287   if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
1288     Subsystem = PeHdr.Pe32.OptionalHeader.Subsystem;
1289   } else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
1290     Subsystem = PeHdr.Pe32Plus.OptionalHeader.Subsystem;
1291   } else {
1292     return FALSE;
1293   }
1294
1295   if (Subsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1296     File->Close (File);
1297     return TRUE;
1298   } else {
1299     File->Close (File);
1300     return FALSE;
1301   }
1302 }
1303
1304 EFI_STATUS
1305 BOpt_FindDrivers (
1306   VOID
1307   )
1308 /*++
1309
1310 Routine Description
1311   Find drivers that will be added as Driver#### variables from handles
1312   in current system environment
1313   All valid handles in the system except those consume SimpleFs, LoadFile
1314   are stored in DriverMenu for future use.
1315
1316 Arguments:
1317   None
1318
1319 Returns:
1320   EFI_SUCCESS
1321   Others
1322
1323 --*/
1324 {
1325   UINTN                           NoDevicePathHandles;
1326   EFI_HANDLE                      *DevicePathHandle;
1327   UINTN                           Index;
1328   EFI_STATUS                      Status;
1329   BM_MENU_ENTRY                   *NewMenuEntry;
1330   BM_HANDLE_CONTEXT               *NewHandleContext;
1331   EFI_HANDLE                      CurHandle;
1332   UINTN                           OptionNumber;
1333   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
1334   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
1335
1336   SimpleFs  = NULL;
1337   LoadFile  = NULL;
1338
1339   InitializeListHead (&DriverMenu.Head);
1340
1341   //
1342   // At first, get all handles that support Device Path
1343   // protocol which is the basic requirement for
1344   // Driver####
1345   //
1346   Status = gBS->LocateHandleBuffer (
1347                   ByProtocol,
1348                   &gEfiDevicePathProtocolGuid,
1349                   NULL,
1350                   &NoDevicePathHandles,
1351                   &DevicePathHandle
1352                   );
1353   if (EFI_ERROR (Status)) {
1354     return Status;
1355   }
1356
1357   OptionNumber = 0;
1358   for (Index = 0; Index < NoDevicePathHandles; Index++) {
1359     CurHandle = DevicePathHandle[Index];
1360
1361     //
1362     //  Check whether this handle support
1363     //  driver binding
1364     //
1365     Status = gBS->HandleProtocol (
1366                     CurHandle,
1367                     &gEfiSimpleFileSystemProtocolGuid,
1368                     (VOID **) &SimpleFs
1369                     );
1370     if (Status == EFI_SUCCESS) {
1371       continue;
1372     }
1373
1374     Status = gBS->HandleProtocol (
1375                     CurHandle,
1376                     &gEfiLoadFileProtocolGuid,
1377                     (VOID **) &LoadFile
1378                     );
1379     if (Status == EFI_SUCCESS) {
1380       continue;
1381     }
1382
1383     NewMenuEntry = BOpt_CreateMenuEntry (BM_HANDLE_CONTEXT_SELECT);
1384     if (NULL == NewMenuEntry) {
1385       SafeFreePool (DevicePathHandle);
1386       return EFI_OUT_OF_RESOURCES;
1387     }
1388
1389     NewHandleContext              = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1390     NewHandleContext->Handle      = CurHandle;
1391     NewHandleContext->DevicePath  = DevicePathFromHandle (CurHandle);
1392     NewMenuEntry->DisplayString = DevicePathToStr (NewHandleContext->DevicePath);
1393     NewMenuEntry->HelpString    = NULL;
1394     NewMenuEntry->OptionNumber  = OptionNumber;
1395     OptionNumber++;
1396     InsertTailList (&DriverMenu.Head, &NewMenuEntry->Link);
1397
1398   }
1399   SafeFreePool (DevicePathHandle);
1400
1401   DriverMenu.MenuNumber = OptionNumber;
1402   return EFI_SUCCESS;
1403 }
1404
1405 UINT16
1406 BOpt_GetBootOptionNumber (
1407   VOID
1408   )
1409 /*++
1410
1411 Routine Description:
1412   Get the Option Number that does not used
1413
1414 Arguments:
1415
1416 Returns:
1417   The Option Number
1418
1419 --*/
1420 {
1421   BM_MENU_ENTRY *NewMenuEntry;
1422   UINT16        *BootOrderList;
1423   UINTN         BootOrderListSize;
1424   UINT16        Number;
1425   UINTN         Index;
1426   UINTN         Index2;
1427   BOOLEAN       Found;
1428   CHAR16        StrTemp[100];
1429   UINT16        *OptionBuffer;
1430   UINTN         OptionSize;
1431
1432   BootOrderListSize = 0;
1433   BootOrderList     = NULL;
1434
1435   BootOrderList = BdsLibGetVariableAndSize (
1436                     L"BootOrder",
1437                     &gEfiGlobalVariableGuid,
1438                     &BootOrderListSize
1439                     );
1440   if (BootOrderList) {
1441     //
1442     // already have Boot####
1443     //
1444     // AlreadyBootNumbers = BootOrderListSize / sizeof(UINT16);
1445     //
1446     for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
1447       Found = TRUE;
1448       for (Index2 = 0; Index2 < BootOptionMenu.MenuNumber; Index2++) {
1449         NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index2);
1450         if (Index == NewMenuEntry->OptionNumber) {
1451           Found = FALSE;
1452           break;
1453         }
1454       }
1455
1456       if (Found) {
1457      UnicodeSPrint (StrTemp, 100, L"Boot%04x", Index);
1458      DEBUG((DEBUG_ERROR,"INdex= %s\n", StrTemp));
1459           OptionBuffer = BdsLibGetVariableAndSize (
1460                     StrTemp,
1461                     &gEfiGlobalVariableGuid,
1462                     &OptionSize
1463                     );
1464          if (NULL == OptionBuffer)
1465             break;
1466       }
1467     }
1468     //
1469     // end for Index
1470     //
1471     Number = (UINT16) Index;
1472   } else {
1473     //
1474     // No Boot####
1475     //
1476     Number = 0;
1477   }
1478
1479   return Number;
1480 }
1481
1482 UINT16
1483 BOpt_GetDriverOptionNumber (
1484   VOID
1485   )
1486 /*++
1487
1488 Routine Description:
1489   Get the Option Number that does not used
1490
1491 Arguments:
1492
1493 Returns:
1494   The Option Number
1495
1496 --*/
1497 {
1498   BM_MENU_ENTRY *NewMenuEntry;
1499   UINT16        *DriverOrderList;
1500   UINTN         DriverOrderListSize;
1501   UINT16        Number;
1502   UINTN         Index;
1503   UINTN         Index2;
1504   BOOLEAN       Found;
1505
1506   DriverOrderListSize = 0;
1507   DriverOrderList     = NULL;
1508
1509   DriverOrderList = BdsLibGetVariableAndSize (
1510                       L"DriverOrder",
1511                       &gEfiGlobalVariableGuid,
1512                       &DriverOrderListSize
1513                       );
1514   if (DriverOrderList) {
1515     //
1516     // already have Driver####
1517     //
1518     // AlreadyDriverNumbers = DriverOrderListSize / sizeof(UINT16);
1519     //
1520     for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1521       Found = TRUE;
1522       for (Index2 = 0; Index2 < DriverOptionMenu.MenuNumber; Index2++) {
1523         NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index2);
1524         if (Index == NewMenuEntry->OptionNumber) {
1525           Found = FALSE;
1526           break;
1527         }
1528       }
1529
1530       if (Found) {
1531         break;
1532       }
1533     }
1534     //
1535     // end for Index
1536     //
1537     Number = (UINT16) Index;
1538   } else {
1539     //
1540     // No Driver####
1541     //
1542     Number = 0;
1543   }
1544
1545   return Number;
1546 }
1547
1548 EFI_STATUS
1549 BOpt_GetDriverOptions (
1550   IN  BMM_CALLBACK_DATA         *CallbackData
1551   )
1552 /*++
1553
1554 Routine Description:
1555   Build up all DriverOptionMenu
1556
1557 Arguments:
1558
1559 Returns:
1560   The Option Number
1561
1562 --*/
1563 {
1564   UINTN           Index;
1565   UINT16          DriverString[12];
1566   UINT8           *LoadOptionFromVar;
1567   UINT8           *LoadOption;
1568   UINTN           DriverOptionSize;
1569
1570   UINT16          *DriverOrderList;
1571   UINTN           DriverOrderListSize;
1572   BM_MENU_ENTRY   *NewMenuEntry;
1573   BM_LOAD_CONTEXT *NewLoadContext;
1574   UINT8           *LoadOptionPtr;
1575   UINTN           StringSize;
1576   UINTN           OptionalDataSize;
1577   UINT8           *LoadOptionEnd;
1578
1579   DriverOrderListSize = 0;
1580   DriverOrderList     = NULL;
1581   DriverOptionSize    = 0;
1582   LoadOptionFromVar   = NULL;
1583   BOpt_FreeMenu (&DriverOptionMenu);
1584   InitializeListHead (&DriverOptionMenu.Head);
1585   //
1586   // Get the DriverOrder from the Var
1587   //
1588   DriverOrderList = BdsLibGetVariableAndSize (
1589                       L"DriverOrder",
1590                       &gEfiGlobalVariableGuid,
1591                       &DriverOrderListSize
1592                       );
1593
1594   for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1595     UnicodeSPrint (
1596       DriverString,
1597       sizeof (DriverString),
1598       L"Driver%04x",
1599       DriverOrderList[Index]
1600       );
1601     //
1602     //  Get all loadoptions from the VAR
1603     //
1604     LoadOptionFromVar = BdsLibGetVariableAndSize (
1605                           DriverString,
1606                           &gEfiGlobalVariableGuid,
1607                           &DriverOptionSize
1608                           );
1609     if (!LoadOptionFromVar) {
1610       continue;
1611     }
1612
1613     LoadOption = EfiAllocateZeroPool (DriverOptionSize);
1614     if (!LoadOption) {
1615       continue;
1616     }
1617
1618     CopyMem (LoadOption, LoadOptionFromVar, DriverOptionSize);
1619     SafeFreePool (LoadOptionFromVar);
1620
1621     NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
1622     if (NULL == NewMenuEntry) {
1623       return EFI_OUT_OF_RESOURCES;
1624     }
1625
1626     NewLoadContext                      = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1627     LoadOptionPtr                       = LoadOption;
1628     LoadOptionEnd                       = LoadOption + DriverOptionSize;
1629     NewMenuEntry->OptionNumber          = DriverOrderList[Index];
1630     NewLoadContext->LoadOptionModified  = FALSE;
1631     NewLoadContext->Deleted             = FALSE;
1632     NewLoadContext->IsLegacy            = FALSE;
1633
1634     //
1635     // LoadOption is a pointer type of UINT8
1636     // for easy use with following LOAD_OPTION
1637     // embedded in this struct
1638     //
1639     NewLoadContext->LoadOption      = LoadOption;
1640     NewLoadContext->LoadOptionSize  = DriverOptionSize;
1641
1642     NewLoadContext->Attributes      = *(UINT32 *) LoadOptionPtr;
1643     NewLoadContext->IsActive        = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1644
1645     NewLoadContext->ForceReconnect  = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1646
1647     LoadOptionPtr += sizeof (UINT32);
1648
1649     NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1650     LoadOptionPtr += sizeof (UINT16);
1651
1652     StringSize                  = StrSize ((UINT16 *) LoadOptionPtr);
1653     NewLoadContext->Description = EfiAllocateZeroPool (StringSize);
1654     ASSERT (NewLoadContext->Description != NULL);
1655     CopyMem (
1656       NewLoadContext->Description,
1657       (UINT16 *) LoadOptionPtr,
1658       StringSize
1659       );
1660     NewMenuEntry->DisplayString = NewLoadContext->Description;
1661
1662     LoadOptionPtr += StringSize;
1663
1664     NewLoadContext->FilePathList = EfiAllocateZeroPool (NewLoadContext->FilePathListLength);
1665     ASSERT (NewLoadContext->FilePathList != NULL);
1666     CopyMem (
1667       NewLoadContext->FilePathList,
1668       (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1669       NewLoadContext->FilePathListLength
1670       );
1671
1672     NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1673     NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1674                                         CallbackData,
1675                                         DriverOptionStrDepository
1676                                         );
1677     NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1678                                       CallbackData,
1679                                       DriverOptionHelpStrDepository
1680                                       );
1681     LoadOptionPtr += NewLoadContext->FilePathListLength;
1682
1683     if (LoadOptionPtr < LoadOptionEnd) {
1684       OptionalDataSize = DriverOptionSize -
1685         sizeof (UINT32) -
1686         sizeof (UINT16) -
1687         StringSize -
1688         NewLoadContext->FilePathListLength;
1689
1690       NewLoadContext->OptionalData = EfiAllocateZeroPool (OptionalDataSize);
1691       ASSERT (NewLoadContext->OptionalData != NULL);
1692       CopyMem (
1693         NewLoadContext->OptionalData,
1694         LoadOptionPtr,
1695         OptionalDataSize
1696         );
1697
1698       NewLoadContext->OptionalDataSize = OptionalDataSize;
1699     }
1700
1701     InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
1702
1703   }
1704
1705   SafeFreePool (DriverOrderList);
1706   DriverOptionMenu.MenuNumber = Index;
1707   return EFI_SUCCESS;
1708
1709 }
1710