VOID
PlatformBdsRestoreNvVarsFromHardDisk ()
{
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
EFI_STATUS Status;
HandleCount = 0;
HandleBuffer = NULL;
VBoxLogFlowFuncEnter();
VisitAllPciInstances (ConnectRecursivelyIfPciMassStorage);
#ifndef VBOX
VisitAllInstancesOfProtocol (
&gEfiSimpleFileSystemProtocolGuid,
VisitingFileSystemInstance,
NULL
);
#endif
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleFileSystemProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
VBoxLogFlowFuncMarkRC(Status);
VBoxLogFlowFuncLeave();
}
static EFI_STATUS fsw_efi_ReMount(IN FSW_VOLUME_DATA *pVolume,
IN EFI_HANDLE ControllerHandle,
EFI_DISK_IO *pDiskIo,
EFI_BLOCK_IO *pBlockIo)
{
EFI_STATUS Status;
VBoxLogFlowFuncEnter();
pVolume->Signature = FSW_VOLUME_DATA_SIGNATURE;
pVolume->Handle = ControllerHandle;
pVolume->DiskIo = pDiskIo;
pVolume->MediaId = pBlockIo->Media->MediaId;
pVolume->LastIOStatus = EFI_SUCCESS;
// mount the filesystem
Status = fsw_efi_map_status(fsw_mount(pVolume, &fsw_efi_host_table,
&FSW_FSTYPE_TABLE_NAME(FSTYPE), &pVolume->vol),
pVolume);
VBoxLogFlowFuncMarkRC(Status);
if (!EFI_ERROR(Status)) {
// register the SimpleFileSystem protocol
pVolume->FileSystem.Revision = EFI_FILE_IO_INTERFACE_REVISION;
pVolume->FileSystem.OpenVolume = fsw_efi_FileSystem_OpenVolume;
Status = BS->InstallMultipleProtocolInterfaces(&ControllerHandle,
&PROTO_NAME(SimpleFileSystemProtocol), &pVolume->FileSystem,
NULL);
if (EFI_ERROR(Status))
Print(L"Fsw ERROR: InstallMultipleProtocolInterfaces returned %x\n", Status);
}
VBoxLogFlowFuncLeaveRC(Status);
return Status;
}
VOID
EFIAPI
PlatformBdsPolicyBehavior (
IN OUT LIST_ENTRY *DriverOptionList,
IN OUT LIST_ENTRY *BootOptionList,
IN PROCESS_CAPSULES ProcessCapsules,
IN BASEM_MEMORY_TEST BaseMemoryTest
)
/*++
Routine Description:
The function will excute with as the platform policy, current policy
is driven by boot mode. IBV/OEM can customize this code for their specific
policy action.
Arguments:
DriverOptionList - The header of the driver option link list
BootOptionList - The header of the boot option link list
ProcessCapsules - A pointer to ProcessCapsules()
BaseMemoryTest - A pointer to BaseMemoryTest()
Returns:
None.
--*/
{
EFI_STATUS Status;
UINT16 Timeout;
EFI_EVENT UserInputDurationTime;
LIST_ENTRY *Link;
BDS_COMMON_OPTION *BootOption;
UINTN Index;
EFI_INPUT_KEY Key;
EFI_TPL OldTpl;
EFI_BOOT_MODE BootMode;
VBoxLogFlowFuncEnter();
ConnectRootBridge ();
if (PcdGetBool (PcdOvmfFlashVariablesEnable)) {
DEBUG ((EFI_D_INFO, "PlatformBdsPolicyBehavior: not restoring NvVars "
"from disk since flash variables appear to be supported.\n"));
} else {
//
// Try to restore variables from the hard disk early so
// they can be used for the other BDS connect operations.
//
PlatformBdsRestoreNvVarsFromHardDisk ();
}
//
// Init the time out value
//
Timeout = PcdGet16 (PcdPlatformBootTimeOut);
//
// Load the driver option as the driver option list
//
PlatformBdsGetDriverOption (DriverOptionList);
//
// Get current Boot Mode
//
Status = BdsLibGetBootMode (&BootMode);
DEBUG ((EFI_D_ERROR, "Boot Mode:%x\n", BootMode));
//
// Go the different platform policy with different boot mode
// Notes: this part code can be change with the table policy
//
ASSERT (BootMode == BOOT_WITH_FULL_CONFIGURATION);
//
// Connect platform console
//
Status = PlatformBdsConnectConsole (gPlatformConsole);
if (EFI_ERROR (Status)) {
//
// Here OEM/IBV can customize with defined action
//
PlatformBdsNoConsoleAction ();
}
//
// Create a 300ms duration event to ensure user has enough input time to enter Setup
//
Status = gBS->CreateEvent (
EVT_TIMER,
0,
NULL,
NULL,
&UserInputDurationTime
);
ASSERT (Status == EFI_SUCCESS);
Status = gBS->SetTimer (UserInputDurationTime, TimerRelative, 3000000);
ASSERT (Status == EFI_SUCCESS);
//
// Memory test and Logo show
//
PlatformBdsDiagnostics (IGNORE, TRUE, BaseMemoryTest);
//
// Perform some platform specific connect sequence
//
PlatformBdsConnectSequence ();
//
// Process QEMU's -kernel command line option
//
TryRunningQemuKernel ();
//
// Give one chance to enter the setup if we
// have the time out
//
if (Timeout != 0) {
//PlatformBdsEnterFrontPage (Timeout, FALSE);
}
DEBUG ((EFI_D_INFO, "BdsLibConnectAll\n"));
BdsLibConnectAll ();
#ifdef VBOX
{
UINTN cFileSystem = 0;
EFI_HANDLE *phFileSystem = NULL;
BDS_COMMON_OPTION *BootOption0080 = NULL;
EFI_STATUS rc = EFI_SUCCESS;
DEBUG ((EFI_D_INFO, "------------------ VBox Platform Specific Initialization Start -----------------------\n"));
BootOption0080 = BdsLibVariableToOption(BootOptionList, L"Boot0080");
if (!BootOption0080)
{
rc = gBS->LocateHandleBuffer (ByProtocol,
&gEfiSimpleFileSystemProtocolGuid,
NULL,
&cFileSystem,
&phFileSystem);
VBoxLogFlowFuncMarkRC(rc);
VBoxLogFlowFuncMarkVar(cFileSystem, "%d");
if ( rc == EFI_SUCCESS
&& cFileSystem > 0)
{
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *pFSVolume;
EFI_FILE_HANDLE hFSRoot;
EFI_FILE_HANDLE hBootEfiFile;
UINTN iFileSystem = 0;
/* Ok, we've found several simple file system handles
* 1. we should find if '\\System\\Library\\CoreServices\\boot.efi' present
* 2. Alter 'BootOrder' to include this file in boot sequence.
*/
for (iFileSystem = 0; iFileSystem < cFileSystem; ++iFileSystem)
{
EFI_DEVICE_PATH_PROTOCOL *pDevicePath = NULL;
/* mount and look up the boot.efi */
rc = gBS->HandleProtocol (phFileSystem[iFileSystem],
&gEfiSimpleFileSystemProtocolGuid,
(VOID *) &pFSVolume);
VBoxLogFlowFuncMarkVar(iFileSystem, "%d");
VBoxLogFlowFuncMarkRC(rc);
if (EFI_ERROR(rc))
continue;
rc = pFSVolume->OpenVolume(pFSVolume, &hFSRoot);
VBoxLogFlowFuncMarkRC(rc);
if (EFI_ERROR(rc))
continue;
rc = hFSRoot->Open(hFSRoot, &hBootEfiFile, L"\\System\\Library\\CoreServices\\boot.efi", EFI_FILE_MODE_READ, 0);
VBoxLogFlowFuncMarkRC(rc);
if (EFI_ERROR(rc))
continue;
/* nice file is found and we have to register it */
pDevicePath = FileDevicePath(phFileSystem[iFileSystem], L"\\System\\Library\\CoreServices\\boot.efi");
VBoxLogFlowFuncMarkVar(pDevicePath,"%p");
if (!pDevicePath)
continue;
rc = BdsLibRegisterNewOption (BootOptionList, pDevicePath, L"Mac Boot", L"BootOrder");
VBoxLogFlowFuncMarkRC(rc);
}
}
}
else
{
VBoxLogFlowFuncMarkVar(BootOption0080->LoadOptionsSize, "%d");
if (BootOption0080->LoadOptionsSize)
VBoxLogFlowFuncMarkVar(BootOption0080->LoadOptions, "%s");
#if 0
/* Boot0080 option is found */
UINT16 *BootOrder;
UINTN BootOrderSize;
UINTN Index = 0;
CHAR16 *BootOptionName;
ASSERT(BootOption0080->Signature == BDS_LOAD_OPTION_SIGNATURE);
BootOrder = BdsLibGetVariableAndSize (
L"BootOrder",
&gEfiGlobalVariableGuid,
&BootOrderSize);
ASSERT(BootOrder);
BootOptionName = AllocateRuntimePool(256 * sizeof(UINT16));
UnicodeSPrint(BootOptionName, 256 * sizeof(UINT16), L"Boot%04x", BootOrder[Index]);
BootOption0080->OptionName = BootOptionName;
rc = gRT->SetVariable(BootOptionName,
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
sizeof(BDS_COMMON_OPTION),
BootOption0080);
LogFlowFuncMarkRC(rc);
#if 0
rc = BdsLibRegisterNewOption (BootOptionList, BootOption0080->DevicePath, L"Mac Boot Temp", L"BootOrder");
#endif
LogFlowFuncMarkRC(rc);
#endif
}
DEBUG ((EFI_D_INFO, "------------------ VBox Platform Specific Initialization End -----------------------\n"));
}
#endif
BdsLibEnumerateAllBootOption (BootOptionList);
SetBootOrderFromQemu (BootOptionList);
//
// The BootOrder variable may have changed, reload the in-memory list with
// it.
//
BdsLibBuildOptionFromVar (BootOptionList, L"BootOrder");
//
// To give the User a chance to enter Setup here, if user set TimeOut is 0.
// BDS should still give user a chance to enter Setup
//
// Connect first boot option, and then check user input before exit
//
for (Link = BootOptionList->ForwardLink; Link != BootOptionList;Link = Link->ForwardLink) {
BootOption = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
if (!IS_LOAD_OPTION_TYPE (BootOption->Attribute, LOAD_OPTION_ACTIVE)) {
//
// skip the header of the link list, becuase it has no boot option
//
continue;
} else {
//
// Make sure the boot option device path connected, but ignore the BBS device path
//
if (DevicePathType (BootOption->DevicePath) != BBS_DEVICE_PATH) {
BdsLibConnectDevicePath (BootOption->DevicePath);
}
break;
}
}
//
// Check whether the user input after the duration time has expired
//
OldTpl = EfiGetCurrentTpl();
gBS->RestoreTPL (TPL_APPLICATION);
gBS->WaitForEvent (1, &UserInputDurationTime, &Index);
gBS->CloseEvent (UserInputDurationTime);
Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
gBS->RaiseTPL (OldTpl);
if (!EFI_ERROR (Status)) {
//
// Enter Setup if user input
//
Timeout = 0xffff;
PlatformBdsEnterFrontPage (Timeout, FALSE);
}
VBoxLogFlowFuncLeave();
return ;
}
/**
Start this driver on ControllerHandle by opening a Block IO or a Block IO2
or both, and Disk IO protocol, reading Device Path, and creating a child
handle with a Disk IO and device path protocol.
@param[in] This Protocol instance pointer.
@param[in] ControllerHandle Handle of device to bind driver to
@param[in] RemainingDevicePath Optional parameter use to pick a specific child
device to start.
@retval EFI_SUCCESS This driver is added to ControllerHandle
@retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
@retval other This driver does not support this device
**/
EFI_STATUS
EFIAPI
PartitionDriverBindingStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
{
EFI_STATUS Status;
EFI_STATUS OpenStatus;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
EFI_DISK_IO_PROTOCOL *DiskIo;
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
PARTITION_DETECT_ROUTINE *Routine;
BOOLEAN MediaPresent;
EFI_TPL OldTpl;
int idxRoutine = 0;
VBoxLogFlowFuncEnter();
BlockIo2 = NULL;
OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
//
// Check RemainingDevicePath validation
//
if (RemainingDevicePath != NULL) {
//
// Check if RemainingDevicePath is the End of Device Path Node,
// if yes, return EFI_SUCCESS
//
if (IsDevicePathEnd (RemainingDevicePath)) {
Status = EFI_SUCCESS;
goto Exit;
}
}
//
// Try to open BlockIO and BlockIO2. If BlockIO would be opened, continue,
// otherwise, return error.
//
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiBlockIoProtocolGuid,
(VOID **) &BlockIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
VBoxLogFlowFuncMarkRC(Status);
goto Exit;
}
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiBlockIo2ProtocolGuid,
(VOID **) &BlockIo2,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
//
// Get the Device Path Protocol on ControllerHandle's handle.
//
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiDevicePathProtocolGuid,
(VOID **) &ParentDevicePath,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
VBoxLogFlowFuncMarkRC(Status);
goto Exit;
}
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiDiskIoProtocolGuid,
(VOID **) &DiskIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
gBS->CloseProtocol (
ControllerHandle,
&gEfiDevicePathProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
VBoxLogFlowFuncMarkRC(Status);
goto Exit;
}
OpenStatus = Status;
//
// Try to read blocks when there's media or it is removable physical partition.
//
Status = EFI_UNSUPPORTED;
MediaPresent = BlockIo->Media->MediaPresent;
if (BlockIo->Media->MediaPresent ||
(BlockIo->Media->RemovableMedia && !BlockIo->Media->LogicalPartition)) {
//
// Try for GPT, then El Torito, and then legacy MBR partition types. If the
// media supports a given partition type install child handles to represent
// the partitions described by the media.
//
Routine = &mPartitionDetectRoutineTable[0];
while (*Routine != NULL) {
Status = (*Routine) (
This,
ControllerHandle,
DiskIo,
BlockIo,
BlockIo2,
ParentDevicePath
);
VBoxLogFlowFuncMarkRC(Status);
if (!EFI_ERROR (Status) || Status == EFI_MEDIA_CHANGED || Status == EFI_NO_MEDIA) {
VBoxLogFlowFuncMarkVar(idxRoutine, "%d");
break;
}
Routine++;
idxRoutine++;
}
}
//
// In the case that the driver is already started (OpenStatus == EFI_ALREADY_STARTED),
// the DevicePathProtocol and the DiskIoProtocol are not actually opened by the
// driver. So don't try to close them. Otherwise, we will break the dependency
// between the controller and the driver set up before.
//
// In the case that when the media changes on a device it will Reinstall the
// BlockIo interaface. This will cause a call to our Stop(), and a subsequent
// reentrant call to our Start() successfully. We should leave the device open
// when this happen. The "media change" case includes either the status is
// EFI_MEDIA_CHANGED or it is a "media" to "no media" change.
//
if (EFI_ERROR (Status) &&
!EFI_ERROR (OpenStatus) &&
Status != EFI_MEDIA_CHANGED &&
!(MediaPresent && Status == EFI_NO_MEDIA)) {
gBS->CloseProtocol (
ControllerHandle,
&gEfiDiskIoProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
//
// Close Parent BlockIO2 if has.
//
gBS->CloseProtocol (
ControllerHandle,
&gEfiBlockIo2ProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
gBS->CloseProtocol (
ControllerHandle,
&gEfiDevicePathProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
}
Exit:
gBS->RestoreTPL (OldTpl);
VBoxLogFlowFuncLeaveRC(Status);
return Status;
}