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   EFI_IMAGE_NT_HEADERS        PeHdr;
1260   EFI_IMAGE_OPTIONAL_HEADER32 *PeOpt32;
1261   EFI_IMAGE_OPTIONAL_HEADER64 *PeOpt64;
1262   UINT16                      Subsystem;
1263   EFI_FILE_HANDLE             File;
1264   EFI_STATUS                  Status;
1265
1266   Status = Dir->Open (Dir, &File, FileName, EFI_FILE_MODE_READ, 0);
1267
1268   if (EFI_ERROR (Status)) {
1269     return FALSE;
1270   }
1271
1272   BufferSize = sizeof (EFI_IMAGE_DOS_HEADER);
1273   File->Read (File, &BufferSize, &DosHdr);
1274   if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {
1275     File->Close (File);
1276     return FALSE;
1277   }
1278
1279   File->SetPosition (File, DosHdr.e_lfanew);
1280   BufferSize = sizeof (EFI_IMAGE_NT_HEADERS);
1281   File->Read (File, &BufferSize, &PeHdr);
1282   if (PeHdr.Signature != EFI_IMAGE_NT_SIGNATURE) {
1283     File->Close (File);
1284     return FALSE;
1285   }
1286   //
1287   // Determine PE type and read subsytem
1288   // BugBug : We should be using EFI_IMAGE_MACHINE_TYPE_SUPPORTED (machine)
1289   // macro to detect the machine type.
1290   // We should not be using  EFI_IMAGE_OPTIONAL_HEADER32 and
1291   // EFI_IMAGE_OPTIONAL_HEADER64
1292   //
1293   if (PeHdr.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
1294     PeOpt32   = (EFI_IMAGE_OPTIONAL_HEADER32 *) &(PeHdr.OptionalHeader);
1295     Subsystem = PeOpt32->Subsystem;
1296   } else if (PeHdr.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
1297     PeOpt64   = (EFI_IMAGE_OPTIONAL_HEADER64 *) &(PeHdr.OptionalHeader);
1298     Subsystem = PeOpt64->Subsystem;
1299   } else {
1300     return FALSE;
1301   }
1302
1303   if (Subsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1304     File->Close (File);
1305     return TRUE;
1306   } else {
1307     File->Close (File);
1308     return FALSE;
1309   }
1310 }
1311
1312 EFI_STATUS
1313 BOpt_FindDrivers (
1314   VOID
1315   )
1316 /*++
1317
1318 Routine Description
1319   Find drivers that will be added as Driver#### variables from handles
1320   in current system environment
1321   All valid handles in the system except those consume SimpleFs, LoadFile
1322   are stored in DriverMenu for future use.
1323
1324 Arguments:
1325   None
1326
1327 Returns:
1328   EFI_SUCCESS
1329   Others
1330
1331 --*/
1332 {
1333   UINTN                           NoDevicePathHandles;
1334   EFI_HANDLE                      *DevicePathHandle;
1335   UINTN                           Index;
1336   EFI_STATUS                      Status;
1337   BM_MENU_ENTRY                   *NewMenuEntry;
1338   BM_HANDLE_CONTEXT               *NewHandleContext;
1339   EFI_HANDLE                      CurHandle;
1340   UINTN                           OptionNumber;
1341   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
1342   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
1343
1344   SimpleFs  = NULL;
1345   LoadFile  = NULL;
1346
1347   InitializeListHead (&DriverMenu.Head);
1348
1349   //
1350   // At first, get all handles that support Device Path
1351   // protocol which is the basic requirement for
1352   // Driver####
1353   //
1354   Status = gBS->LocateHandleBuffer (
1355                   ByProtocol,
1356                   &gEfiDevicePathProtocolGuid,
1357                   NULL,
1358                   &NoDevicePathHandles,
1359                   &DevicePathHandle
1360                   );
1361   if (EFI_ERROR (Status)) {
1362     return Status;
1363   }
1364
1365   OptionNumber = 0;
1366   for (Index = 0; Index < NoDevicePathHandles; Index++) {
1367     CurHandle = DevicePathHandle[Index];
1368
1369     //
1370     //  Check whether this handle support
1371     //  driver binding
1372     //
1373     Status = gBS->HandleProtocol (
1374                     CurHandle,
1375                     &gEfiSimpleFileSystemProtocolGuid,
1376                     (VOID **) &SimpleFs
1377                     );
1378     if (Status == EFI_SUCCESS) {
1379       continue;
1380     }
1381
1382     Status = gBS->HandleProtocol (
1383                     CurHandle,
1384                     &gEfiLoadFileProtocolGuid,
1385                     (VOID **) &LoadFile
1386                     );
1387     if (Status == EFI_SUCCESS) {
1388       continue;
1389     }
1390
1391     NewMenuEntry = BOpt_CreateMenuEntry (BM_HANDLE_CONTEXT_SELECT);
1392     if (NULL == NewMenuEntry) {
1393       SafeFreePool (DevicePathHandle);
1394       return EFI_OUT_OF_RESOURCES;
1395     }
1396
1397     NewHandleContext              = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1398     NewHandleContext->Handle      = CurHandle;
1399     NewHandleContext->DevicePath  = DevicePathFromHandle (CurHandle);
1400     NewMenuEntry->DisplayString = DevicePathToStr (NewHandleContext->DevicePath);
1401     NewMenuEntry->HelpString    = NULL;
1402     NewMenuEntry->OptionNumber  = OptionNumber;
1403     OptionNumber++;
1404     InsertTailList (&DriverMenu.Head, &NewMenuEntry->Link);
1405
1406   }
1407   SafeFreePool (DevicePathHandle);
1408
1409   DriverMenu.MenuNumber = OptionNumber;
1410   return EFI_SUCCESS;
1411 }
1412
1413 UINT16
1414 BOpt_GetBootOptionNumber (
1415   VOID
1416   )
1417 /*++
1418
1419 Routine Description:
1420   Get the Option Number that does not used
1421
1422 Arguments:
1423
1424 Returns:
1425   The Option Number
1426
1427 --*/
1428 {
1429   BM_MENU_ENTRY *NewMenuEntry;
1430   UINT16        *BootOrderList;
1431   UINTN         BootOrderListSize;
1432   UINT16        Number;
1433   UINTN         Index;
1434   UINTN         Index2;
1435   BOOLEAN       Found;
1436   CHAR16        StrTemp[100];
1437   UINT16        *OptionBuffer;
1438   UINTN         OptionSize;
1439
1440   BootOrderListSize = 0;
1441   BootOrderList     = NULL;
1442
1443   BootOrderList = BdsLibGetVariableAndSize (
1444                     L"BootOrder",
1445                     &gEfiGlobalVariableGuid,
1446                     &BootOrderListSize
1447                     );
1448   if (BootOrderList) {
1449     //
1450     // already have Boot####
1451     //
1452     // AlreadyBootNumbers = BootOrderListSize / sizeof(UINT16);
1453     //
1454     for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
1455       Found = TRUE;
1456       for (Index2 = 0; Index2 < BootOptionMenu.MenuNumber; Index2++) {
1457         NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index2);
1458         if (Index == NewMenuEntry->OptionNumber) {
1459           Found = FALSE;
1460           break;
1461         }
1462       }
1463
1464       if (Found) {
1465      UnicodeSPrint (StrTemp, 100, L"Boot%04x", Index);
1466      DEBUG((DEBUG_ERROR,"INdex= %s\n", StrTemp));
1467           OptionBuffer = BdsLibGetVariableAndSize (
1468                     StrTemp,
1469                     &gEfiGlobalVariableGuid,
1470                     &OptionSize
1471                     );
1472          if (NULL == OptionBuffer)
1473             break;
1474       }
1475     }
1476     //
1477     // end for Index
1478     //
1479     Number = (UINT16) Index;
1480   } else {
1481     //
1482     // No Boot####
1483     //
1484     Number = 0;
1485   }
1486
1487   return Number;
1488 }
1489
1490 UINT16
1491 BOpt_GetDriverOptionNumber (
1492   VOID
1493   )
1494 /*++
1495
1496 Routine Description:
1497   Get the Option Number that does not used
1498
1499 Arguments:
1500
1501 Returns:
1502   The Option Number
1503
1504 --*/
1505 {
1506   BM_MENU_ENTRY *NewMenuEntry;
1507   UINT16        *DriverOrderList;
1508   UINTN         DriverOrderListSize;
1509   UINT16        Number;
1510   UINTN         Index;
1511   UINTN         Index2;
1512   BOOLEAN       Found;
1513
1514   DriverOrderListSize = 0;
1515   DriverOrderList     = NULL;
1516
1517   DriverOrderList = BdsLibGetVariableAndSize (
1518                       L"DriverOrder",
1519                       &gEfiGlobalVariableGuid,
1520                       &DriverOrderListSize
1521                       );
1522   if (DriverOrderList) {
1523     //
1524     // already have Driver####
1525     //
1526     // AlreadyDriverNumbers = DriverOrderListSize / sizeof(UINT16);
1527     //
1528     for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1529       Found = TRUE;
1530       for (Index2 = 0; Index2 < DriverOptionMenu.MenuNumber; Index2++) {
1531         NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index2);
1532         if (Index == NewMenuEntry->OptionNumber) {
1533           Found = FALSE;
1534           break;
1535         }
1536       }
1537
1538       if (Found) {
1539         break;
1540       }
1541     }
1542     //
1543     // end for Index
1544     //
1545     Number = (UINT16) Index;
1546   } else {
1547     //
1548     // No Driver####
1549     //
1550     Number = 0;
1551   }
1552
1553   return Number;
1554 }
1555
1556 EFI_STATUS
1557 BOpt_GetDriverOptions (
1558   IN  BMM_CALLBACK_DATA         *CallbackData
1559   )
1560 /*++
1561
1562 Routine Description:
1563   Build up all DriverOptionMenu
1564
1565 Arguments:
1566
1567 Returns:
1568   The Option Number
1569
1570 --*/
1571 {
1572   UINTN           Index;
1573   UINT16          DriverString[12];
1574   UINT8           *LoadOptionFromVar;
1575   UINT8           *LoadOption;
1576   UINTN           DriverOptionSize;
1577
1578   UINT16          *DriverOrderList;
1579   UINTN           DriverOrderListSize;
1580   BM_MENU_ENTRY   *NewMenuEntry;
1581   BM_LOAD_CONTEXT *NewLoadContext;
1582   UINT8           *LoadOptionPtr;
1583   UINTN           StringSize;
1584   UINTN           OptionalDataSize;
1585   UINT8           *LoadOptionEnd;
1586
1587   DriverOrderListSize = 0;
1588   DriverOrderList     = NULL;
1589   DriverOptionSize    = 0;
1590   LoadOptionFromVar   = NULL;
1591   BOpt_FreeMenu (&DriverOptionMenu);
1592   InitializeListHead (&DriverOptionMenu.Head);
1593   //
1594   // Get the DriverOrder from the Var
1595   //
1596   DriverOrderList = BdsLibGetVariableAndSize (
1597                       L"DriverOrder",
1598                       &gEfiGlobalVariableGuid,
1599                       &DriverOrderListSize
1600                       );
1601
1602   for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1603     UnicodeSPrint (
1604       DriverString,
1605       sizeof (DriverString),
1606       L"Driver%04x",
1607       DriverOrderList[Index]
1608       );
1609     //
1610     //  Get all loadoptions from the VAR
1611     //
1612     LoadOptionFromVar = BdsLibGetVariableAndSize (
1613                           DriverString,
1614                           &gEfiGlobalVariableGuid,
1615                           &DriverOptionSize
1616                           );
1617     if (!LoadOptionFromVar) {
1618       continue;
1619     }
1620
1621     LoadOption = EfiAllocateZeroPool (DriverOptionSize);
1622     if (!LoadOption) {
1623       continue;
1624     }
1625
1626     CopyMem (LoadOption, LoadOptionFromVar, DriverOptionSize);
1627     SafeFreePool (LoadOptionFromVar);
1628
1629     NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
1630     if (NULL == NewMenuEntry) {
1631       return EFI_OUT_OF_RESOURCES;
1632     }
1633
1634     NewLoadContext                      = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1635     LoadOptionPtr                       = LoadOption;
1636     LoadOptionEnd                       = LoadOption + DriverOptionSize;
1637     NewMenuEntry->OptionNumber          = DriverOrderList[Index];
1638     NewLoadContext->LoadOptionModified  = FALSE;
1639     NewLoadContext->Deleted             = FALSE;
1640     NewLoadContext->IsLegacy            = FALSE;
1641
1642     //
1643     // LoadOption is a pointer type of UINT8
1644     // for easy use with following LOAD_OPTION
1645     // embedded in this struct
1646     //
1647     NewLoadContext->LoadOption      = LoadOption;
1648     NewLoadContext->LoadOptionSize  = DriverOptionSize;
1649
1650     NewLoadContext->Attributes      = *(UINT32 *) LoadOptionPtr;
1651     NewLoadContext->IsActive        = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1652
1653     NewLoadContext->ForceReconnect  = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1654
1655     LoadOptionPtr += sizeof (UINT32);
1656
1657     NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1658     LoadOptionPtr += sizeof (UINT16);
1659
1660     StringSize                  = StrSize ((UINT16 *) LoadOptionPtr);
1661     NewLoadContext->Description = EfiAllocateZeroPool (StringSize);
1662     ASSERT (NewLoadContext->Description != NULL);
1663     CopyMem (
1664       NewLoadContext->Description,
1665       (UINT16 *) LoadOptionPtr,
1666       StringSize
1667       );
1668     NewMenuEntry->DisplayString = NewLoadContext->Description;
1669
1670     LoadOptionPtr += StringSize;
1671
1672     NewLoadContext->FilePathList = EfiAllocateZeroPool (NewLoadContext->FilePathListLength);
1673     ASSERT (NewLoadContext->FilePathList != NULL);
1674     CopyMem (
1675       NewLoadContext->FilePathList,
1676       (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1677       NewLoadContext->FilePathListLength
1678       );
1679
1680     NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1681     NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1682                                         CallbackData,
1683                                         DriverOptionStrDepository
1684                                         );
1685     NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1686                                       CallbackData,
1687                                       DriverOptionHelpStrDepository
1688                                       );
1689     LoadOptionPtr += NewLoadContext->FilePathListLength;
1690
1691     if (LoadOptionPtr < LoadOptionEnd) {
1692       OptionalDataSize = DriverOptionSize -
1693         sizeof (UINT32) -
1694         sizeof (UINT16) -
1695         StringSize -
1696         NewLoadContext->FilePathListLength;
1697
1698       NewLoadContext->OptionalData = EfiAllocateZeroPool (OptionalDataSize);
1699       ASSERT (NewLoadContext->OptionalData != NULL);
1700       CopyMem (
1701         NewLoadContext->OptionalData,
1702         LoadOptionPtr,
1703         OptionalDataSize
1704         );
1705
1706       NewLoadContext->OptionalDataSize = OptionalDataSize;
1707     }
1708
1709     InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
1710
1711   }
1712
1713   SafeFreePool (DriverOrderList);
1714   DriverOptionMenu.MenuNumber = Index;
1715   return EFI_SUCCESS;
1716
1717 }
1718