/**
Update the parameters of a TFTP boot option
The function asks sequentially to update the IPv4 parameters as well as the boot file path,
providing the previously set value if any.
@param[in] OldDevicePath Current complete device path of the Tftp boot option.
This has to be a valid complete Tftp boot option path.
By complete, we mean that it is not only the Tftp
specific end part built by the
"BdsLoadOptionTftpCreateDevicePath()" function.
This path is handled as read only.
@param[in] FileName Description of the file the path is asked for
@param[out] NewDevicePath Pointer to the new complete device path.
@retval EFI_SUCCESS Update completed
@retval EFI_ABORTED Update aborted by the user
@retval EFI_OUT_OF_RESOURCES Fail to perform the update due to lack of resource
**/
EFI_STATUS
BdsLoadOptionTftpUpdateDevicePath (
IN EFI_DEVICE_PATH *OldDevicePath,
IN CHAR16 *FileName,
OUT EFI_DEVICE_PATH_PROTOCOL **NewDevicePath
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH *DevicePath;
EFI_DEVICE_PATH *DevicePathNode;
UINT8 *Ipv4NodePtr;
IPv4_DEVICE_PATH Ipv4Node;
BOOLEAN IsDHCP;
EFI_IP_ADDRESS OldIp;
EFI_IP_ADDRESS OldSubnetMask;
EFI_IP_ADDRESS OldGatewayIp;
EFI_IP_ADDRESS LocalIp;
EFI_IP_ADDRESS SubnetMask;
EFI_IP_ADDRESS GatewayIp;
EFI_IP_ADDRESS RemoteIp;
UINT8 *FileNodePtr;
CHAR16 BootFilePath[BOOT_DEVICE_FILEPATH_MAX];
UINTN PathSize;
UINTN BootFilePathSize;
FILEPATH_DEVICE_PATH *NewFilePathNode;
Ipv4NodePtr = NULL;
//
// Make a copy of the complete device path that is made of :
// the device path of the device that support the Simple Network protocol
// followed by an IPv4 node (type IPv4_DEVICE_PATH),
// followed by a file path node (type FILEPATH_DEVICE_PATH) and ended up
// by an end node. The IPv6 case is not handled yet.
//
DevicePath = DuplicateDevicePath (OldDevicePath);
if (DevicePath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto ErrorExit;
}
//
// Because of the check done by "BdsLoadOptionTftpIsSupported()" prior to the
// call to this function, we know that the device path ends with an IPv4 node
// followed by a file path node and finally an end node. To get the address of
// the last IPv4 node, we loop over the whole device path, noting down the
// address of each encountered IPv4 node.
//
for (DevicePathNode = DevicePath;
!IsDevicePathEnd (DevicePathNode);
DevicePathNode = NextDevicePathNode (DevicePathNode))
{
if (IS_DEVICE_PATH_NODE (DevicePathNode, MESSAGING_DEVICE_PATH, MSG_IPv4_DP)) {
Ipv4NodePtr = (UINT8*)DevicePathNode;
}
}
// Copy for alignment of the IPv4 node data
CopyMem (&Ipv4Node, Ipv4NodePtr, sizeof (IPv4_DEVICE_PATH));
Print (L"Get the IP address from DHCP: ");
Status = GetHIInputBoolean (&IsDHCP);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
if (!IsDHCP) {
Print (L"Local static IP address: ");
if (Ipv4Node.StaticIpAddress) {
CopyMem (&OldIp.v4, &Ipv4Node.LocalIpAddress, sizeof (EFI_IPv4_ADDRESS));
Status = EditHIInputIP (&OldIp, &LocalIp);
} else {
Status = GetHIInputIP (&LocalIp);
}
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
Print (L"Get the network mask: ");
if (Ipv4Node.StaticIpAddress) {
CopyMem (&OldSubnetMask.v4, &Ipv4Node.SubnetMask, sizeof (EFI_IPv4_ADDRESS));
Status = EditHIInputIP (&OldSubnetMask, &SubnetMask);
} else {
Status = GetHIInputIP (&SubnetMask);
}
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
Print (L"Get the gateway IP address: ");
if (Ipv4Node.StaticIpAddress) {
CopyMem (&OldGatewayIp.v4, &Ipv4Node.GatewayIpAddress, sizeof (EFI_IPv4_ADDRESS));
Status = EditHIInputIP (&OldGatewayIp, &GatewayIp);
} else {
Status = GetHIInputIP (&GatewayIp);
}
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
}
Print (L"TFTP server IP address: ");
// Copy remote IPv4 address into IPv4 or IPv6 union
CopyMem (&OldIp.v4, &Ipv4Node.RemoteIpAddress, sizeof (EFI_IPv4_ADDRESS));
Status = EditHIInputIP (&OldIp, &RemoteIp);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
// Get the path of the boot file and its size in number of bytes
FileNodePtr = Ipv4NodePtr + sizeof (IPv4_DEVICE_PATH);
BootFilePathSize = DevicePathNodeLength (FileNodePtr) - SIZE_OF_FILEPATH_DEVICE_PATH;
//
// Ask for update of the boot file path
//
do {
// Copy for 2-byte alignment of the Unicode string
CopyMem (
BootFilePath, FileNodePtr + SIZE_OF_FILEPATH_DEVICE_PATH,
MIN (BootFilePathSize, BOOT_DEVICE_FILEPATH_MAX)
);
BootFilePath[BOOT_DEVICE_FILEPATH_MAX - 1] = L'\0';
Print (L"File path of the %s: ", FileName);
Status = EditHIInputStr (BootFilePath, BOOT_DEVICE_FILEPATH_MAX);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
PathSize = StrSize (BootFilePath);
if (PathSize > 2) {
break;
}
// Empty string, give the user another try
Print (L"Empty string - Invalid path\n");
} while (PathSize <= 2) ;
//
// Update the IPv4 node. IPv6 case not handled yet.
//
if (IsDHCP) {
Ipv4Node.StaticIpAddress = FALSE;
ZeroMem (&Ipv4Node.LocalIpAddress, sizeof (EFI_IPv4_ADDRESS));
ZeroMem (&Ipv4Node.SubnetMask, sizeof (EFI_IPv4_ADDRESS));
ZeroMem (&Ipv4Node.GatewayIpAddress, sizeof (EFI_IPv4_ADDRESS));
} else {
Ipv4Node.StaticIpAddress = TRUE;
CopyMem (&Ipv4Node.LocalIpAddress, &LocalIp.v4, sizeof (EFI_IPv4_ADDRESS));
CopyMem (&Ipv4Node.SubnetMask, &SubnetMask.v4, sizeof (EFI_IPv4_ADDRESS));
CopyMem (&Ipv4Node.GatewayIpAddress, &GatewayIp.v4, sizeof (EFI_IPv4_ADDRESS));
}
CopyMem (&Ipv4Node.RemoteIpAddress, &RemoteIp.v4, sizeof (EFI_IPv4_ADDRESS));
CopyMem (Ipv4NodePtr, &Ipv4Node, sizeof (IPv4_DEVICE_PATH));
//
// Create the new file path node
//
NewFilePathNode = (FILEPATH_DEVICE_PATH*)AllocatePool (
SIZE_OF_FILEPATH_DEVICE_PATH +
PathSize
);
NewFilePathNode->Header.Type = MEDIA_DEVICE_PATH;
NewFilePathNode->Header.SubType = MEDIA_FILEPATH_DP;
SetDevicePathNodeLength (
NewFilePathNode,
SIZE_OF_FILEPATH_DEVICE_PATH + PathSize
);
CopyMem (NewFilePathNode->PathName, BootFilePath, PathSize);
//
// Generate the new Device Path by replacing the file path node at address
// "FileNodePtr" by the new one "NewFilePathNode" and return its address.
//
SetDevicePathEndNode (FileNodePtr);
*NewDevicePath = AppendDevicePathNode (
DevicePath,
(CONST EFI_DEVICE_PATH_PROTOCOL*)NewFilePathNode
);
ErrorExit:
if (DevicePath != NULL) {
FreePool (DevicePath) ;
}
return Status;
}
EFI_STATUS
BootDeviceGetType (
IN EFI_DEVICE_PATH* DevicePath,
OUT ARM_BDS_LOADER_TYPE *BootType,
OUT UINT32 *Attributes
)
{
EFI_STATUS Status;
BOOLEAN IsEfiApp;
BOOLEAN IsBootLoader;
BOOLEAN HasFDTSupport;
CHAR16* FileName;
EFI_DEVICE_PATH* PrevDevicePathNode;
EFI_DEVICE_PATH* DevicePathNode;
EFI_PHYSICAL_ADDRESS Image;
UINTN FileSize;
EFI_IMAGE_DOS_HEADER* DosHeader;
UINTN PeCoffHeaderOffset;
EFI_IMAGE_NT_HEADERS32* NtHeader;
//
// Check if the last node of the device path is a FilePath node
//
PrevDevicePathNode = NULL;
DevicePathNode = DevicePath;
while ((DevicePathNode != NULL) && !IsDevicePathEnd (DevicePathNode)) {
PrevDevicePathNode = DevicePathNode;
DevicePathNode = NextDevicePathNode (DevicePathNode);
}
if ((PrevDevicePathNode != NULL) &&
(PrevDevicePathNode->Type == MEDIA_DEVICE_PATH) &&
(PrevDevicePathNode->SubType == MEDIA_FILEPATH_DP))
{
FileName = ((FILEPATH_DEVICE_PATH*)PrevDevicePathNode)->PathName;
} else {
FileName = NULL;
}
if (FileName == NULL) {
Print(L"Is an EFI Application? ");
Status = GetHIInputBoolean (&IsEfiApp);
if (EFI_ERROR(Status)) {
return EFI_ABORTED;
}
} else if (HasFilePathEfiExtension(FileName)) {
IsEfiApp = TRUE;
} else {
// Check if the file exist
Status = BdsLoadImage (DevicePath, AllocateAnyPages, &Image, &FileSize);
if (!EFI_ERROR (Status)) {
DosHeader = (EFI_IMAGE_DOS_HEADER *)(UINTN) Image;
if (DosHeader->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
//
// DOS image header is present,
// so read the PE header after the DOS image header.
//
PeCoffHeaderOffset = DosHeader->e_lfanew;
} else {
PeCoffHeaderOffset = 0;
}
//
// Check PE/COFF image.
//
NtHeader = (EFI_IMAGE_NT_HEADERS32 *)(UINTN) (Image + PeCoffHeaderOffset);
if (NtHeader->Signature != EFI_IMAGE_NT_SIGNATURE) {
IsEfiApp = FALSE;
} else {
IsEfiApp = TRUE;
}
// Free memory
gBS->FreePages (Image, EFI_SIZE_TO_PAGES(FileSize));
} else {
// If we did not manage to open it then ask for the type
Print(L"Is an EFI Application? ");
Status = GetHIInputBoolean (&IsEfiApp);
if (EFI_ERROR(Status)) {
return EFI_ABORTED;
}
}
}
if (IsEfiApp) {
Print(L"Is your application an OS loader? ");
Status = GetHIInputBoolean (&IsBootLoader);
if (EFI_ERROR(Status)) {
return EFI_ABORTED;
}
if (!IsBootLoader) {
*Attributes |= LOAD_OPTION_CATEGORY_APP;
}
*BootType = BDS_LOADER_EFI_APPLICATION;
} else {
Print(L"Has FDT support? ");
Status = GetHIInputBoolean (&HasFDTSupport);
if (EFI_ERROR(Status)) {
return EFI_ABORTED;
}
if (HasFDTSupport) {
*BootType = BDS_LOADER_KERNEL_LINUX_FDT;
} else {
*BootType = BDS_LOADER_KERNEL_LINUX_ATAG;
}
}
return EFI_SUCCESS;
}
EFI_STATUS
BdsLoadOptionTftpCreateDevicePath (
IN CHAR16* FileName,
OUT EFI_DEVICE_PATH_PROTOCOL **DevicePathNodes
)
{
EFI_STATUS Status;
BOOLEAN IsDHCP;
EFI_IP_ADDRESS LocalIp;
EFI_IP_ADDRESS SubnetMask;
EFI_IP_ADDRESS GatewayIp;
EFI_IP_ADDRESS RemoteIp;
IPv4_DEVICE_PATH *IPv4DevicePathNode;
FILEPATH_DEVICE_PATH *FilePathDevicePath;
CHAR16 BootFilePath[BOOT_DEVICE_FILEPATH_MAX];
UINTN BootFilePathSize;
Print (L"Get the IP address from DHCP: ");
Status = GetHIInputBoolean (&IsDHCP);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
if (!IsDHCP) {
Print (L"Local static IP address: ");
Status = GetHIInputIP (&LocalIp);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
Print (L"Get the network mask: ");
Status = GetHIInputIP (&SubnetMask);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
Print (L"Get the gateway IP address: ");
Status = GetHIInputIP (&GatewayIp);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
}
Print (L"Get the TFTP server IP address: ");
Status = GetHIInputIP (&RemoteIp);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
Print (L"File path of the %s : ", FileName);
Status = GetHIInputStr (BootFilePath, BOOT_DEVICE_FILEPATH_MAX);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
BootFilePathSize = StrSize(BootFilePath);
if (BootFilePathSize == 2) {
return EFI_NOT_FOUND;
}
// Allocate the memory for the IPv4 + File Path Device Path Nodes
IPv4DevicePathNode = (IPv4_DEVICE_PATH*)AllocatePool(sizeof(IPv4_DEVICE_PATH) + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize + END_DEVICE_PATH_LENGTH);
if (NULL == IPv4DevicePathNode)
{
return EFI_INVALID_PARAMETER;
}
// Create the IPv4 Device Path
IPv4DevicePathNode->Header.Type = MESSAGING_DEVICE_PATH;
IPv4DevicePathNode->Header.SubType = MSG_IPv4_DP;
SetDevicePathNodeLength (&IPv4DevicePathNode->Header, sizeof(IPv4_DEVICE_PATH));
if (!IsDHCP) {
CopyMem (&IPv4DevicePathNode->LocalIpAddress, &LocalIp.v4, sizeof (EFI_IPv4_ADDRESS));
CopyMem (&IPv4DevicePathNode->SubnetMask, &SubnetMask.v4, sizeof (EFI_IPv4_ADDRESS));
CopyMem (&IPv4DevicePathNode->GatewayIpAddress, &GatewayIp.v4, sizeof (EFI_IPv4_ADDRESS));
}
CopyMem (&IPv4DevicePathNode->RemoteIpAddress, &RemoteIp.v4, sizeof (EFI_IPv4_ADDRESS));
IPv4DevicePathNode->LocalPort = 0;
IPv4DevicePathNode->RemotePort = 0;
IPv4DevicePathNode->Protocol = EFI_IP_PROTO_TCP;
IPv4DevicePathNode->StaticIpAddress = (IsDHCP != TRUE);
// Create the FilePath Device Path node
FilePathDevicePath = (FILEPATH_DEVICE_PATH*)(IPv4DevicePathNode + 1);
FilePathDevicePath->Header.Type = MEDIA_DEVICE_PATH;
FilePathDevicePath->Header.SubType = MEDIA_FILEPATH_DP;
SetDevicePathNodeLength (FilePathDevicePath, SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize);
CopyMem (FilePathDevicePath->PathName, BootFilePath, BootFilePathSize);
// Set the End Device Path Node
SetDevicePathEndNode ((VOID*)((UINTN)FilePathDevicePath + SIZE_OF_FILEPATH_DEVICE_PATH + BootFilePathSize));
*DevicePathNodes = (EFI_DEVICE_PATH_PROTOCOL*)IPv4DevicePathNode;
return Status;
}
EFI_STATUS
BootMenuUpdateBootOption (
IN LIST_ENTRY *BootOptionsList
)
{
EFI_STATUS Status;
BDS_LOAD_OPTION_ENTRY *BootOptionEntry;
BDS_LOAD_OPTION *BootOption;
BDS_LOAD_OPTION_SUPPORT* DeviceSupport;
ARM_BDS_LOADER_ARGUMENTS* BootArguments;
CHAR16 BootDescription[BOOT_DEVICE_DESCRIPTION_MAX];
CHAR8 CmdLine[BOOT_DEVICE_OPTION_MAX];
CHAR16 UnicodeCmdLine[BOOT_DEVICE_OPTION_MAX];
EFI_DEVICE_PATH *DevicePath;
EFI_DEVICE_PATH *TempInitrdPath;
ARM_BDS_LOADER_TYPE BootType;
ARM_BDS_LOADER_OPTIONAL_DATA* LoaderOptionalData;
ARM_BDS_LINUX_ARGUMENTS* LinuxArguments;
EFI_DEVICE_PATH *InitrdPathNodes;
EFI_DEVICE_PATH *InitrdPath;
UINTN InitrdSize;
UINTN CmdLineSize;
BOOLEAN InitrdSupport;
UINT8* OptionalData;
UINTN OptionalDataSize;
BOOLEAN IsPrintable;
BOOLEAN IsUnicode;
DisplayBootOptions (BootOptionsList);
Status = SelectBootOption (BootOptionsList, UPDATE_BOOT_ENTRY, &BootOptionEntry);
if (EFI_ERROR (Status)) {
return Status;
}
BootOption = BootOptionEntry->BdsLoadOption;
// Get the device support for this Boot Option
Status = BootDeviceGetDeviceSupport (BootOption->FilePathList, &DeviceSupport);
if (EFI_ERROR(Status)) {
Print(L"Not possible to retrieve the supported device for the update\n");
return EFI_UNSUPPORTED;
}
Status = DeviceSupport->UpdateDevicePathNode (BootOption->FilePathList, L"EFI Application or the kernel", &DevicePath);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
if (DeviceSupport->RequestBootType) {
Status = BootDeviceGetType (DevicePath, &BootType, &BootOption->Attributes);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
}
LoaderOptionalData = BootOption->OptionalData;
if (LoaderOptionalData != NULL) {
BootType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((UINT32 *)(&LoaderOptionalData->Header.LoaderType));
} else {
BootType = BDS_LOADER_EFI_APPLICATION;
}
if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {
LinuxArguments = &LoaderOptionalData->Arguments.LinuxArguments;
CmdLineSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->CmdLineSize);
InitrdSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->InitrdSize);
if (InitrdSize > 0) {
Print(L"Keep the initrd: ");
} else {
Print(L"Add an initrd: ");
}
Status = GetHIInputBoolean (&InitrdSupport);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
if (InitrdSupport) {
if (InitrdSize > 0) {
// Case we update the initrd device path
Status = DeviceSupport->UpdateDevicePathNode ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize), L"initrd", &InitrdPath);
if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) {// EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd
Status = EFI_ABORTED;
goto EXIT;
}
InitrdSize = GetDevicePathSize (InitrdPath);
} else {
// Case we create the initrd device path
Status = DeviceSupport->CreateDevicePathNode (L"initrd", &InitrdPathNodes);
if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd
Status = EFI_ABORTED;
goto EXIT;
}
if (InitrdPathNodes != NULL) {
// Duplicate Linux kernel Device Path
TempInitrdPath = DuplicateDevicePath (BootOption->FilePathList);
// Replace Linux kernel Node by EndNode
SetDevicePathEndNode (GetLastDevicePathNode (TempInitrdPath));
// Append the Device Path to the selected device path
InitrdPath = AppendDevicePath (TempInitrdPath, (CONST EFI_DEVICE_PATH_PROTOCOL *)InitrdPathNodes);
FreePool (TempInitrdPath);
// Free the InitrdPathNodes created by Support->CreateDevicePathNode()
FreePool (InitrdPathNodes);
if (InitrdPath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto EXIT;
}
InitrdSize = GetDevicePathSize (InitrdPath);
} else {
InitrdPath = NULL;
}
}
} else {
InitrdSize = 0;
}
Print(L"Arguments to pass to the binary: ");
if (CmdLineSize > 0) {
AsciiStrnCpy (CmdLine, (CONST CHAR8*)(LinuxArguments + 1), sizeof (CmdLine));
CmdLine[sizeof (CmdLine) - 1] = '\0';
} else {
CmdLine[0] = '\0';
}
Status = EditHIInputAscii (CmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
CmdLineSize = AsciiStrSize (CmdLine);
OptionalDataSize = sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize;
BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (OptionalDataSize);
BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;
BootArguments->LinuxArguments.InitrdSize = InitrdSize;
CopyMem (&BootArguments->LinuxArguments + 1, CmdLine, CmdLineSize);
CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);
OptionalData = (UINT8*)BootArguments;
} else {
Print (L"Arguments to pass to the EFI Application: ");
if (BootOption->OptionalDataSize > 0) {
IsPrintable = IsPrintableString (BootOption->OptionalData, &IsUnicode);
if (IsPrintable) {
//
// The size in bytes of the string, final zero included, should
// be equal to or at least lower than "BootOption->OptionalDataSize"
// and the "IsPrintableString()" has already tested that the length
// in number of characters is smaller than BOOT_DEVICE_OPTION_MAX,
// final '\0' included. We can thus copy the string for editing
// using "CopyMem()". Furthermore, note that in the case of an Unicode
// string "StrnCpy()" and "StrCpy()" can not be used to copy the
// string because the data pointed to by "BootOption->OptionalData"
// is not necessarily 2-byte aligned.
//
if (IsUnicode) {
CopyMem (
UnicodeCmdLine, BootOption->OptionalData,
MIN (sizeof (UnicodeCmdLine),
BootOption->OptionalDataSize)
);
} else {
CopyMem (
CmdLine, BootOption->OptionalData,
MIN (sizeof (CmdLine),
BootOption->OptionalDataSize)
);
}
}
} else {
UnicodeCmdLine[0] = L'\0';
IsPrintable = TRUE;
IsUnicode = TRUE;
}
// We do not request arguments for OptionalData that cannot be printed
if (IsPrintable) {
if (IsUnicode) {
Status = EditHIInputStr (UnicodeCmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR (Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
OptionalData = (UINT8*)UnicodeCmdLine;
OptionalDataSize = StrSize (UnicodeCmdLine);
} else {
Status = EditHIInputAscii (CmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR (Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
OptionalData = (UINT8*)CmdLine;
OptionalDataSize = AsciiStrSize (CmdLine);
}
} else {
// We keep the former OptionalData
OptionalData = BootOption->OptionalData;
OptionalDataSize = BootOption->OptionalDataSize;
}
}
Print(L"Description for this new Entry: ");
StrnCpy (BootDescription, BootOption->Description, BOOT_DEVICE_DESCRIPTION_MAX);
Status = EditHIInputStr (BootDescription, BOOT_DEVICE_DESCRIPTION_MAX);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
// Update the entry
Status = BootOptionUpdate (BootOption, BootOption->Attributes, BootDescription, DevicePath, BootType, OptionalData, OptionalDataSize);
FREE_DEVICE_PATH:
FreePool (DevicePath);
EXIT:
if (Status == EFI_ABORTED) {
Print(L"\n");
}
return Status;
}
EFI_STATUS
BootMenuAddBootOption (
IN LIST_ENTRY *BootOptionsList
)
{
EFI_STATUS Status;
BDS_SUPPORTED_DEVICE* SupportedBootDevice;
ARM_BDS_LOADER_ARGUMENTS* BootArguments;
CHAR16 BootDescription[BOOT_DEVICE_DESCRIPTION_MAX];
CHAR8 AsciiCmdLine[BOOT_DEVICE_OPTION_MAX];
CHAR16 CmdLine[BOOT_DEVICE_OPTION_MAX];
UINT32 Attributes;
ARM_BDS_LOADER_TYPE BootType;
BDS_LOAD_OPTION_ENTRY *BdsLoadOptionEntry;
EFI_DEVICE_PATH *DevicePath;
EFI_DEVICE_PATH_PROTOCOL *DevicePathNodes;
EFI_DEVICE_PATH_PROTOCOL *InitrdPathNodes;
EFI_DEVICE_PATH_PROTOCOL *InitrdPath;
UINTN CmdLineSize;
BOOLEAN InitrdSupport;
UINTN InitrdSize;
UINT8* OptionalData;
UINTN OptionalDataSize;
Attributes = 0;
SupportedBootDevice = NULL;
// List the Boot Devices supported
Status = SelectBootDevice (&SupportedBootDevice);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
// Create the specific device path node
Status = SupportedBootDevice->Support->CreateDevicePathNode (L"EFI Application or the kernel", &DevicePathNodes);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
// Append the Device Path to the selected device path
DevicePath = AppendDevicePath (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)DevicePathNodes);
if (DevicePath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto EXIT;
}
if (SupportedBootDevice->Support->RequestBootType) {
Status = BootDeviceGetType (DevicePath, &BootType, &Attributes);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
} else {
BootType = BDS_LOADER_EFI_APPLICATION;
}
if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {
Print(L"Add an initrd: ");
Status = GetHIInputBoolean (&InitrdSupport);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
if (InitrdSupport) {
// Create the specific device path node
Status = SupportedBootDevice->Support->CreateDevicePathNode (L"initrd", &InitrdPathNodes);
if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd
Status = EFI_ABORTED;
goto EXIT;
}
if (InitrdPathNodes != NULL) {
// Append the Device Path to the selected device path
InitrdPath = AppendDevicePath (SupportedBootDevice->DevicePathProtocol, (CONST EFI_DEVICE_PATH_PROTOCOL *)InitrdPathNodes);
// Free the InitrdPathNodes created by Support->CreateDevicePathNode()
FreePool (InitrdPathNodes);
if (InitrdPath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto EXIT;
}
} else {
InitrdPath = NULL;
}
} else {
InitrdPath = NULL;
}
Print(L"Arguments to pass to the binary: ");
Status = GetHIInputAscii (AsciiCmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
CmdLineSize = AsciiStrSize (AsciiCmdLine);
InitrdSize = GetDevicePathSize (InitrdPath);
OptionalDataSize = sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize;
BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (OptionalDataSize);
BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;
BootArguments->LinuxArguments.InitrdSize = InitrdSize;
CopyMem ((VOID*)(&BootArguments->LinuxArguments + 1), AsciiCmdLine, CmdLineSize);
CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);
OptionalData = (UINT8*)BootArguments;
} else {
Print (L"Arguments to pass to the EFI Application: ");
Status = GetHIInputStr (CmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR (Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
OptionalData = (UINT8*)CmdLine;
OptionalDataSize = StrSize (CmdLine);
}
Print(L"Description for this new Entry: ");
Status = GetHIInputStr (BootDescription, BOOT_DEVICE_DESCRIPTION_MAX);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
// Create new entry
BdsLoadOptionEntry = (BDS_LOAD_OPTION_ENTRY*)AllocatePool (sizeof(BDS_LOAD_OPTION_ENTRY));
Status = BootOptionCreate (Attributes, BootDescription, DevicePath, BootType, OptionalData, OptionalDataSize, &BdsLoadOptionEntry->BdsLoadOption);
if (!EFI_ERROR(Status)) {
InsertTailList (BootOptionsList, &BdsLoadOptionEntry->Link);
}
FREE_DEVICE_PATH:
FreePool (DevicePath);
EXIT:
if (Status == EFI_ABORTED) {
Print(L"\n");
}
FreePool(SupportedBootDevice);
return Status;
}
/***
Gather information from user.
@param[in|out] DeviceList - Linked list of USB devices.
@param[in] MaxDevices - Number of USB devices in linked list.
@retval EFI_SUCCESS Always success.
***/
EFI_STATUS
UsbGetInputPrompt (
IN OUT LIST_ENTRY *DeviceList,
IN UINTN MaxDevices
)
{
EFI_STATUS Status;
DATA_TEST DataTest;
DISK_ENTRY *DiskEntry = NULL;
DISK_INFO *DiskInfo = NULL;
UINTN IndexDisk, IndexPartition, BufferSize;
BOOLEAN YesAns = FALSE;
while (TRUE) {
do {
Print (L"Choose a USB disk: ");
Status = GetHIInputInteger (&IndexDisk);
if (Status == EFI_INVALID_PARAMETER) {
Print (L"Exiting...\n");
return EFI_SUCCESS;
}
if (IndexDisk <= 0 || IndexDisk > MaxDevices) {
Print (L"Invalid input, please enter again!\n");
IndexDisk = 0;
}else break;
}while (IndexDisk == 0);
DataTest.DiskIndex = IndexDisk;
DiskEntry = SearchDiskEntry (DeviceList, IndexDisk);
DiskInfo = &(DiskEntry->DiskInfo);
BufferSize = DiskInfo->BlockIo->Media->BlockSize;
DataTest.IsTestingPartition = FALSE;
DataTest.IsUsingSample = FALSE;
Print (L"Check entire disk? (Warning: The partitions of disk may be corrupted!!)\n");
Status = GetHIInputBoolean (&YesAns);
if (Status == EFI_INVALID_PARAMETER) {
continue;
}
if (!YesAns) {
DataTest.IsTestingPartition = TRUE;
do {
Print (L"Choose a partition of USB disk: ");
Status = GetHIInputInteger (&IndexPartition);
if (Status == EFI_INVALID_PARAMETER) {
break;
}
if (SearchPartitionEntry (&(DiskInfo->PartitionsList), IndexPartition) == NULL) {
Print (L"Invalid input, please enter again!\n");
IndexPartition = 0;
}else break;
}while (IndexPartition == 0);
if (IndexPartition == 0) {
continue;
}
DataTest.PartitionNumber = IndexPartition;
}
Print (L"Test with sample pattern?\n");
Status = GetHIInputBoolean (&YesAns);
if (Status == EFI_INVALID_PARAMETER) {
continue;
}
DataTest.IsUsingSample = YesAns;
Status = UsbTestInputPrompt (&DataTest, BufferSize);
if (DataTest.IsUsingSample) {
Status = TestBlocksAutomatically (DeviceList, &DataTest, BufferSize);
}else {
Status = TestBlocksManually (DeviceList, &DataTest, BufferSize);
}
}
return EFI_SUCCESS;
}
/**
* This function check if the DevicePath defines an EFI binary
*
* This function is used when the BDS support Linux loader to
* detect if the binary is an EFI application or potentially a
* Linux kernel.
*/
EFI_STATUS
IsEfiBinary (
IN EFI_DEVICE_PATH* DevicePath,
OUT BOOLEAN *EfiBinary
)
{
EFI_STATUS Status;
CHAR16* FileName;
EFI_DEVICE_PATH* PrevDevicePathNode;
EFI_DEVICE_PATH* DevicePathNode;
EFI_PHYSICAL_ADDRESS Image;
UINTN FileSize;
EFI_IMAGE_DOS_HEADER* DosHeader;
UINTN PeCoffHeaderOffset;
EFI_IMAGE_NT_HEADERS32* NtHeader;
ASSERT (EfiBinary != NULL);
//
// Check if the last node of the device path is a FilePath node
//
PrevDevicePathNode = NULL;
DevicePathNode = DevicePath;
while ((DevicePathNode != NULL) && !IsDevicePathEnd (DevicePathNode)) {
PrevDevicePathNode = DevicePathNode;
DevicePathNode = NextDevicePathNode (DevicePathNode);
}
if ((PrevDevicePathNode != NULL) &&
(PrevDevicePathNode->Type == MEDIA_DEVICE_PATH) &&
(PrevDevicePathNode->SubType == MEDIA_FILEPATH_DP))
{
FileName = ((FILEPATH_DEVICE_PATH*)PrevDevicePathNode)->PathName;
} else {
FileName = NULL;
}
if (FileName == NULL) {
Print (L"Is an EFI Application? ");
Status = GetHIInputBoolean (EfiBinary);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
} else if (HasFilePathEfiExtension (FileName)) {
*EfiBinary = TRUE;
} else {
// Check if the file exist
Status = BdsLoadImage (DevicePath, AllocateAnyPages, &Image, &FileSize);
if (!EFI_ERROR (Status)) {
DosHeader = (EFI_IMAGE_DOS_HEADER *)(UINTN) Image;
if (DosHeader->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
//
// DOS image header is present,
// so read the PE header after the DOS image header.
//
PeCoffHeaderOffset = DosHeader->e_lfanew;
} else {
PeCoffHeaderOffset = 0;
}
//
// Check PE/COFF image.
//
NtHeader = (EFI_IMAGE_NT_HEADERS32 *)(UINTN) (Image + PeCoffHeaderOffset);
if (NtHeader->Signature != EFI_IMAGE_NT_SIGNATURE) {
*EfiBinary = FALSE;
} else {
*EfiBinary = TRUE;
}
// Free memory
gBS->FreePages (Image, EFI_SIZE_TO_PAGES (FileSize));
} else {
// If we did not manage to open it then ask for the type
Print (L"Is an EFI Application? ");
Status = GetHIInputBoolean (EfiBinary);
if (EFI_ERROR (Status)) {
return EFI_ABORTED;
}
}
}
return EFI_SUCCESS;
}