VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/UefiBootManagerLib/BmBoot.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago

EFI: First step in UDK2018 merge. Does not build yet.
  • Property svn:eol-style set to native
File size: 76.9 KB
Line 
1/** @file
2 Library functions which relates with booting.
3
4Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
5(C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
6This program and the accompanying materials
7are licensed and made available under the terms and conditions of the BSD License
8which accompanies this distribution. The full text of the license may be found at
9http://opensource.org/licenses/bsd-license.php
10
11THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14**/
15
16#include "InternalBm.h"
17
18EFI_RAM_DISK_PROTOCOL *mRamDisk = NULL;
19
20EFI_BOOT_MANAGER_REFRESH_LEGACY_BOOT_OPTION mBmRefreshLegacyBootOption = NULL;
21EFI_BOOT_MANAGER_LEGACY_BOOT mBmLegacyBoot = NULL;
22
23///
24/// This GUID is used for an EFI Variable that stores the front device pathes
25/// for a partial device path that starts with the HD node.
26///
27EFI_GUID mBmHardDriveBootVariableGuid = { 0xfab7e9e1, 0x39dd, 0x4f2b, { 0x84, 0x08, 0xe2, 0x0e, 0x90, 0x6c, 0xb6, 0xde } };
28EFI_GUID mBmAutoCreateBootOptionGuid = { 0x8108ac4e, 0x9f11, 0x4d59, { 0x85, 0x0e, 0xe2, 0x1a, 0x52, 0x2c, 0x59, 0xb2 } };
29
30/**
31
32 End Perf entry of BDS
33
34 @param Event The triggered event.
35 @param Context Context for this event.
36
37**/
38VOID
39EFIAPI
40BmEndOfBdsPerfCode (
41 IN EFI_EVENT Event,
42 IN VOID *Context
43 )
44{
45 //
46 // Record the performance data for End of BDS
47 //
48 PERF_END(NULL, "BDS", NULL, 0);
49
50 return ;
51}
52
53/**
54 The function registers the legacy boot support capabilities.
55
56 @param RefreshLegacyBootOption The function pointer to create all the legacy boot options.
57 @param LegacyBoot The function pointer to boot the legacy boot option.
58**/
59VOID
60EFIAPI
61EfiBootManagerRegisterLegacyBootSupport (
62 EFI_BOOT_MANAGER_REFRESH_LEGACY_BOOT_OPTION RefreshLegacyBootOption,
63 EFI_BOOT_MANAGER_LEGACY_BOOT LegacyBoot
64 )
65{
66 mBmRefreshLegacyBootOption = RefreshLegacyBootOption;
67 mBmLegacyBoot = LegacyBoot;
68}
69
70/**
71 Return TRUE when the boot option is auto-created instead of manually added.
72
73 @param BootOption Pointer to the boot option to check.
74
75 @retval TRUE The boot option is auto-created.
76 @retval FALSE The boot option is manually added.
77**/
78BOOLEAN
79BmIsAutoCreateBootOption (
80 EFI_BOOT_MANAGER_LOAD_OPTION *BootOption
81 )
82{
83 if ((BootOption->OptionalDataSize == sizeof (EFI_GUID)) &&
84 CompareGuid ((EFI_GUID *) BootOption->OptionalData, &mBmAutoCreateBootOptionGuid)
85 ) {
86 return TRUE;
87 } else {
88 return FALSE;
89 }
90}
91
92/**
93 Find the boot option in the NV storage and return the option number.
94
95 @param OptionToFind Boot option to be checked.
96
97 @return The option number of the found boot option.
98
99**/
100UINTN
101BmFindBootOptionInVariable (
102 IN EFI_BOOT_MANAGER_LOAD_OPTION *OptionToFind
103 )
104{
105 EFI_STATUS Status;
106 EFI_BOOT_MANAGER_LOAD_OPTION BootOption;
107 UINTN OptionNumber;
108 CHAR16 OptionName[BM_OPTION_NAME_LEN];
109 EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions;
110 UINTN BootOptionCount;
111 UINTN Index;
112
113 OptionNumber = LoadOptionNumberUnassigned;
114
115 //
116 // Try to match the variable exactly if the option number is assigned
117 //
118 if (OptionToFind->OptionNumber != LoadOptionNumberUnassigned) {
119 UnicodeSPrint (
120 OptionName, sizeof (OptionName), L"%s%04x",
121 mBmLoadOptionName[OptionToFind->OptionType], OptionToFind->OptionNumber
122 );
123 Status = EfiBootManagerVariableToLoadOption (OptionName, &BootOption);
124
125 if (!EFI_ERROR (Status)) {
126 ASSERT (OptionToFind->OptionNumber == BootOption.OptionNumber);
127 if ((OptionToFind->Attributes == BootOption.Attributes) &&
128 (StrCmp (OptionToFind->Description, BootOption.Description) == 0) &&
129 (CompareMem (OptionToFind->FilePath, BootOption.FilePath, GetDevicePathSize (OptionToFind->FilePath)) == 0) &&
130 (OptionToFind->OptionalDataSize == BootOption.OptionalDataSize) &&
131 (CompareMem (OptionToFind->OptionalData, BootOption.OptionalData, OptionToFind->OptionalDataSize) == 0)
132 ) {
133 OptionNumber = OptionToFind->OptionNumber;
134 }
135 EfiBootManagerFreeLoadOption (&BootOption);
136 }
137 }
138
139 //
140 // The option number assigned is either incorrect or unassigned.
141 //
142 if (OptionNumber == LoadOptionNumberUnassigned) {
143 BootOptions = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot);
144
145 Index = EfiBootManagerFindLoadOption (OptionToFind, BootOptions, BootOptionCount);
146 if (Index != -1) {
147 OptionNumber = BootOptions[Index].OptionNumber;
148 }
149
150 EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount);
151 }
152
153 return OptionNumber;
154}
155
156/**
157 Return the correct FV file path.
158 FV address may change across reboot. This routine promises the FV file device path is right.
159
160 @param FilePath The Memory Mapped Device Path to get the file buffer.
161
162 @return The updated FV Device Path pointint to the file.
163**/
164EFI_DEVICE_PATH_PROTOCOL *
165BmAdjustFvFilePath (
166 IN EFI_DEVICE_PATH_PROTOCOL *FilePath
167 )
168{
169 EFI_STATUS Status;
170 UINTN Index;
171 EFI_DEVICE_PATH_PROTOCOL *FvFileNode;
172 EFI_HANDLE FvHandle;
173 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
174 UINTN FvHandleCount;
175 EFI_HANDLE *FvHandles;
176 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
177 EFI_DEVICE_PATH_PROTOCOL *FullPath;
178
179 //
180 // Get the file buffer by using the exactly FilePath.
181 //
182 FvFileNode = FilePath;
183 Status = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &FvFileNode, &FvHandle);
184 if (!EFI_ERROR (Status)) {
185 return DuplicateDevicePath (FilePath);
186 }
187
188 //
189 // Only wide match other FVs if it's a memory mapped FV file path.
190 //
191 if ((DevicePathType (FilePath) != HARDWARE_DEVICE_PATH) || (DevicePathSubType (FilePath) != HW_MEMMAP_DP)) {
192 return NULL;
193 }
194
195 FvFileNode = NextDevicePathNode (FilePath);
196
197 //
198 // Firstly find the FV file in current FV
199 //
200 gBS->HandleProtocol (
201 gImageHandle,
202 &gEfiLoadedImageProtocolGuid,
203 (VOID **) &LoadedImage
204 );
205 NewDevicePath = AppendDevicePathNode (DevicePathFromHandle (LoadedImage->DeviceHandle), FvFileNode);
206 FullPath = BmAdjustFvFilePath (NewDevicePath);
207 FreePool (NewDevicePath);
208 if (FullPath != NULL) {
209 return FullPath;
210 }
211
212 //
213 // Secondly find the FV file in all other FVs
214 //
215 gBS->LocateHandleBuffer (
216 ByProtocol,
217 &gEfiFirmwareVolume2ProtocolGuid,
218 NULL,
219 &FvHandleCount,
220 &FvHandles
221 );
222 for (Index = 0; Index < FvHandleCount; Index++) {
223 if (FvHandles[Index] == LoadedImage->DeviceHandle) {
224 //
225 // Skip current FV, it was handed in first step.
226 //
227 continue;
228 }
229 NewDevicePath = AppendDevicePathNode (DevicePathFromHandle (FvHandles[Index]), FvFileNode);
230 FullPath = BmAdjustFvFilePath (NewDevicePath);
231 FreePool (NewDevicePath);
232 if (FullPath != NULL) {
233 break;
234 }
235 }
236
237 if (FvHandles != NULL) {
238 FreePool (FvHandles);
239 }
240 return FullPath;
241}
242
243/**
244 Check if it's a Device Path pointing to FV file.
245
246 The function doesn't garentee the device path points to existing FV file.
247
248 @param DevicePath Input device path.
249
250 @retval TRUE The device path is a FV File Device Path.
251 @retval FALSE The device path is NOT a FV File Device Path.
252**/
253BOOLEAN
254BmIsFvFilePath (
255 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
256 )
257{
258 EFI_STATUS Status;
259 EFI_HANDLE Handle;
260 EFI_DEVICE_PATH_PROTOCOL *Node;
261
262 Node = DevicePath;
263 Status = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &Node, &Handle);
264 if (!EFI_ERROR (Status)) {
265 return TRUE;
266 }
267
268 if ((DevicePathType (DevicePath) == HARDWARE_DEVICE_PATH) && (DevicePathSubType (DevicePath) == HW_MEMMAP_DP)) {
269 DevicePath = NextDevicePathNode (DevicePath);
270 if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) && (DevicePathSubType (DevicePath) == MEDIA_PIWG_FW_FILE_DP)) {
271 return IsDevicePathEnd (NextDevicePathNode (DevicePath));
272 }
273 }
274 return FALSE;
275}
276
277/**
278 Check whether a USB device match the specified USB Class device path. This
279 function follows "Load Option Processing" behavior in UEFI specification.
280
281 @param UsbIo USB I/O protocol associated with the USB device.
282 @param UsbClass The USB Class device path to match.
283
284 @retval TRUE The USB device match the USB Class device path.
285 @retval FALSE The USB device does not match the USB Class device path.
286
287**/
288BOOLEAN
289BmMatchUsbClass (
290 IN EFI_USB_IO_PROTOCOL *UsbIo,
291 IN USB_CLASS_DEVICE_PATH *UsbClass
292 )
293{
294 EFI_STATUS Status;
295 EFI_USB_DEVICE_DESCRIPTOR DevDesc;
296 EFI_USB_INTERFACE_DESCRIPTOR IfDesc;
297 UINT8 DeviceClass;
298 UINT8 DeviceSubClass;
299 UINT8 DeviceProtocol;
300
301 if ((DevicePathType (UsbClass) != MESSAGING_DEVICE_PATH) ||
302 (DevicePathSubType (UsbClass) != MSG_USB_CLASS_DP)){
303 return FALSE;
304 }
305
306 //
307 // Check Vendor Id and Product Id.
308 //
309 Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DevDesc);
310 if (EFI_ERROR (Status)) {
311 return FALSE;
312 }
313
314 if ((UsbClass->VendorId != 0xffff) &&
315 (UsbClass->VendorId != DevDesc.IdVendor)) {
316 return FALSE;
317 }
318
319 if ((UsbClass->ProductId != 0xffff) &&
320 (UsbClass->ProductId != DevDesc.IdProduct)) {
321 return FALSE;
322 }
323
324 DeviceClass = DevDesc.DeviceClass;
325 DeviceSubClass = DevDesc.DeviceSubClass;
326 DeviceProtocol = DevDesc.DeviceProtocol;
327 if (DeviceClass == 0) {
328 //
329 // If Class in Device Descriptor is set to 0, use the Class, SubClass and
330 // Protocol in Interface Descriptor instead.
331 //
332 Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &IfDesc);
333 if (EFI_ERROR (Status)) {
334 return FALSE;
335 }
336
337 DeviceClass = IfDesc.InterfaceClass;
338 DeviceSubClass = IfDesc.InterfaceSubClass;
339 DeviceProtocol = IfDesc.InterfaceProtocol;
340 }
341
342 //
343 // Check Class, SubClass and Protocol.
344 //
345 if ((UsbClass->DeviceClass != 0xff) &&
346 (UsbClass->DeviceClass != DeviceClass)) {
347 return FALSE;
348 }
349
350 if ((UsbClass->DeviceSubClass != 0xff) &&
351 (UsbClass->DeviceSubClass != DeviceSubClass)) {
352 return FALSE;
353 }
354
355 if ((UsbClass->DeviceProtocol != 0xff) &&
356 (UsbClass->DeviceProtocol != DeviceProtocol)) {
357 return FALSE;
358 }
359
360 return TRUE;
361}
362
363/**
364 Check whether a USB device match the specified USB WWID device path. This
365 function follows "Load Option Processing" behavior in UEFI specification.
366
367 @param UsbIo USB I/O protocol associated with the USB device.
368 @param UsbWwid The USB WWID device path to match.
369
370 @retval TRUE The USB device match the USB WWID device path.
371 @retval FALSE The USB device does not match the USB WWID device path.
372
373**/
374BOOLEAN
375BmMatchUsbWwid (
376 IN EFI_USB_IO_PROTOCOL *UsbIo,
377 IN USB_WWID_DEVICE_PATH *UsbWwid
378 )
379{
380 EFI_STATUS Status;
381 EFI_USB_DEVICE_DESCRIPTOR DevDesc;
382 EFI_USB_INTERFACE_DESCRIPTOR IfDesc;
383 UINT16 *LangIdTable;
384 UINT16 TableSize;
385 UINT16 Index;
386 CHAR16 *CompareStr;
387 UINTN CompareLen;
388 CHAR16 *SerialNumberStr;
389 UINTN Length;
390
391 if ((DevicePathType (UsbWwid) != MESSAGING_DEVICE_PATH) ||
392 (DevicePathSubType (UsbWwid) != MSG_USB_WWID_DP)) {
393 return FALSE;
394 }
395
396 //
397 // Check Vendor Id and Product Id.
398 //
399 Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DevDesc);
400 if (EFI_ERROR (Status)) {
401 return FALSE;
402 }
403 if ((DevDesc.IdVendor != UsbWwid->VendorId) ||
404 (DevDesc.IdProduct != UsbWwid->ProductId)) {
405 return FALSE;
406 }
407
408 //
409 // Check Interface Number.
410 //
411 Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &IfDesc);
412 if (EFI_ERROR (Status)) {
413 return FALSE;
414 }
415 if (IfDesc.InterfaceNumber != UsbWwid->InterfaceNumber) {
416 return FALSE;
417 }
418
419 //
420 // Check Serial Number.
421 //
422 if (DevDesc.StrSerialNumber == 0) {
423 return FALSE;
424 }
425
426 //
427 // Get all supported languages.
428 //
429 TableSize = 0;
430 LangIdTable = NULL;
431 Status = UsbIo->UsbGetSupportedLanguages (UsbIo, &LangIdTable, &TableSize);
432 if (EFI_ERROR (Status) || (TableSize == 0) || (LangIdTable == NULL)) {
433 return FALSE;
434 }
435
436 //
437 // Serial number in USB WWID device path is the last 64-or-less UTF-16 characters.
438 //
439 CompareStr = (CHAR16 *) (UINTN) (UsbWwid + 1);
440 CompareLen = (DevicePathNodeLength (UsbWwid) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16);
441 if (CompareStr[CompareLen - 1] == L'\0') {
442 CompareLen--;
443 }
444
445 //
446 // Compare serial number in each supported language.
447 //
448 for (Index = 0; Index < TableSize / sizeof (UINT16); Index++) {
449 SerialNumberStr = NULL;
450 Status = UsbIo->UsbGetStringDescriptor (
451 UsbIo,
452 LangIdTable[Index],
453 DevDesc.StrSerialNumber,
454 &SerialNumberStr
455 );
456 if (EFI_ERROR (Status) || (SerialNumberStr == NULL)) {
457 continue;
458 }
459
460 Length = StrLen (SerialNumberStr);
461 if ((Length >= CompareLen) &&
462 (CompareMem (SerialNumberStr + Length - CompareLen, CompareStr, CompareLen * sizeof (CHAR16)) == 0)) {
463 FreePool (SerialNumberStr);
464 return TRUE;
465 }
466
467 FreePool (SerialNumberStr);
468 }
469
470 return FALSE;
471}
472
473/**
474 Find a USB device which match the specified short-form device path start with
475 USB Class or USB WWID device path. If ParentDevicePath is NULL, this function
476 will search in all USB devices of the platform. If ParentDevicePath is not NULL,
477 this function will only search in its child devices.
478
479 @param DevicePath The device path that contains USB Class or USB WWID device path.
480 @param ParentDevicePathSize The length of the device path before the USB Class or
481 USB WWID device path.
482 @param UsbIoHandleCount A pointer to the count of the returned USB IO handles.
483
484 @retval NULL The matched USB IO handles cannot be found.
485 @retval other The matched USB IO handles.
486
487**/
488EFI_HANDLE *
489BmFindUsbDevice (
490 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
491 IN UINTN ParentDevicePathSize,
492 OUT UINTN *UsbIoHandleCount
493 )
494{
495 EFI_STATUS Status;
496 EFI_HANDLE *UsbIoHandles;
497 EFI_DEVICE_PATH_PROTOCOL *UsbIoDevicePath;
498 EFI_USB_IO_PROTOCOL *UsbIo;
499 UINTN Index;
500 BOOLEAN Matched;
501
502 ASSERT (UsbIoHandleCount != NULL);
503
504 //
505 // Get all UsbIo Handles.
506 //
507 Status = gBS->LocateHandleBuffer (
508 ByProtocol,
509 &gEfiUsbIoProtocolGuid,
510 NULL,
511 UsbIoHandleCount,
512 &UsbIoHandles
513 );
514 if (EFI_ERROR (Status)) {
515 *UsbIoHandleCount = 0;
516 UsbIoHandles = NULL;
517 }
518
519 for (Index = 0; Index < *UsbIoHandleCount; ) {
520 //
521 // Get the Usb IO interface.
522 //
523 Status = gBS->HandleProtocol(
524 UsbIoHandles[Index],
525 &gEfiUsbIoProtocolGuid,
526 (VOID **) &UsbIo
527 );
528 UsbIoDevicePath = DevicePathFromHandle (UsbIoHandles[Index]);
529 Matched = FALSE;
530 if (!EFI_ERROR (Status) && (UsbIoDevicePath != NULL)) {
531
532 //
533 // Compare starting part of UsbIoHandle's device path with ParentDevicePath.
534 //
535 if (CompareMem (UsbIoDevicePath, DevicePath, ParentDevicePathSize) == 0) {
536 if (BmMatchUsbClass (UsbIo, (USB_CLASS_DEVICE_PATH *) ((UINTN) DevicePath + ParentDevicePathSize)) ||
537 BmMatchUsbWwid (UsbIo, (USB_WWID_DEVICE_PATH *) ((UINTN) DevicePath + ParentDevicePathSize))) {
538 Matched = TRUE;
539 }
540 }
541 }
542
543 if (!Matched) {
544 (*UsbIoHandleCount) --;
545 CopyMem (&UsbIoHandles[Index], &UsbIoHandles[Index + 1], (*UsbIoHandleCount - Index) * sizeof (EFI_HANDLE));
546 } else {
547 Index++;
548 }
549 }
550
551 return UsbIoHandles;
552}
553
554/**
555 Expand USB Class or USB WWID device path node to be full device path of a USB
556 device in platform.
557
558 This function support following 4 cases:
559 1) Boot Option device path starts with a USB Class or USB WWID device path,
560 and there is no Media FilePath device path in the end.
561 In this case, it will follow Removable Media Boot Behavior.
562 2) Boot Option device path starts with a USB Class or USB WWID device path,
563 and ended with Media FilePath device path.
564 3) Boot Option device path starts with a full device path to a USB Host Controller,
565 contains a USB Class or USB WWID device path node, while not ended with Media
566 FilePath device path. In this case, it will follow Removable Media Boot Behavior.
567 4) Boot Option device path starts with a full device path to a USB Host Controller,
568 contains a USB Class or USB WWID device path node, and ended with Media
569 FilePath device path.
570
571 @param FilePath The device path pointing to a load option.
572 It could be a short-form device path.
573 @param FullPath The full path returned by the routine in last call.
574 Set to NULL in first call.
575 @param ShortformNode Pointer to the USB short-form device path node in the FilePath buffer.
576
577 @return The next possible full path pointing to the load option.
578 Caller is responsible to free the memory.
579**/
580EFI_DEVICE_PATH_PROTOCOL *
581BmExpandUsbDevicePath (
582 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
583 IN EFI_DEVICE_PATH_PROTOCOL *FullPath,
584 IN EFI_DEVICE_PATH_PROTOCOL *ShortformNode
585 )
586{
587 UINTN ParentDevicePathSize;
588 EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath;
589 EFI_DEVICE_PATH_PROTOCOL *NextFullPath;
590 EFI_HANDLE *Handles;
591 UINTN HandleCount;
592 UINTN Index;
593 BOOLEAN GetNext;
594
595 NextFullPath = NULL;
596 GetNext = (BOOLEAN)(FullPath == NULL);
597 ParentDevicePathSize = (UINTN) ShortformNode - (UINTN) FilePath;
598 RemainingDevicePath = NextDevicePathNode (ShortformNode);
599 Handles = BmFindUsbDevice (FilePath, ParentDevicePathSize, &HandleCount);
600
601 for (Index = 0; Index < HandleCount; Index++) {
602 FilePath = AppendDevicePath (DevicePathFromHandle (Handles[Index]), RemainingDevicePath);
603 if (FilePath == NULL) {
604 //
605 // Out of memory.
606 //
607 continue;
608 }
609 NextFullPath = BmGetNextLoadOptionDevicePath (FilePath, NULL);
610 FreePool (FilePath);
611 if (NextFullPath == NULL) {
612 //
613 // No BlockIo or SimpleFileSystem under FilePath.
614 //
615 continue;
616 }
617 if (GetNext) {
618 break;
619 } else {
620 GetNext = (BOOLEAN)(CompareMem (NextFullPath, FullPath, GetDevicePathSize (NextFullPath)) == 0);
621 FreePool (NextFullPath);
622 NextFullPath = NULL;
623 }
624 }
625
626 if (Handles != NULL) {
627 FreePool (Handles);
628 }
629
630 return NextFullPath;
631}
632
633/**
634 Expand File-path device path node to be full device path in platform.
635
636 @param FilePath The device path pointing to a load option.
637 It could be a short-form device path.
638 @param FullPath The full path returned by the routine in last call.
639 Set to NULL in first call.
640
641 @return The next possible full path pointing to the load option.
642 Caller is responsible to free the memory.
643**/
644EFI_DEVICE_PATH_PROTOCOL *
645BmExpandFileDevicePath (
646 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
647 IN EFI_DEVICE_PATH_PROTOCOL *FullPath
648 )
649{
650 EFI_STATUS Status;
651 UINTN Index;
652 UINTN HandleCount;
653 EFI_HANDLE *Handles;
654 EFI_BLOCK_IO_PROTOCOL *BlockIo;
655 UINTN MediaType;
656 EFI_DEVICE_PATH_PROTOCOL *NextFullPath;
657 BOOLEAN GetNext;
658
659 EfiBootManagerConnectAll ();
660 Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiSimpleFileSystemProtocolGuid, NULL, &HandleCount, &Handles);
661 if (EFI_ERROR (Status)) {
662 HandleCount = 0;
663 Handles = NULL;
664 }
665
666 GetNext = (BOOLEAN)(FullPath == NULL);
667 NextFullPath = NULL;
668 //
669 // Enumerate all removable media devices followed by all fixed media devices,
670 // followed by media devices which don't layer on block io.
671 //
672 for (MediaType = 0; MediaType < 3; MediaType++) {
673 for (Index = 0; Index < HandleCount; Index++) {
674 Status = gBS->HandleProtocol (Handles[Index], &gEfiBlockIoProtocolGuid, (VOID *) &BlockIo);
675 if (EFI_ERROR (Status)) {
676 BlockIo = NULL;
677 }
678 if ((MediaType == 0 && BlockIo != NULL && BlockIo->Media->RemovableMedia) ||
679 (MediaType == 1 && BlockIo != NULL && !BlockIo->Media->RemovableMedia) ||
680 (MediaType == 2 && BlockIo == NULL)
681 ) {
682 NextFullPath = AppendDevicePath (DevicePathFromHandle (Handles[Index]), FilePath);
683 if (GetNext) {
684 break;
685 } else {
686 GetNext = (BOOLEAN)(CompareMem (NextFullPath, FullPath, GetDevicePathSize (NextFullPath)) == 0);
687 FreePool (NextFullPath);
688 NextFullPath = NULL;
689 }
690 }
691 }
692 if (NextFullPath != NULL) {
693 break;
694 }
695 }
696
697 if (Handles != NULL) {
698 FreePool (Handles);
699 }
700
701 return NextFullPath;
702}
703
704/**
705 Expand URI device path node to be full device path in platform.
706
707 @param FilePath The device path pointing to a load option.
708 It could be a short-form device path.
709 @param FullPath The full path returned by the routine in last call.
710 Set to NULL in first call.
711
712 @return The next possible full path pointing to the load option.
713 Caller is responsible to free the memory.
714**/
715EFI_DEVICE_PATH_PROTOCOL *
716BmExpandUriDevicePath (
717 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
718 IN EFI_DEVICE_PATH_PROTOCOL *FullPath
719 )
720{
721 EFI_STATUS Status;
722 UINTN Index;
723 UINTN HandleCount;
724 EFI_HANDLE *Handles;
725 EFI_DEVICE_PATH_PROTOCOL *NextFullPath;
726 EFI_DEVICE_PATH_PROTOCOL *RamDiskDevicePath;
727 BOOLEAN GetNext;
728
729 EfiBootManagerConnectAll ();
730 Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiLoadFileProtocolGuid, NULL, &HandleCount, &Handles);
731 if (EFI_ERROR (Status)) {
732 HandleCount = 0;
733 Handles = NULL;
734 }
735
736 NextFullPath = NULL;
737 GetNext = (BOOLEAN)(FullPath == NULL);
738 for (Index = 0; Index < HandleCount; Index++) {
739 NextFullPath = BmExpandLoadFile (Handles[Index], FilePath);
740
741 if (NextFullPath == NULL) {
742 continue;
743 }
744
745 if (GetNext) {
746 break;
747 } else {
748 GetNext = (BOOLEAN)(CompareMem (NextFullPath, FullPath, GetDevicePathSize (NextFullPath)) == 0);
749 //
750 // Free the resource occupied by the RAM disk.
751 //
752 RamDiskDevicePath = BmGetRamDiskDevicePath (NextFullPath);
753 if (RamDiskDevicePath != NULL) {
754 BmDestroyRamDisk (RamDiskDevicePath);
755 FreePool (RamDiskDevicePath);
756 }
757 FreePool (NextFullPath);
758 NextFullPath = NULL;
759 }
760 }
761
762 if (Handles != NULL) {
763 FreePool (Handles);
764 }
765
766 return NextFullPath;
767}
768
769/**
770 Save the partition DevicePath to the CachedDevicePath as the first instance.
771
772 @param CachedDevicePath The device path cache.
773 @param DevicePath The partition device path to be cached.
774**/
775VOID
776BmCachePartitionDevicePath (
777 IN OUT EFI_DEVICE_PATH_PROTOCOL **CachedDevicePath,
778 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
779 )
780{
781 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
782 UINTN Count;
783
784 if (BmMatchDevicePaths (*CachedDevicePath, DevicePath)) {
785 TempDevicePath = *CachedDevicePath;
786 *CachedDevicePath = BmDelPartMatchInstance (*CachedDevicePath, DevicePath);
787 FreePool (TempDevicePath);
788 }
789
790 if (*CachedDevicePath == NULL) {
791 *CachedDevicePath = DuplicateDevicePath (DevicePath);
792 return;
793 }
794
795 TempDevicePath = *CachedDevicePath;
796 *CachedDevicePath = AppendDevicePathInstance (DevicePath, *CachedDevicePath);
797 if (TempDevicePath != NULL) {
798 FreePool (TempDevicePath);
799 }
800
801 //
802 // Here limit the device path instance number to 12, which is max number for a system support 3 IDE controller
803 // If the user try to boot many OS in different HDs or partitions, in theory, the 'HDDP' variable maybe become larger and larger.
804 //
805 Count = 0;
806 TempDevicePath = *CachedDevicePath;
807 while (!IsDevicePathEnd (TempDevicePath)) {
808 TempDevicePath = NextDevicePathNode (TempDevicePath);
809 //
810 // Parse one instance
811 //
812 while (!IsDevicePathEndType (TempDevicePath)) {
813 TempDevicePath = NextDevicePathNode (TempDevicePath);
814 }
815 Count++;
816 //
817 // If the CachedDevicePath variable contain too much instance, only remain 12 instances.
818 //
819 if (Count == 12) {
820 SetDevicePathEndNode (TempDevicePath);
821 break;
822 }
823 }
824}
825
826/**
827 Expand a device path that starts with a hard drive media device path node to be a
828 full device path that includes the full hardware path to the device. We need
829 to do this so it can be booted. As an optimization the front match (the part point
830 to the partition node. E.g. ACPI() /PCI()/ATA()/Partition() ) is saved in a variable
831 so a connect all is not required on every boot. All successful history device path
832 which point to partition node (the front part) will be saved.
833
834 @param FilePath The device path pointing to a load option.
835 It could be a short-form device path.
836
837 @return The full device path pointing to the load option.
838**/
839EFI_DEVICE_PATH_PROTOCOL *
840BmExpandPartitionDevicePath (
841 IN EFI_DEVICE_PATH_PROTOCOL *FilePath
842 )
843{
844 EFI_STATUS Status;
845 UINTN BlockIoHandleCount;
846 EFI_HANDLE *BlockIoBuffer;
847 EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath;
848 UINTN Index;
849 EFI_DEVICE_PATH_PROTOCOL *CachedDevicePath;
850 EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath;
851 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
852 EFI_DEVICE_PATH_PROTOCOL *FullPath;
853 UINTN CachedDevicePathSize;
854 BOOLEAN NeedAdjust;
855 EFI_DEVICE_PATH_PROTOCOL *Instance;
856 UINTN Size;
857
858 //
859 // Check if there is prestore 'HDDP' variable.
860 // If exist, search the front path which point to partition node in the variable instants.
861 // If fail to find or 'HDDP' not exist, reconnect all and search in all system
862 //
863 GetVariable2 (L"HDDP", &mBmHardDriveBootVariableGuid, (VOID **) &CachedDevicePath, &CachedDevicePathSize);
864
865 //
866 // Delete the invalid 'HDDP' variable.
867 //
868 if ((CachedDevicePath != NULL) && !IsDevicePathValid (CachedDevicePath, CachedDevicePathSize)) {
869 FreePool (CachedDevicePath);
870 CachedDevicePath = NULL;
871 Status = gRT->SetVariable (
872 L"HDDP",
873 &mBmHardDriveBootVariableGuid,
874 0,
875 0,
876 NULL
877 );
878 ASSERT_EFI_ERROR (Status);
879 }
880
881 FullPath = NULL;
882 if (CachedDevicePath != NULL) {
883 TempNewDevicePath = CachedDevicePath;
884 NeedAdjust = FALSE;
885 do {
886 //
887 // Check every instance of the variable
888 // First, check whether the instance contain the partition node, which is needed for distinguishing multi
889 // partial partition boot option. Second, check whether the instance could be connected.
890 //
891 Instance = GetNextDevicePathInstance (&TempNewDevicePath, &Size);
892 if (BmMatchPartitionDevicePathNode (Instance, (HARDDRIVE_DEVICE_PATH *) FilePath)) {
893 //
894 // Connect the device path instance, the device path point to hard drive media device path node
895 // e.g. ACPI() /PCI()/ATA()/Partition()
896 //
897 Status = EfiBootManagerConnectDevicePath (Instance, NULL);
898 if (!EFI_ERROR (Status)) {
899 TempDevicePath = AppendDevicePath (Instance, NextDevicePathNode (FilePath));
900 //
901 // TempDevicePath = ACPI()/PCI()/ATA()/Partition()
902 // or = ACPI()/PCI()/ATA()/Partition()/.../A.EFI
903 //
904 // When TempDevicePath = ACPI()/PCI()/ATA()/Partition(),
905 // it may expand to two potienal full paths (nested partition, rarely happen):
906 // 1. ACPI()/PCI()/ATA()/Partition()/Partition(A1)/EFI/BootX64.EFI
907 // 2. ACPI()/PCI()/ATA()/Partition()/Partition(A2)/EFI/BootX64.EFI
908 // For simplicity, only #1 is returned.
909 //
910 FullPath = BmGetNextLoadOptionDevicePath (TempDevicePath, NULL);
911 FreePool (TempDevicePath);
912
913 if (FullPath != NULL) {
914 //
915 // Adjust the 'HDDP' instances sequence if the matched one is not first one.
916 //
917 if (NeedAdjust) {
918 BmCachePartitionDevicePath (&CachedDevicePath, Instance);
919 //
920 // Save the matching Device Path so we don't need to do a connect all next time
921 // Failing to save only impacts performance next time expanding the short-form device path
922 //
923 Status = gRT->SetVariable (
924 L"HDDP",
925 &mBmHardDriveBootVariableGuid,
926 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
927 GetDevicePathSize (CachedDevicePath),
928 CachedDevicePath
929 );
930 }
931
932 FreePool (Instance);
933 FreePool (CachedDevicePath);
934 return FullPath;
935 }
936 }
937 }
938 //
939 // Come here means the first instance is not matched
940 //
941 NeedAdjust = TRUE;
942 FreePool(Instance);
943 } while (TempNewDevicePath != NULL);
944 }
945
946 //
947 // If we get here we fail to find or 'HDDP' not exist, and now we need
948 // to search all devices in the system for a matched partition
949 //
950 EfiBootManagerConnectAll ();
951 Status = gBS->LocateHandleBuffer (ByProtocol, &gEfiBlockIoProtocolGuid, NULL, &BlockIoHandleCount, &BlockIoBuffer);
952 if (EFI_ERROR (Status)) {
953 BlockIoHandleCount = 0;
954 BlockIoBuffer = NULL;
955 }
956 //
957 // Loop through all the device handles that support the BLOCK_IO Protocol
958 //
959 for (Index = 0; Index < BlockIoHandleCount; Index++) {
960 BlockIoDevicePath = DevicePathFromHandle (BlockIoBuffer[Index]);
961 if (BlockIoDevicePath == NULL) {
962 continue;
963 }
964
965 if (BmMatchPartitionDevicePathNode (BlockIoDevicePath, (HARDDRIVE_DEVICE_PATH *) FilePath)) {
966 //
967 // Find the matched partition device path
968 //
969 TempDevicePath = AppendDevicePath (BlockIoDevicePath, NextDevicePathNode (FilePath));
970 FullPath = BmGetNextLoadOptionDevicePath (TempDevicePath, NULL);
971 FreePool (TempDevicePath);
972
973 if (FullPath != NULL) {
974 BmCachePartitionDevicePath (&CachedDevicePath, BlockIoDevicePath);
975
976 //
977 // Save the matching Device Path so we don't need to do a connect all next time
978 // Failing to save only impacts performance next time expanding the short-form device path
979 //
980 Status = gRT->SetVariable (
981 L"HDDP",
982 &mBmHardDriveBootVariableGuid,
983 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
984 GetDevicePathSize (CachedDevicePath),
985 CachedDevicePath
986 );
987
988 break;
989 }
990 }
991 }
992
993 if (CachedDevicePath != NULL) {
994 FreePool (CachedDevicePath);
995 }
996 if (BlockIoBuffer != NULL) {
997 FreePool (BlockIoBuffer);
998 }
999 return FullPath;
1000}
1001
1002/**
1003 Expand the media device path which points to a BlockIo or SimpleFileSystem instance
1004 by appending EFI_REMOVABLE_MEDIA_FILE_NAME.
1005
1006 @param DevicePath The media device path pointing to a BlockIo or SimpleFileSystem instance.
1007 @param FullPath The full path returned by the routine in last call.
1008 Set to NULL in first call.
1009
1010 @return The next possible full path pointing to the load option.
1011 Caller is responsible to free the memory.
1012**/
1013EFI_DEVICE_PATH_PROTOCOL *
1014BmExpandMediaDevicePath (
1015 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1016 IN EFI_DEVICE_PATH_PROTOCOL *FullPath
1017 )
1018{
1019 EFI_STATUS Status;
1020 EFI_HANDLE Handle;
1021 EFI_BLOCK_IO_PROTOCOL *BlockIo;
1022 VOID *Buffer;
1023 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
1024 EFI_DEVICE_PATH_PROTOCOL *NextFullPath;
1025 UINTN Size;
1026 UINTN TempSize;
1027 EFI_HANDLE *SimpleFileSystemHandles;
1028 UINTN NumberSimpleFileSystemHandles;
1029 UINTN Index;
1030 BOOLEAN GetNext;
1031
1032 GetNext = (BOOLEAN)(FullPath == NULL);
1033 //
1034 // Check whether the device is connected
1035 //
1036 TempDevicePath = DevicePath;
1037 Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &TempDevicePath, &Handle);
1038 if (!EFI_ERROR (Status)) {
1039 ASSERT (IsDevicePathEnd (TempDevicePath));
1040
1041 NextFullPath = FileDevicePath (Handle, EFI_REMOVABLE_MEDIA_FILE_NAME);
1042 //
1043 // For device path pointing to simple file system, it only expands to one full path.
1044 //
1045 if (GetNext) {
1046 return NextFullPath;
1047 } else {
1048 FreePool (NextFullPath);
1049 return NULL;
1050 }
1051 }
1052
1053 Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &TempDevicePath, &Handle);
1054 ASSERT_EFI_ERROR (Status);
1055
1056 //
1057 // For device boot option only pointing to the removable device handle,
1058 // should make sure all its children handles (its child partion or media handles)
1059 // are created and connected.
1060 //
1061 gBS->ConnectController (Handle, NULL, NULL, TRUE);
1062
1063 //
1064 // Issue a dummy read to the device to check for media change.
1065 // When the removable media is changed, any Block IO read/write will
1066 // cause the BlockIo protocol be reinstalled and EFI_MEDIA_CHANGED is
1067 // returned. After the Block IO protocol is reinstalled, subsequent
1068 // Block IO read/write will success.
1069 //
1070 Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);
1071 ASSERT_EFI_ERROR (Status);
1072 Buffer = AllocatePool (BlockIo->Media->BlockSize);
1073 if (Buffer != NULL) {
1074 BlockIo->ReadBlocks (
1075 BlockIo,
1076 BlockIo->Media->MediaId,
1077 0,
1078 BlockIo->Media->BlockSize,
1079 Buffer
1080 );
1081 FreePool (Buffer);
1082 }
1083
1084 //
1085 // Detect the the default boot file from removable Media
1086 //
1087 NextFullPath = NULL;
1088 Size = GetDevicePathSize (DevicePath) - END_DEVICE_PATH_LENGTH;
1089 gBS->LocateHandleBuffer (
1090 ByProtocol,
1091 &gEfiSimpleFileSystemProtocolGuid,
1092 NULL,
1093 &NumberSimpleFileSystemHandles,
1094 &SimpleFileSystemHandles
1095 );
1096 for (Index = 0; Index < NumberSimpleFileSystemHandles; Index++) {
1097 //
1098 // Get the device path size of SimpleFileSystem handle
1099 //
1100 TempDevicePath = DevicePathFromHandle (SimpleFileSystemHandles[Index]);
1101 TempSize = GetDevicePathSize (TempDevicePath) - END_DEVICE_PATH_LENGTH;
1102 //
1103 // Check whether the device path of boot option is part of the SimpleFileSystem handle's device path
1104 //
1105 if ((Size <= TempSize) && (CompareMem (TempDevicePath, DevicePath, Size) == 0)) {
1106 NextFullPath = FileDevicePath (SimpleFileSystemHandles[Index], EFI_REMOVABLE_MEDIA_FILE_NAME);
1107 if (GetNext) {
1108 break;
1109 } else {
1110 GetNext = (BOOLEAN)(CompareMem (NextFullPath, FullPath, GetDevicePathSize (NextFullPath)) == 0);
1111 FreePool (NextFullPath);
1112 NextFullPath = NULL;
1113 }
1114 }
1115 }
1116
1117 if (SimpleFileSystemHandles != NULL) {
1118 FreePool (SimpleFileSystemHandles);
1119 }
1120
1121 return NextFullPath;
1122}
1123
1124/**
1125 Check whether Left and Right are the same without matching the specific
1126 device path data in IP device path and URI device path node.
1127
1128 @retval TRUE Left and Right are the same.
1129 @retval FALSE Left and Right are the different.
1130**/
1131BOOLEAN
1132BmMatchHttpBootDevicePath (
1133 IN EFI_DEVICE_PATH_PROTOCOL *Left,
1134 IN EFI_DEVICE_PATH_PROTOCOL *Right
1135 )
1136{
1137 for (; !IsDevicePathEnd (Left) && !IsDevicePathEnd (Right)
1138 ; Left = NextDevicePathNode (Left), Right = NextDevicePathNode (Right)
1139 ) {
1140 if (CompareMem (Left, Right, DevicePathNodeLength (Left)) != 0) {
1141 if ((DevicePathType (Left) != MESSAGING_DEVICE_PATH) || (DevicePathType (Right) != MESSAGING_DEVICE_PATH)) {
1142 return FALSE;
1143 }
1144
1145 if (DevicePathSubType (Left) == MSG_DNS_DP) {
1146 Left = NextDevicePathNode (Left);
1147 }
1148
1149 if (DevicePathSubType (Right) == MSG_DNS_DP) {
1150 Right = NextDevicePathNode (Right);
1151 }
1152
1153 if (((DevicePathSubType (Left) != MSG_IPv4_DP) || (DevicePathSubType (Right) != MSG_IPv4_DP)) &&
1154 ((DevicePathSubType (Left) != MSG_IPv6_DP) || (DevicePathSubType (Right) != MSG_IPv6_DP)) &&
1155 ((DevicePathSubType (Left) != MSG_URI_DP) || (DevicePathSubType (Right) != MSG_URI_DP))
1156 ) {
1157 return FALSE;
1158 }
1159 }
1160 }
1161 return (BOOLEAN) (IsDevicePathEnd (Left) && IsDevicePathEnd (Right));
1162}
1163
1164/**
1165 Get the file buffer from the file system produced by Load File instance.
1166
1167 @param LoadFileHandle The handle of LoadFile instance.
1168 @param RamDiskHandle Return the RAM Disk handle.
1169
1170 @return The next possible full path pointing to the load option.
1171 Caller is responsible to free the memory.
1172**/
1173EFI_DEVICE_PATH_PROTOCOL *
1174BmExpandNetworkFileSystem (
1175 IN EFI_HANDLE LoadFileHandle,
1176 OUT EFI_HANDLE *RamDiskHandle
1177 )
1178{
1179 EFI_STATUS Status;
1180 EFI_HANDLE Handle;
1181 EFI_HANDLE *Handles;
1182 UINTN HandleCount;
1183 UINTN Index;
1184 EFI_DEVICE_PATH_PROTOCOL *Node;
1185
1186 Status = gBS->LocateHandleBuffer (
1187 ByProtocol,
1188 &gEfiBlockIoProtocolGuid,
1189 NULL,
1190 &HandleCount,
1191 &Handles
1192 );
1193 if (EFI_ERROR (Status)) {
1194 Handles = NULL;
1195 HandleCount = 0;
1196 }
1197
1198 Handle = NULL;
1199 for (Index = 0; Index < HandleCount; Index++) {
1200 Node = DevicePathFromHandle (Handles[Index]);
1201 Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &Node, &Handle);
1202 if (!EFI_ERROR (Status) &&
1203 (Handle == LoadFileHandle) &&
1204 (DevicePathType (Node) == MEDIA_DEVICE_PATH) && (DevicePathSubType (Node) == MEDIA_RAM_DISK_DP)) {
1205 //
1206 // Find the BlockIo instance populated from the LoadFile.
1207 //
1208 Handle = Handles[Index];
1209 break;
1210 }
1211 }
1212
1213 if (Handles != NULL) {
1214 FreePool (Handles);
1215 }
1216
1217 if (Index == HandleCount) {
1218 Handle = NULL;
1219 }
1220
1221 *RamDiskHandle = Handle;
1222
1223 if (Handle != NULL) {
1224 //
1225 // Re-use BmExpandMediaDevicePath() to get the full device path of load option.
1226 // But assume only one SimpleFileSystem can be found under the BlockIo.
1227 //
1228 return BmExpandMediaDevicePath (DevicePathFromHandle (Handle), NULL);
1229 } else {
1230 return NULL;
1231 }
1232}
1233
1234/**
1235 Return the RAM Disk device path created by LoadFile.
1236
1237 @param FilePath The source file path.
1238
1239 @return Callee-to-free RAM Disk device path
1240**/
1241EFI_DEVICE_PATH_PROTOCOL *
1242BmGetRamDiskDevicePath (
1243 IN EFI_DEVICE_PATH_PROTOCOL *FilePath
1244 )
1245{
1246 EFI_STATUS Status;
1247 EFI_DEVICE_PATH_PROTOCOL *RamDiskDevicePath;
1248 EFI_DEVICE_PATH_PROTOCOL *Node;
1249 EFI_HANDLE Handle;
1250
1251 Node = FilePath;
1252 Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &Node, &Handle);
1253 if (!EFI_ERROR (Status) &&
1254 (DevicePathType (Node) == MEDIA_DEVICE_PATH) &&
1255 (DevicePathSubType (Node) == MEDIA_RAM_DISK_DP)
1256 ) {
1257
1258 //
1259 // Construct the device path pointing to RAM Disk
1260 //
1261 Node = NextDevicePathNode (Node);
1262 RamDiskDevicePath = DuplicateDevicePath (FilePath);
1263 ASSERT (RamDiskDevicePath != NULL);
1264 SetDevicePathEndNode ((VOID *) ((UINTN) RamDiskDevicePath + ((UINTN) Node - (UINTN) FilePath)));
1265 return RamDiskDevicePath;
1266 }
1267
1268 return NULL;
1269}
1270
1271/**
1272 Return the buffer and buffer size occupied by the RAM Disk.
1273
1274 @param RamDiskDevicePath RAM Disk device path.
1275 @param RamDiskSizeInPages Return RAM Disk size in pages.
1276
1277 @retval RAM Disk buffer.
1278**/
1279VOID *
1280BmGetRamDiskMemoryInfo (
1281 IN EFI_DEVICE_PATH_PROTOCOL *RamDiskDevicePath,
1282 OUT UINTN *RamDiskSizeInPages
1283 )
1284{
1285
1286 EFI_STATUS Status;
1287 EFI_HANDLE Handle;
1288 UINT64 StartingAddr;
1289 UINT64 EndingAddr;
1290
1291 ASSERT (RamDiskDevicePath != NULL);
1292
1293 *RamDiskSizeInPages = 0;
1294
1295 //
1296 // Get the buffer occupied by RAM Disk.
1297 //
1298 Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &RamDiskDevicePath, &Handle);
1299 ASSERT_EFI_ERROR (Status);
1300 ASSERT ((DevicePathType (RamDiskDevicePath) == MEDIA_DEVICE_PATH) &&
1301 (DevicePathSubType (RamDiskDevicePath) == MEDIA_RAM_DISK_DP));
1302 StartingAddr = ReadUnaligned64 ((UINT64 *) ((MEDIA_RAM_DISK_DEVICE_PATH *) RamDiskDevicePath)->StartingAddr);
1303 EndingAddr = ReadUnaligned64 ((UINT64 *) ((MEDIA_RAM_DISK_DEVICE_PATH *) RamDiskDevicePath)->EndingAddr);
1304 *RamDiskSizeInPages = EFI_SIZE_TO_PAGES ((UINTN) (EndingAddr - StartingAddr + 1));
1305 return (VOID *) (UINTN) StartingAddr;
1306}
1307
1308/**
1309 Destroy the RAM Disk.
1310
1311 The destroy operation includes to call RamDisk.Unregister to
1312 unregister the RAM DISK from RAM DISK driver, free the memory
1313 allocated for the RAM Disk.
1314
1315 @param RamDiskDevicePath RAM Disk device path.
1316**/
1317VOID
1318BmDestroyRamDisk (
1319 IN EFI_DEVICE_PATH_PROTOCOL *RamDiskDevicePath
1320 )
1321{
1322 EFI_STATUS Status;
1323 VOID *RamDiskBuffer;
1324 UINTN RamDiskSizeInPages;
1325
1326 ASSERT (RamDiskDevicePath != NULL);
1327
1328 RamDiskBuffer = BmGetRamDiskMemoryInfo (RamDiskDevicePath, &RamDiskSizeInPages);
1329
1330 //
1331 // Destroy RAM Disk.
1332 //
1333 if (mRamDisk == NULL) {
1334 Status = gBS->LocateProtocol (&gEfiRamDiskProtocolGuid, NULL, (VOID *) &mRamDisk);
1335 ASSERT_EFI_ERROR (Status);
1336 }
1337 Status = mRamDisk->Unregister (RamDiskDevicePath);
1338 ASSERT_EFI_ERROR (Status);
1339 FreePages (RamDiskBuffer, RamDiskSizeInPages);
1340}
1341
1342/**
1343 Get the file buffer from the specified Load File instance.
1344
1345 @param LoadFileHandle The specified Load File instance.
1346 @param FilePath The file path which will pass to LoadFile().
1347
1348 @return The full device path pointing to the load option buffer.
1349**/
1350EFI_DEVICE_PATH_PROTOCOL *
1351BmExpandLoadFile (
1352 IN EFI_HANDLE LoadFileHandle,
1353 IN EFI_DEVICE_PATH_PROTOCOL *FilePath
1354 )
1355{
1356 EFI_STATUS Status;
1357 EFI_LOAD_FILE_PROTOCOL *LoadFile;
1358 VOID *FileBuffer;
1359 EFI_HANDLE RamDiskHandle;
1360 UINTN BufferSize;
1361 EFI_DEVICE_PATH_PROTOCOL *FullPath;
1362
1363 Status = gBS->OpenProtocol (
1364 LoadFileHandle,
1365 &gEfiLoadFileProtocolGuid,
1366 (VOID **) &LoadFile,
1367 gImageHandle,
1368 NULL,
1369 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1370 );
1371 ASSERT_EFI_ERROR (Status);
1372
1373 FileBuffer = NULL;
1374 BufferSize = 0;
1375 Status = LoadFile->LoadFile (LoadFile, FilePath, TRUE, &BufferSize, FileBuffer);
1376 if ((Status != EFI_WARN_FILE_SYSTEM) && (Status != EFI_BUFFER_TOO_SMALL)) {
1377 return NULL;
1378 }
1379
1380 if (Status == EFI_BUFFER_TOO_SMALL) {
1381 //
1382 // The load option buffer is directly returned by LoadFile.
1383 //
1384 return DuplicateDevicePath (DevicePathFromHandle (LoadFileHandle));
1385 }
1386
1387 //
1388 // The load option resides in a RAM disk.
1389 //
1390 FileBuffer = AllocateReservedPages (EFI_SIZE_TO_PAGES (BufferSize));
1391 if (FileBuffer == NULL) {
1392 return NULL;
1393 }
1394
1395 Status = LoadFile->LoadFile (LoadFile, FilePath, TRUE, &BufferSize, FileBuffer);
1396 if (EFI_ERROR (Status)) {
1397 FreePages (FileBuffer, EFI_SIZE_TO_PAGES (BufferSize));
1398 return NULL;
1399 }
1400
1401 FullPath = BmExpandNetworkFileSystem (LoadFileHandle, &RamDiskHandle);
1402 if (FullPath == NULL) {
1403 //
1404 // Free the memory occupied by the RAM disk if there is no BlockIo or SimpleFileSystem instance.
1405 //
1406 BmDestroyRamDisk (DevicePathFromHandle (RamDiskHandle));
1407 }
1408
1409 return FullPath;
1410}
1411
1412/**
1413 Return the full device path pointing to the load option.
1414
1415 FilePath may:
1416 1. Exactly matches to a LoadFile instance.
1417 2. Cannot match to any LoadFile instance. Wide match is required.
1418 In either case, the routine may return:
1419 1. A copy of FilePath when FilePath matches to a LoadFile instance and
1420 the LoadFile returns a load option buffer.
1421 2. A new device path with IP and URI information updated when wide match
1422 happens.
1423 3. A new device path pointing to a load option in RAM disk.
1424 In either case, only one full device path is returned for a specified
1425 FilePath.
1426
1427 @param FilePath The media device path pointing to a LoadFile instance.
1428
1429 @return The load option buffer.
1430**/
1431EFI_DEVICE_PATH_PROTOCOL *
1432BmExpandLoadFiles (
1433 IN EFI_DEVICE_PATH_PROTOCOL *FilePath
1434 )
1435{
1436 EFI_STATUS Status;
1437 EFI_HANDLE Handle;
1438 EFI_HANDLE *Handles;
1439 UINTN HandleCount;
1440 UINTN Index;
1441 EFI_DEVICE_PATH_PROTOCOL *Node;
1442
1443 //
1444 // Get file buffer from load file instance.
1445 //
1446 Node = FilePath;
1447 Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &Node, &Handle);
1448 if (!EFI_ERROR (Status) && IsDevicePathEnd (Node)) {
1449 //
1450 // When wide match happens, pass full device path to LoadFile (),
1451 // otherwise, pass remaining device path to LoadFile ().
1452 //
1453 FilePath = Node;
1454 } else {
1455 Handle = NULL;
1456 //
1457 // Use wide match algorithm to find one when
1458 // cannot find a LoadFile instance to exactly match the FilePath
1459 //
1460 Status = gBS->LocateHandleBuffer (
1461 ByProtocol,
1462 &gEfiLoadFileProtocolGuid,
1463 NULL,
1464 &HandleCount,
1465 &Handles
1466 );
1467 if (EFI_ERROR (Status)) {
1468 Handles = NULL;
1469 HandleCount = 0;
1470 }
1471 for (Index = 0; Index < HandleCount; Index++) {
1472 if (BmMatchHttpBootDevicePath (DevicePathFromHandle (Handles[Index]), FilePath)) {
1473 Handle = Handles[Index];
1474 break;
1475 }
1476 }
1477 if (Handles != NULL) {
1478 FreePool (Handles);
1479 }
1480 }
1481
1482 if (Handle == NULL) {
1483 return NULL;
1484 }
1485
1486 return BmExpandLoadFile (Handle, FilePath);
1487}
1488
1489/**
1490 Get the load option by its device path.
1491
1492 @param FilePath The device path pointing to a load option.
1493 It could be a short-form device path.
1494 @param FullPath Return the full device path of the load option after
1495 short-form device path expanding.
1496 Caller is responsible to free it.
1497 @param FileSize Return the load option size.
1498
1499 @return The load option buffer. Caller is responsible to free the memory.
1500**/
1501VOID *
1502EFIAPI
1503EfiBootManagerGetLoadOptionBuffer (
1504 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1505 OUT EFI_DEVICE_PATH_PROTOCOL **FullPath,
1506 OUT UINTN *FileSize
1507 )
1508{
1509 *FullPath = NULL;
1510
1511 EfiBootManagerConnectDevicePath (FilePath, NULL);
1512 return BmGetNextLoadOptionBuffer (LoadOptionTypeMax, FilePath, FullPath, FileSize);
1513}
1514
1515/**
1516 Get the next possible full path pointing to the load option.
1517 The routine doesn't guarantee the returned full path points to an existing
1518 file, and it also doesn't guarantee the existing file is a valid load option.
1519 BmGetNextLoadOptionBuffer() guarantees.
1520
1521 @param FilePath The device path pointing to a load option.
1522 It could be a short-form device path.
1523 @param FullPath The full path returned by the routine in last call.
1524 Set to NULL in first call.
1525
1526 @return The next possible full path pointing to the load option.
1527 Caller is responsible to free the memory.
1528**/
1529EFI_DEVICE_PATH_PROTOCOL *
1530BmGetNextLoadOptionDevicePath (
1531 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
1532 IN EFI_DEVICE_PATH_PROTOCOL *FullPath
1533 )
1534{
1535 EFI_HANDLE Handle;
1536 EFI_DEVICE_PATH_PROTOCOL *Node;
1537 EFI_STATUS Status;
1538
1539 ASSERT (FilePath != NULL);
1540
1541 //
1542 // Boot from media device by adding a default file name \EFI\BOOT\BOOT{machine type short-name}.EFI
1543 //
1544 Node = FilePath;
1545 Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &Node, &Handle);
1546 if (EFI_ERROR (Status)) {
1547 Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &Node, &Handle);
1548 }
1549
1550 if (!EFI_ERROR (Status) && IsDevicePathEnd (Node)) {
1551 return BmExpandMediaDevicePath (FilePath, FullPath);
1552 }
1553
1554 //
1555 // Expand the short-form device path to full device path
1556 //
1557 if ((DevicePathType (FilePath) == MEDIA_DEVICE_PATH) &&
1558 (DevicePathSubType (FilePath) == MEDIA_HARDDRIVE_DP)) {
1559 //
1560 // Expand the Harddrive device path
1561 //
1562 if (FullPath == NULL) {
1563 return BmExpandPartitionDevicePath (FilePath);
1564 } else {
1565 return NULL;
1566 }
1567 } else if ((DevicePathType (FilePath) == MEDIA_DEVICE_PATH) &&
1568 (DevicePathSubType (FilePath) == MEDIA_FILEPATH_DP)) {
1569 //
1570 // Expand the File-path device path
1571 //
1572 return BmExpandFileDevicePath (FilePath, FullPath);
1573 } else if ((DevicePathType (FilePath) == MESSAGING_DEVICE_PATH) &&
1574 (DevicePathSubType (FilePath) == MSG_URI_DP)) {
1575 //
1576 // Expand the URI device path
1577 //
1578 return BmExpandUriDevicePath (FilePath, FullPath);
1579 } else {
1580 Node = FilePath;
1581 Status = gBS->LocateDevicePath (&gEfiUsbIoProtocolGuid, &Node, &Handle);
1582 if (EFI_ERROR (Status)) {
1583 //
1584 // Only expand the USB WWID/Class device path
1585 // when FilePath doesn't point to a physical UsbIo controller.
1586 // Otherwise, infinite recursion will happen.
1587 //
1588 for (Node = FilePath; !IsDevicePathEnd (Node); Node = NextDevicePathNode (Node)) {
1589 if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) &&
1590 ((DevicePathSubType (Node) == MSG_USB_CLASS_DP) || (DevicePathSubType (Node) == MSG_USB_WWID_DP))) {
1591 break;
1592 }
1593 }
1594
1595 //
1596 // Expand the USB WWID/Class device path
1597 //
1598 if (!IsDevicePathEnd (Node)) {
1599 if (FilePath == Node) {
1600 //
1601 // Boot Option device path starts with USB Class or USB WWID device path.
1602 // For Boot Option device path which doesn't begin with the USB Class or
1603 // USB WWID device path, it's not needed to connect again here.
1604 //
1605 BmConnectUsbShortFormDevicePath (FilePath);
1606 }
1607 return BmExpandUsbDevicePath (FilePath, FullPath, Node);
1608 }
1609 }
1610 }
1611
1612 //
1613 // For the below cases, FilePath only expands to one Full path.
1614 // So just handle the case when FullPath == NULL.
1615 //
1616 if (FullPath != NULL) {
1617 return NULL;
1618 }
1619
1620 //
1621 // Load option resides in FV.
1622 //
1623 if (BmIsFvFilePath (FilePath)) {
1624 return BmAdjustFvFilePath (FilePath);
1625 }
1626
1627 //
1628 // Load option resides in Simple File System.
1629 //
1630 Node = FilePath;
1631 Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &Node, &Handle);
1632 if (!EFI_ERROR (Status)) {
1633 return DuplicateDevicePath (FilePath);
1634 }
1635
1636 //
1637 // Last chance to try: Load option may be loaded through LoadFile.
1638 //
1639 return BmExpandLoadFiles (FilePath);
1640}
1641
1642/**
1643 Check if it's a Device Path pointing to BootManagerMenu.
1644
1645 @param DevicePath Input device path.
1646
1647 @retval TRUE The device path is BootManagerMenu File Device Path.
1648 @retval FALSE The device path is NOT BootManagerMenu File Device Path.
1649**/
1650BOOLEAN
1651BmIsBootManagerMenuFilePath (
1652 EFI_DEVICE_PATH_PROTOCOL *DevicePath
1653)
1654{
1655 EFI_HANDLE FvHandle;
1656 VOID *NameGuid;
1657 EFI_STATUS Status;
1658
1659 Status = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &DevicePath, &FvHandle);
1660 if (!EFI_ERROR (Status)) {
1661 NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePath);
1662 if (NameGuid != NULL) {
1663 return CompareGuid (NameGuid, PcdGetPtr (PcdBootManagerMenuFile));
1664 }
1665 }
1666
1667 return FALSE;
1668}
1669
1670/**
1671 Attempt to boot the EFI boot option. This routine sets L"BootCurent" and
1672 also signals the EFI ready to boot event. If the device path for the option
1673 starts with a BBS device path a legacy boot is attempted via the registered
1674 gLegacyBoot function. Short form device paths are also supported via this
1675 rountine. A device path starting with MEDIA_HARDDRIVE_DP, MSG_USB_WWID_DP,
1676 MSG_USB_CLASS_DP gets expaned out to find the first device that matches.
1677 If the BootOption Device Path fails the removable media boot algorithm
1678 is attempted (\EFI\BOOTIA32.EFI, \EFI\BOOTX64.EFI,... only one file type
1679 is tried per processor type)
1680
1681 @param BootOption Boot Option to try and boot.
1682 On return, BootOption->Status contains the boot status.
1683 EFI_SUCCESS BootOption was booted
1684 EFI_UNSUPPORTED A BBS device path was found with no valid callback
1685 registered via EfiBootManagerInitialize().
1686 EFI_NOT_FOUND The BootOption was not found on the system
1687 !EFI_SUCCESS BootOption failed with this error status
1688
1689**/
1690VOID
1691EFIAPI
1692EfiBootManagerBoot (
1693 IN EFI_BOOT_MANAGER_LOAD_OPTION *BootOption
1694 )
1695{
1696 EFI_STATUS Status;
1697 EFI_HANDLE ImageHandle;
1698 EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
1699 UINT16 Uint16;
1700 UINTN OptionNumber;
1701 UINTN OriginalOptionNumber;
1702 EFI_DEVICE_PATH_PROTOCOL *FilePath;
1703 EFI_DEVICE_PATH_PROTOCOL *RamDiskDevicePath;
1704 VOID *FileBuffer;
1705 UINTN FileSize;
1706 EFI_BOOT_LOGO_PROTOCOL *BootLogo;
1707 EFI_EVENT LegacyBootEvent;
1708
1709 if (BootOption == NULL) {
1710 return;
1711 }
1712
1713 if (BootOption->FilePath == NULL || BootOption->OptionType != LoadOptionTypeBoot) {
1714 BootOption->Status = EFI_INVALID_PARAMETER;
1715 return;
1716 }
1717
1718 //
1719 // 1. Create Boot#### for a temporary boot if there is no match Boot#### (i.e. a boot by selected a EFI Shell using "Boot From File")
1720 //
1721 OptionNumber = BmFindBootOptionInVariable (BootOption);
1722 if (OptionNumber == LoadOptionNumberUnassigned) {
1723 Status = BmGetFreeOptionNumber (LoadOptionTypeBoot, &Uint16);
1724 if (!EFI_ERROR (Status)) {
1725 //
1726 // Save the BootOption->OptionNumber to restore later
1727 //
1728 OptionNumber = Uint16;
1729 OriginalOptionNumber = BootOption->OptionNumber;
1730 BootOption->OptionNumber = OptionNumber;
1731 Status = EfiBootManagerLoadOptionToVariable (BootOption);
1732 BootOption->OptionNumber = OriginalOptionNumber;
1733 }
1734
1735 if (EFI_ERROR (Status)) {
1736 DEBUG ((EFI_D_ERROR, "[Bds] Failed to create Boot#### for a temporary boot - %r!\n", Status));
1737 BootOption->Status = Status;
1738 return ;
1739 }
1740 }
1741
1742 //
1743 // 2. Set BootCurrent
1744 //
1745 Uint16 = (UINT16) OptionNumber;
1746 BmSetVariableAndReportStatusCodeOnError (
1747 L"BootCurrent",
1748 &gEfiGlobalVariableGuid,
1749 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1750 sizeof (UINT16),
1751 &Uint16
1752 );
1753
1754 //
1755 // 3. Signal the EVT_SIGNAL_READY_TO_BOOT event when we are about to load and execute
1756 // the boot option.
1757 //
1758 if (BmIsBootManagerMenuFilePath (BootOption->FilePath)) {
1759 DEBUG ((EFI_D_INFO, "[Bds] Booting Boot Manager Menu.\n"));
1760 BmStopHotkeyService (NULL, NULL);
1761 } else {
1762 EfiSignalEventReadyToBoot();
1763 //
1764 // Report Status Code to indicate ReadyToBoot was signalled
1765 //
1766 REPORT_STATUS_CODE (EFI_PROGRESS_CODE, (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_PC_READY_TO_BOOT_EVENT));
1767 //
1768 // 4. Repair system through DriverHealth protocol
1769 //
1770 BmRepairAllControllers ();
1771 }
1772
1773 PERF_START_EX (gImageHandle, "BdsAttempt", NULL, 0, (UINT32) OptionNumber);
1774
1775 //
1776 // 5. Adjust the different type memory page number just before booting
1777 // and save the updated info into the variable for next boot to use
1778 //
1779 BmSetMemoryTypeInformationVariable (
1780 (BOOLEAN) ((BootOption->Attributes & LOAD_OPTION_CATEGORY) == LOAD_OPTION_CATEGORY_BOOT)
1781 );
1782
1783 //
1784 // 6. Load EFI boot option to ImageHandle
1785 //
1786 DEBUG_CODE_BEGIN ();
1787 if (BootOption->Description == NULL) {
1788 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "[Bds]Booting from unknown device path\n"));
1789 } else {
1790 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "[Bds]Booting %s\n", BootOption->Description));
1791 }
1792 DEBUG_CODE_END ();
1793
1794 ImageHandle = NULL;
1795 RamDiskDevicePath = NULL;
1796 if (DevicePathType (BootOption->FilePath) != BBS_DEVICE_PATH) {
1797 Status = EFI_NOT_FOUND;
1798 FilePath = NULL;
1799 EfiBootManagerConnectDevicePath (BootOption->FilePath, NULL);
1800 FileBuffer = BmGetNextLoadOptionBuffer (LoadOptionTypeBoot, BootOption->FilePath, &FilePath, &FileSize);
1801 if (FileBuffer != NULL) {
1802 RamDiskDevicePath = BmGetRamDiskDevicePath (FilePath);
1803
1804 REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderLoad));
1805 Status = gBS->LoadImage (
1806 TRUE,
1807 gImageHandle,
1808 FilePath,
1809 FileBuffer,
1810 FileSize,
1811 &ImageHandle
1812 );
1813 }
1814 if (FileBuffer != NULL) {
1815 FreePool (FileBuffer);
1816 }
1817 if (FilePath != NULL) {
1818 FreePool (FilePath);
1819 }
1820
1821 if (EFI_ERROR (Status)) {
1822 //
1823 // Report Status Code to indicate that the failure to load boot option
1824 //
1825 REPORT_STATUS_CODE (
1826 EFI_ERROR_CODE | EFI_ERROR_MINOR,
1827 (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_EC_BOOT_OPTION_LOAD_ERROR)
1828 );
1829 BootOption->Status = Status;
1830 //
1831 // Destroy the RAM disk
1832 //
1833 if (RamDiskDevicePath != NULL) {
1834 BmDestroyRamDisk (RamDiskDevicePath);
1835 FreePool (RamDiskDevicePath);
1836 }
1837 return;
1838 }
1839 }
1840
1841 //
1842 // Check to see if we should legacy BOOT. If yes then do the legacy boot
1843 // Write boot to OS performance data for Legacy boot
1844 //
1845 if ((DevicePathType (BootOption->FilePath) == BBS_DEVICE_PATH) && (DevicePathSubType (BootOption->FilePath) == BBS_BBS_DP)) {
1846 if (mBmLegacyBoot != NULL) {
1847 //
1848 // Write boot to OS performance data for legacy boot.
1849 //
1850 PERF_CODE (
1851 //
1852 // Create an event to be signalled when Legacy Boot occurs to write performance data.
1853 //
1854 Status = EfiCreateEventLegacyBootEx(
1855 TPL_NOTIFY,
1856 BmEndOfBdsPerfCode,
1857 NULL,
1858 &LegacyBootEvent
1859 );
1860 ASSERT_EFI_ERROR (Status);
1861 );
1862
1863 mBmLegacyBoot (BootOption);
1864 } else {
1865 BootOption->Status = EFI_UNSUPPORTED;
1866 }
1867
1868 PERF_END_EX (gImageHandle, "BdsAttempt", NULL, 0, (UINT32) OptionNumber);
1869 return;
1870 }
1871
1872 //
1873 // Provide the image with its load options
1874 //
1875 Status = gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &ImageInfo);
1876 ASSERT_EFI_ERROR (Status);
1877
1878 if (!BmIsAutoCreateBootOption (BootOption)) {
1879 ImageInfo->LoadOptionsSize = BootOption->OptionalDataSize;
1880 ImageInfo->LoadOptions = BootOption->OptionalData;
1881 }
1882
1883 //
1884 // Clean to NULL because the image is loaded directly from the firmwares boot manager.
1885 //
1886 ImageInfo->ParentHandle = NULL;
1887
1888 //
1889 // Before calling the image, enable the Watchdog Timer for 5 minutes period
1890 //
1891 gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
1892
1893 //
1894 // Write boot to OS performance data for UEFI boot
1895 //
1896 PERF_CODE (
1897 BmEndOfBdsPerfCode (NULL, NULL);
1898 );
1899
1900 REPORT_STATUS_CODE (EFI_PROGRESS_CODE, PcdGet32 (PcdProgressCodeOsLoaderStart));
1901
1902 Status = gBS->StartImage (ImageHandle, &BootOption->ExitDataSize, &BootOption->ExitData);
1903 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Image Return Status = %r\n", Status));
1904 BootOption->Status = Status;
1905 if (EFI_ERROR (Status)) {
1906 //
1907 // Report Status Code to indicate that boot failure
1908 //
1909 REPORT_STATUS_CODE (
1910 EFI_ERROR_CODE | EFI_ERROR_MINOR,
1911 (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_DXE_BS_EC_BOOT_OPTION_FAILED)
1912 );
1913 }
1914 PERF_END_EX (gImageHandle, "BdsAttempt", NULL, 0, (UINT32) OptionNumber);
1915
1916 //
1917 // Destroy the RAM disk
1918 //
1919 if (RamDiskDevicePath != NULL) {
1920 BmDestroyRamDisk (RamDiskDevicePath);
1921 FreePool (RamDiskDevicePath);
1922 }
1923
1924 //
1925 // Clear the Watchdog Timer after the image returns
1926 //
1927 gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
1928
1929 //
1930 // Set Logo status invalid after trying one boot option
1931 //
1932 BootLogo = NULL;
1933 Status = gBS->LocateProtocol (&gEfiBootLogoProtocolGuid, NULL, (VOID **) &BootLogo);
1934 if (!EFI_ERROR (Status) && (BootLogo != NULL)) {
1935 Status = BootLogo->SetBootLogo (BootLogo, NULL, 0, 0, 0, 0);
1936 ASSERT_EFI_ERROR (Status);
1937 }
1938
1939 //
1940 // Clear Boot Current
1941 //
1942 Status = gRT->SetVariable (
1943 L"BootCurrent",
1944 &gEfiGlobalVariableGuid,
1945 0,
1946 0,
1947 NULL
1948 );
1949 //
1950 // Deleting variable with current variable implementation shouldn't fail.
1951 // When BootXXXX (e.g.: BootManagerMenu) boots BootYYYY, exiting BootYYYY causes BootCurrent deleted,
1952 // exiting BootXXXX causes deleting BootCurrent returns EFI_NOT_FOUND.
1953 //
1954 ASSERT (Status == EFI_SUCCESS || Status == EFI_NOT_FOUND);
1955}
1956
1957/**
1958 Check whether there is a instance in BlockIoDevicePath, which contain multi device path
1959 instances, has the same partition node with HardDriveDevicePath device path
1960
1961 @param BlockIoDevicePath Multi device path instances which need to check
1962 @param HardDriveDevicePath A device path which starts with a hard drive media
1963 device path.
1964
1965 @retval TRUE There is a matched device path instance.
1966 @retval FALSE There is no matched device path instance.
1967
1968**/
1969BOOLEAN
1970BmMatchPartitionDevicePathNode (
1971 IN EFI_DEVICE_PATH_PROTOCOL *BlockIoDevicePath,
1972 IN HARDDRIVE_DEVICE_PATH *HardDriveDevicePath
1973 )
1974{
1975 HARDDRIVE_DEVICE_PATH *Node;
1976
1977 if ((BlockIoDevicePath == NULL) || (HardDriveDevicePath == NULL)) {
1978 return FALSE;
1979 }
1980
1981 //
1982 // find the partition device path node
1983 //
1984 while (!IsDevicePathEnd (BlockIoDevicePath)) {
1985 if ((DevicePathType (BlockIoDevicePath) == MEDIA_DEVICE_PATH) &&
1986 (DevicePathSubType (BlockIoDevicePath) == MEDIA_HARDDRIVE_DP)
1987 ) {
1988 break;
1989 }
1990
1991 BlockIoDevicePath = NextDevicePathNode (BlockIoDevicePath);
1992 }
1993
1994 if (IsDevicePathEnd (BlockIoDevicePath)) {
1995 return FALSE;
1996 }
1997
1998 //
1999 // See if the harddrive device path in blockio matches the orig Hard Drive Node
2000 //
2001 Node = (HARDDRIVE_DEVICE_PATH *) BlockIoDevicePath;
2002
2003 //
2004 // Match Signature and PartitionNumber.
2005 // Unused bytes in Signature are initiaized with zeros.
2006 //
2007 return (BOOLEAN) (
2008 (Node->PartitionNumber == HardDriveDevicePath->PartitionNumber) &&
2009 (Node->MBRType == HardDriveDevicePath->MBRType) &&
2010 (Node->SignatureType == HardDriveDevicePath->SignatureType) &&
2011 (CompareMem (Node->Signature, HardDriveDevicePath->Signature, sizeof (Node->Signature)) == 0)
2012 );
2013}
2014
2015/**
2016 Emuerate all possible bootable medias in the following order:
2017 1. Removable BlockIo - The boot option only points to the removable media
2018 device, like USB key, DVD, Floppy etc.
2019 2. Fixed BlockIo - The boot option only points to a Fixed blockIo device,
2020 like HardDisk.
2021 3. Non-BlockIo SimpleFileSystem - The boot option points to a device supporting
2022 SimpleFileSystem Protocol, but not supporting BlockIo
2023 protocol.
2024 4. LoadFile - The boot option points to the media supporting
2025 LoadFile protocol.
2026 Reference: UEFI Spec chapter 3.3 Boot Option Variables Default Boot Behavior
2027
2028 @param BootOptionCount Return the boot option count which has been found.
2029
2030 @retval Pointer to the boot option array.
2031**/
2032EFI_BOOT_MANAGER_LOAD_OPTION *
2033BmEnumerateBootOptions (
2034 UINTN *BootOptionCount
2035 )
2036{
2037 EFI_STATUS Status;
2038 EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions;
2039 UINTN HandleCount;
2040 EFI_HANDLE *Handles;
2041 EFI_BLOCK_IO_PROTOCOL *BlkIo;
2042 UINTN Removable;
2043 UINTN Index;
2044 CHAR16 *Description;
2045
2046 ASSERT (BootOptionCount != NULL);
2047
2048 *BootOptionCount = 0;
2049 BootOptions = NULL;
2050
2051 //
2052 // Parse removable block io followed by fixed block io
2053 //
2054 gBS->LocateHandleBuffer (
2055 ByProtocol,
2056 &gEfiBlockIoProtocolGuid,
2057 NULL,
2058 &HandleCount,
2059 &Handles
2060 );
2061
2062 for (Removable = 0; Removable < 2; Removable++) {
2063 for (Index = 0; Index < HandleCount; Index++) {
2064 Status = gBS->HandleProtocol (
2065 Handles[Index],
2066 &gEfiBlockIoProtocolGuid,
2067 (VOID **) &BlkIo
2068 );
2069 if (EFI_ERROR (Status)) {
2070 continue;
2071 }
2072
2073 //
2074 // Skip the logical partitions
2075 //
2076 if (BlkIo->Media->LogicalPartition) {
2077 continue;
2078 }
2079
2080 //
2081 // Skip the fixed block io then the removable block io
2082 //
2083 if (BlkIo->Media->RemovableMedia == ((Removable == 0) ? FALSE : TRUE)) {
2084 continue;
2085 }
2086
2087 Description = BmGetBootDescription (Handles[Index]);
2088 BootOptions = ReallocatePool (
2089 sizeof (EFI_BOOT_MANAGER_LOAD_OPTION) * (*BootOptionCount),
2090 sizeof (EFI_BOOT_MANAGER_LOAD_OPTION) * (*BootOptionCount + 1),
2091 BootOptions
2092 );
2093 ASSERT (BootOptions != NULL);
2094
2095 Status = EfiBootManagerInitializeLoadOption (
2096 &BootOptions[(*BootOptionCount)++],
2097 LoadOptionNumberUnassigned,
2098 LoadOptionTypeBoot,
2099 LOAD_OPTION_ACTIVE,
2100 Description,
2101 DevicePathFromHandle (Handles[Index]),
2102 NULL,
2103 0
2104 );
2105 ASSERT_EFI_ERROR (Status);
2106
2107 FreePool (Description);
2108 }
2109 }
2110
2111 if (HandleCount != 0) {
2112 FreePool (Handles);
2113 }
2114
2115 //
2116 // Parse simple file system not based on block io
2117 //
2118 gBS->LocateHandleBuffer (
2119 ByProtocol,
2120 &gEfiSimpleFileSystemProtocolGuid,
2121 NULL,
2122 &HandleCount,
2123 &Handles
2124 );
2125 for (Index = 0; Index < HandleCount; Index++) {
2126 Status = gBS->HandleProtocol (
2127 Handles[Index],
2128 &gEfiBlockIoProtocolGuid,
2129 (VOID **) &BlkIo
2130 );
2131 if (!EFI_ERROR (Status)) {
2132 //
2133 // Skip if the file system handle supports a BlkIo protocol, which we've handled in above
2134 //
2135 continue;
2136 }
2137 Description = BmGetBootDescription (Handles[Index]);
2138 BootOptions = ReallocatePool (
2139 sizeof (EFI_BOOT_MANAGER_LOAD_OPTION) * (*BootOptionCount),
2140 sizeof (EFI_BOOT_MANAGER_LOAD_OPTION) * (*BootOptionCount + 1),
2141 BootOptions
2142 );
2143 ASSERT (BootOptions != NULL);
2144
2145 Status = EfiBootManagerInitializeLoadOption (
2146 &BootOptions[(*BootOptionCount)++],
2147 LoadOptionNumberUnassigned,
2148 LoadOptionTypeBoot,
2149 LOAD_OPTION_ACTIVE,
2150 Description,
2151 DevicePathFromHandle (Handles[Index]),
2152 NULL,
2153 0
2154 );
2155 ASSERT_EFI_ERROR (Status);
2156 FreePool (Description);
2157 }
2158
2159 if (HandleCount != 0) {
2160 FreePool (Handles);
2161 }
2162
2163 //
2164 // Parse load file protocol
2165 //
2166 gBS->LocateHandleBuffer (
2167 ByProtocol,
2168 &gEfiLoadFileProtocolGuid,
2169 NULL,
2170 &HandleCount,
2171 &Handles
2172 );
2173 for (Index = 0; Index < HandleCount; Index++) {
2174 //
2175 // Ignore BootManagerMenu. its boot option will be created by EfiBootManagerGetBootManagerMenu().
2176 //
2177 if (BmIsBootManagerMenuFilePath (DevicePathFromHandle (Handles[Index]))) {
2178 continue;
2179 }
2180
2181 Description = BmGetBootDescription (Handles[Index]);
2182 BootOptions = ReallocatePool (
2183 sizeof (EFI_BOOT_MANAGER_LOAD_OPTION) * (*BootOptionCount),
2184 sizeof (EFI_BOOT_MANAGER_LOAD_OPTION) * (*BootOptionCount + 1),
2185 BootOptions
2186 );
2187 ASSERT (BootOptions != NULL);
2188
2189 Status = EfiBootManagerInitializeLoadOption (
2190 &BootOptions[(*BootOptionCount)++],
2191 LoadOptionNumberUnassigned,
2192 LoadOptionTypeBoot,
2193 LOAD_OPTION_ACTIVE,
2194 Description,
2195 DevicePathFromHandle (Handles[Index]),
2196 NULL,
2197 0
2198 );
2199 ASSERT_EFI_ERROR (Status);
2200 FreePool (Description);
2201 }
2202
2203 if (HandleCount != 0) {
2204 FreePool (Handles);
2205 }
2206
2207 BmMakeBootOptionDescriptionUnique (BootOptions, *BootOptionCount);
2208 return BootOptions;
2209}
2210
2211/**
2212 The function enumerates all boot options, creates them and registers them in the BootOrder variable.
2213**/
2214VOID
2215EFIAPI
2216EfiBootManagerRefreshAllBootOption (
2217 VOID
2218 )
2219{
2220 EFI_STATUS Status;
2221 EFI_BOOT_MANAGER_LOAD_OPTION *NvBootOptions;
2222 UINTN NvBootOptionCount;
2223 EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions;
2224 UINTN BootOptionCount;
2225 UINTN Index;
2226
2227 //
2228 // Optionally refresh the legacy boot option
2229 //
2230 if (mBmRefreshLegacyBootOption != NULL) {
2231 mBmRefreshLegacyBootOption ();
2232 }
2233
2234 BootOptions = BmEnumerateBootOptions (&BootOptionCount);
2235 NvBootOptions = EfiBootManagerGetLoadOptions (&NvBootOptionCount, LoadOptionTypeBoot);
2236
2237 //
2238 // Mark the boot option as added by BDS by setting OptionalData to a special GUID
2239 //
2240 for (Index = 0; Index < BootOptionCount; Index++) {
2241 BootOptions[Index].OptionalData = AllocateCopyPool (sizeof (EFI_GUID), &mBmAutoCreateBootOptionGuid);
2242 BootOptions[Index].OptionalDataSize = sizeof (EFI_GUID);
2243 }
2244
2245 //
2246 // Remove invalid EFI boot options from NV
2247 //
2248 for (Index = 0; Index < NvBootOptionCount; Index++) {
2249 if (((DevicePathType (NvBootOptions[Index].FilePath) != BBS_DEVICE_PATH) ||
2250 (DevicePathSubType (NvBootOptions[Index].FilePath) != BBS_BBS_DP)
2251 ) && BmIsAutoCreateBootOption (&NvBootOptions[Index])
2252 ) {
2253 //
2254 // Only check those added by BDS
2255 // so that the boot options added by end-user or OS installer won't be deleted
2256 //
2257 if (EfiBootManagerFindLoadOption (&NvBootOptions[Index], BootOptions, BootOptionCount) == -1) {
2258 Status = EfiBootManagerDeleteLoadOptionVariable (NvBootOptions[Index].OptionNumber, LoadOptionTypeBoot);
2259 //
2260 // Deleting variable with current variable implementation shouldn't fail.
2261 //
2262 ASSERT_EFI_ERROR (Status);
2263 }
2264 }
2265 }
2266
2267 //
2268 // Add new EFI boot options to NV
2269 //
2270 for (Index = 0; Index < BootOptionCount; Index++) {
2271 if (EfiBootManagerFindLoadOption (&BootOptions[Index], NvBootOptions, NvBootOptionCount) == -1) {
2272 EfiBootManagerAddLoadOptionVariable (&BootOptions[Index], (UINTN) -1);
2273 //
2274 // Try best to add the boot options so continue upon failure.
2275 //
2276 }
2277 }
2278
2279 EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount);
2280 EfiBootManagerFreeLoadOptions (NvBootOptions, NvBootOptionCount);
2281}
2282
2283/**
2284 This function is called to get or create the boot option for the Boot Manager Menu.
2285
2286 The Boot Manager Menu is shown after successfully booting a boot option.
2287 Assume the BootManagerMenuFile is in the same FV as the module links to this library.
2288
2289 @param BootOption Return the boot option of the Boot Manager Menu
2290
2291 @retval EFI_SUCCESS Successfully register the Boot Manager Menu.
2292 @retval EFI_NOT_FOUND The Boot Manager Menu cannot be found.
2293 @retval others Return status of gRT->SetVariable (). BootOption still points
2294 to the Boot Manager Menu even the Status is not EFI_SUCCESS
2295 and EFI_NOT_FOUND.
2296**/
2297EFI_STATUS
2298BmRegisterBootManagerMenu (
2299 OUT EFI_BOOT_MANAGER_LOAD_OPTION *BootOption
2300 )
2301{
2302 EFI_STATUS Status;
2303 CHAR16 *Description;
2304 UINTN DescriptionLength;
2305 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
2306 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
2307 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH FileNode;
2308 UINTN HandleCount;
2309 EFI_HANDLE *Handles;
2310 UINTN Index;
2311 VOID *Data;
2312 UINTN DataSize;
2313
2314 DevicePath = NULL;
2315 Description = NULL;
2316 //
2317 // Try to find BootManagerMenu from LoadFile protocol
2318 //
2319 gBS->LocateHandleBuffer (
2320 ByProtocol,
2321 &gEfiLoadFileProtocolGuid,
2322 NULL,
2323 &HandleCount,
2324 &Handles
2325 );
2326 for (Index = 0; Index < HandleCount; Index++) {
2327 if (BmIsBootManagerMenuFilePath (DevicePathFromHandle (Handles[Index]))) {
2328 DevicePath = DuplicateDevicePath (DevicePathFromHandle (Handles[Index]));
2329 Description = BmGetBootDescription (Handles[Index]);
2330 break;
2331 }
2332 }
2333 if (HandleCount != 0) {
2334 FreePool (Handles);
2335 }
2336
2337 if (DevicePath == NULL) {
2338 Data = NULL;
2339 Status = GetSectionFromFv (
2340 PcdGetPtr (PcdBootManagerMenuFile),
2341 EFI_SECTION_PE32,
2342 0,
2343 (VOID **) &Data,
2344 &DataSize
2345 );
2346 if (Data != NULL) {
2347 FreePool (Data);
2348 }
2349 if (EFI_ERROR (Status)) {
2350 DEBUG ((EFI_D_WARN, "[Bds]BootManagerMenu FFS section can not be found, skip its boot option registration\n"));
2351 return EFI_NOT_FOUND;
2352 }
2353
2354 //
2355 // Get BootManagerMenu application's description from EFI User Interface Section.
2356 //
2357 Status = GetSectionFromFv (
2358 PcdGetPtr (PcdBootManagerMenuFile),
2359 EFI_SECTION_USER_INTERFACE,
2360 0,
2361 (VOID **) &Description,
2362 &DescriptionLength
2363 );
2364 if (EFI_ERROR (Status)) {
2365 Description = NULL;
2366 }
2367
2368 EfiInitializeFwVolDevicepathNode (&FileNode, PcdGetPtr (PcdBootManagerMenuFile));
2369 Status = gBS->HandleProtocol (
2370 gImageHandle,
2371 &gEfiLoadedImageProtocolGuid,
2372 (VOID **) &LoadedImage
2373 );
2374 ASSERT_EFI_ERROR (Status);
2375 DevicePath = AppendDevicePathNode (
2376 DevicePathFromHandle (LoadedImage->DeviceHandle),
2377 (EFI_DEVICE_PATH_PROTOCOL *) &FileNode
2378 );
2379 ASSERT (DevicePath != NULL);
2380 }
2381
2382 Status = EfiBootManagerInitializeLoadOption (
2383 BootOption,
2384 LoadOptionNumberUnassigned,
2385 LoadOptionTypeBoot,
2386 LOAD_OPTION_CATEGORY_APP | LOAD_OPTION_ACTIVE | LOAD_OPTION_HIDDEN,
2387 (Description != NULL) ? Description : L"Boot Manager Menu",
2388 DevicePath,
2389 NULL,
2390 0
2391 );
2392 ASSERT_EFI_ERROR (Status);
2393 FreePool (DevicePath);
2394 if (Description != NULL) {
2395 FreePool (Description);
2396 }
2397
2398 DEBUG_CODE (
2399 EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions;
2400 UINTN BootOptionCount;
2401
2402 BootOptions = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot);
2403 ASSERT (EfiBootManagerFindLoadOption (BootOption, BootOptions, BootOptionCount) == -1);
2404 EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount);
2405 );
2406
2407 return EfiBootManagerAddLoadOptionVariable (BootOption, 0);
2408}
2409
2410/**
2411 Return the boot option corresponding to the Boot Manager Menu.
2412 It may automatically create one if the boot option hasn't been created yet.
2413
2414 @param BootOption Return the Boot Manager Menu.
2415
2416 @retval EFI_SUCCESS The Boot Manager Menu is successfully returned.
2417 @retval EFI_NOT_FOUND The Boot Manager Menu cannot be found.
2418 @retval others Return status of gRT->SetVariable (). BootOption still points
2419 to the Boot Manager Menu even the Status is not EFI_SUCCESS
2420 and EFI_NOT_FOUND.
2421**/
2422EFI_STATUS
2423EFIAPI
2424EfiBootManagerGetBootManagerMenu (
2425 EFI_BOOT_MANAGER_LOAD_OPTION *BootOption
2426 )
2427{
2428 EFI_STATUS Status;
2429 UINTN BootOptionCount;
2430 EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions;
2431 UINTN Index;
2432
2433 BootOptions = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot);
2434
2435 for (Index = 0; Index < BootOptionCount; Index++) {
2436 if (BmIsBootManagerMenuFilePath (BootOptions[Index].FilePath)) {
2437 Status = EfiBootManagerInitializeLoadOption (
2438 BootOption,
2439 BootOptions[Index].OptionNumber,
2440 BootOptions[Index].OptionType,
2441 BootOptions[Index].Attributes,
2442 BootOptions[Index].Description,
2443 BootOptions[Index].FilePath,
2444 BootOptions[Index].OptionalData,
2445 BootOptions[Index].OptionalDataSize
2446 );
2447 ASSERT_EFI_ERROR (Status);
2448 break;
2449 }
2450 }
2451
2452 EfiBootManagerFreeLoadOptions (BootOptions, BootOptionCount);
2453
2454 //
2455 // Automatically create the Boot#### for Boot Manager Menu when not found.
2456 //
2457 if (Index == BootOptionCount) {
2458 return BmRegisterBootManagerMenu (BootOption);
2459 } else {
2460 return EFI_SUCCESS;
2461 }
2462}
2463
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette