You've already forked slimbootloader
mirror of
https://github.com/Dasharo/slimbootloader.git
synced 2026-03-06 15:26:20 -08:00
a63818df94
When OsLoader shell "fs load" tried to free memory, the assertion happened with the message "CR has Bad Signature". It's caused when FreePool() tried to free the memory allocated by AllocatePages(), and the memory signature is not as expected. So modify the free memory function to FreePages() Signed-off-by: Vincent Chen <vincent.chen@intel.com>
452 lines
11 KiB
C
452 lines
11 KiB
C
/** @file
|
|
Shell command `fs` to view partition information
|
|
|
|
Copyright (c) 2019 - 2022, Intel Corporation. All rights reserved.<BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
#include <Library/BootloaderCommonLib.h>
|
|
#include <Library/ShellLib.h>
|
|
#include <Library/PartitionLib.h>
|
|
#include <Library/FileSystemLib.h>
|
|
#include <Library/MediaAccessLib.h>
|
|
#include <Library/ConsoleInLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Guid/OsBootOptionGuid.h>
|
|
#include <Library/BootOptionLib.h>
|
|
#include <Guid/DeviceTableHobGuid.h>
|
|
|
|
STATIC OS_BOOT_MEDIUM_TYPE mDeviceType = OsBootDeviceMax;
|
|
STATIC UINT8 mDeviceInstance = 0;
|
|
STATIC EFI_HANDLE mHwPartHandle = NULL;
|
|
STATIC EFI_HANDLE mFsHandle = NULL;
|
|
|
|
/**
|
|
Show media information
|
|
|
|
@param[in] Shell shell instance
|
|
@param[in] Argc number of command line arguments
|
|
@param[in] Argv command line arguments
|
|
|
|
@retval EFI_SUCCESS
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
ShellCommandFsFunc (
|
|
IN SHELL *Shell,
|
|
IN UINTN Argc,
|
|
IN CHAR16 *Argv[]
|
|
);
|
|
|
|
CONST SHELL_COMMAND ShellCommandFs = {
|
|
L"fs",
|
|
L"filesystem access command",
|
|
&ShellCommandFsFunc
|
|
};
|
|
|
|
/**
|
|
Print available platform devices
|
|
|
|
@retval none
|
|
|
|
**/
|
|
STATIC
|
|
VOID
|
|
PrintPlatformDevices (
|
|
IN VOID
|
|
)
|
|
{
|
|
PLT_DEVICE_TABLE *DeviceTable;
|
|
UINT16 Count;
|
|
UINT16 Index;
|
|
OS_BOOT_MEDIUM_TYPE DeviceType;
|
|
UINT8 DeviceInstance;
|
|
|
|
Count = 0;
|
|
DeviceTable = (PLT_DEVICE_TABLE *)GetDeviceTable ();
|
|
if (DeviceTable != NULL) {
|
|
Count = DeviceTable->DeviceNumber;
|
|
for (Index = 0; Index < Count; Index++) {
|
|
DeviceType = (OS_BOOT_MEDIUM_TYPE)DeviceTable->Device[Index].Type;
|
|
if (DeviceType >= OsBootDeviceMax)
|
|
continue;
|
|
|
|
DeviceInstance = DeviceTable->Device[Index].Instance;
|
|
ShellPrint (L" %d:%d %a", DeviceType, DeviceInstance, GetBootDeviceNameString (DeviceType));
|
|
if (DeviceTable->Device[Index].Dev.PciDev.IsMmioDevice != 0) {
|
|
ShellPrint (L"(MEM 0x%x)\n", DeviceTable->Device[Index].Dev.DevAddr);
|
|
} else {
|
|
ShellPrint (L"(PCI 0x%x:0x%x:0x%x)\n",
|
|
DeviceTable->Device[Index].Dev.PciDev.PciBusNumber,
|
|
DeviceTable->Device[Index].Dev.PciDev.PciDeviceNumber,
|
|
DeviceTable->Device[Index].Dev.PciDev.PciFunctionNumber);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
Close file system
|
|
|
|
@retval EFI_SUCCESS
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
CmdFsClose (
|
|
IN VOID
|
|
)
|
|
{
|
|
if (mFsHandle != NULL) {
|
|
CloseFileSystem (mFsHandle);
|
|
mFsHandle = NULL;
|
|
}
|
|
if (mHwPartHandle != NULL) {
|
|
ClosePartitions (mHwPartHandle);
|
|
mHwPartHandle = NULL;
|
|
}
|
|
|
|
if (mDeviceType != OsBootDeviceMax) {
|
|
// De-init the current media device
|
|
// If USB keyboard console is used, don't DeInit USB yet.
|
|
if (!((mDeviceType == OsBootDeviceUsb) &&
|
|
((PcdGet32 (PcdConsoleInDeviceMask) & ConsoleInUsbKeyboard) != 0))) {
|
|
MediaInitialize (0, DevDeinit);
|
|
}
|
|
mDeviceType = OsBootDeviceMax;
|
|
mDeviceInstance = 0;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Initialize file system
|
|
|
|
@param[in] DeviceType Platform Device Index
|
|
@param[in] DeviceInstance The device instance number starting from 0.
|
|
@param[in] HwPartNo HW Partition Number
|
|
@param[in] SwPartNo SW Partition Number
|
|
|
|
@retval EFI_SUCCESS FS init success
|
|
@retval Others Error
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
CmdFsInit (
|
|
IN OS_BOOT_MEDIUM_TYPE DeviceType,
|
|
IN UINT8 DeviceInstance,
|
|
IN UINT32 HwPartNo,
|
|
IN UINT32 SwPartNo
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
UINTN BaseAddress;
|
|
|
|
// Get device bar
|
|
BaseAddress = GetDeviceAddr (DeviceType, DeviceInstance);
|
|
if (BaseAddress == 0) {
|
|
ShellPrint (L"Device no. %d (%a) is not in platform devices. <device no.> - ",
|
|
DeviceType, GetBootDeviceNameString (DeviceType));
|
|
PrintPlatformDevices ();
|
|
return EFI_ABORTED;
|
|
} else if (!(BaseAddress & 0xFF000000)) {
|
|
BaseAddress = TO_MM_PCI_ADDRESS (BaseAddress);
|
|
}
|
|
|
|
if (mDeviceType != OsBootDeviceMax) {
|
|
CmdFsClose ();
|
|
}
|
|
|
|
// Set media interface
|
|
Status = MediaSetInterfaceType (DeviceType);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
Status = MediaInitialize (BaseAddress, DevInitAll);
|
|
ShellPrint (L"Media(%a) Init ", GetBootDeviceNameString (DeviceType));
|
|
mDeviceType = DeviceType;
|
|
mDeviceInstance = DeviceInstance;
|
|
if (!EFI_ERROR (Status)) {
|
|
ShellPrint (L"Success!\n");
|
|
} else {
|
|
ShellPrint (L"Fail!\n");
|
|
goto Error;
|
|
}
|
|
|
|
// Find a partition
|
|
ShellPrint (L"Find a Partition\n");
|
|
Status = FindPartitions (HwPartNo, &mHwPartHandle);
|
|
ShellPrint (L"Partition Detect (device:%d, hwpart:%d) ", mDeviceType, HwPartNo);
|
|
if (!EFI_ERROR (Status)) {
|
|
ShellPrint (L"Success!\n");
|
|
} else {
|
|
ShellPrint (L"Fail!\n");
|
|
goto Error;
|
|
}
|
|
|
|
ShellPrint (L"Init FileSystem\n");
|
|
Status = InitFileSystem (SwPartNo, EnumFileSystemTypeAuto, mHwPartHandle, &mFsHandle);
|
|
ShellPrint (L"FileSystem Detect (device:%d, hwpart:%d, swpart:%d) ",
|
|
mDeviceType, HwPartNo, SwPartNo);
|
|
if (!EFI_ERROR (Status)) {
|
|
FsType = GetFileSystemType (mFsHandle);
|
|
ShellPrint (L"Success! (%a)\n", GetFsTypeString (FsType));
|
|
} else {
|
|
ShellPrint (L"Fail!\n");
|
|
goto Error;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
Error:
|
|
CmdFsClose ();
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Print directory or file list
|
|
|
|
@retval EFI_SUCCESS
|
|
@retval EFI_ABORTED
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
CmdFsFsListDir (
|
|
IN CHAR16 *DirFilePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
if (mFsHandle == NULL) {
|
|
ShellPrint (L"FileSystem is not initialized!\n");
|
|
return EFI_ABORTED;
|
|
}
|
|
|
|
Status = ListDir (mFsHandle, DirFilePath);
|
|
if (Status == EFI_NOT_FOUND) {
|
|
ShellPrint (L"Not found!\n");
|
|
} else if (Status == EFI_UNSUPPORTED) {
|
|
ShellPrint (L"This command has been disabled.\n");
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Load a file into memory.
|
|
|
|
@param[in] File path to load.
|
|
@param[in] LoadAddr Memory address to load.
|
|
|
|
@retval EFI_SUCCESS File was loaded successfully.
|
|
@retval EFI_ABORTED File system is not initialized.
|
|
@retval EFI_OUT_OF_RESOURCES Insufficant memory.
|
|
@retval EFI_BAD_BUFFER_SIZE File size is 0.
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
CmdFsLoad (
|
|
IN CHAR16 *FilePath,
|
|
IN UINTN LoadAddr
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN ImageSize;
|
|
VOID *Image;
|
|
EFI_HANDLE FsHandle;
|
|
EFI_HANDLE FileHandle;
|
|
|
|
FsHandle = mFsHandle;
|
|
if (FsHandle == NULL) {
|
|
ShellPrint (L"FileSystem is not initialized!\n");
|
|
return EFI_ABORTED;
|
|
}
|
|
|
|
FileHandle = NULL;
|
|
Status = OpenFile (FsHandle, FilePath, &FileHandle);
|
|
if (EFI_ERROR (Status)) {
|
|
goto FileLoadErrOut;
|
|
}
|
|
|
|
Status = GetFileSize (FileHandle, &ImageSize);
|
|
if (EFI_ERROR (Status)) {
|
|
goto FileLoadErrOut;
|
|
}
|
|
|
|
if (ImageSize == 0) {
|
|
Status = EFI_BAD_BUFFER_SIZE;
|
|
goto FileLoadErrOut;
|
|
}
|
|
|
|
if (LoadAddr == 0) {
|
|
// Allocate space for loading
|
|
Image = AllocatePages (EFI_SIZE_TO_PAGES (ImageSize));
|
|
if (Image == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto FileLoadErrOut;
|
|
}
|
|
} else {
|
|
Image = (VOID *)LoadAddr;
|
|
}
|
|
|
|
Status = ReadFile (FileHandle, Image, &ImageSize);
|
|
if (EFI_ERROR (Status)) {
|
|
if ((Image != NULL) && (LoadAddr == 0)) {
|
|
FreePages (Image, EFI_SIZE_TO_PAGES (ImageSize));
|
|
}
|
|
goto FileLoadErrOut;
|
|
}
|
|
|
|
FileLoadErrOut:
|
|
if (EFI_ERROR (Status)) {
|
|
ShellPrint (L"Failed to load file: %r\n", Status);
|
|
} else {
|
|
ShellPrint (L"File was loaded at 0x%p with length 0x%X!\n", Image, ImageSize);
|
|
}
|
|
|
|
if (FileHandle != NULL) {
|
|
CloseFile (FileHandle);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Display current filesystem info
|
|
|
|
@retval EFI_SUCCESS
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
CmdFsInfo (
|
|
IN VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT32 HwPartNo;
|
|
UINT32 SwPartNo;
|
|
OS_FILE_SYSTEM_TYPE FsType;
|
|
|
|
ShellPrint (L"Current DeviceType: %a\n", (mDeviceType != OsBootDeviceMax) ?
|
|
GetBootDeviceNameString (mDeviceType) : "Not Initialized");
|
|
|
|
ShellPrint (L"Current DeviceInstance: %d\n", mDeviceInstance);
|
|
|
|
ShellPrint (L"Current HwPart: ");
|
|
Status = GetPartitionCurrentPartNo (mHwPartHandle, &HwPartNo);
|
|
if (!EFI_ERROR (Status)) {
|
|
ShellPrint (L"%d\n", HwPartNo);
|
|
} else {
|
|
ShellPrint (L"Not Initialized\n");
|
|
}
|
|
|
|
ShellPrint (L"Current SwPart: ");
|
|
Status = GetFileSystemCurrentPartNo (mFsHandle, &SwPartNo);
|
|
if (!EFI_ERROR (Status)) {
|
|
ShellPrint (L"%d\n", SwPartNo);
|
|
} else {
|
|
ShellPrint (L"Not Initialized\n");
|
|
}
|
|
|
|
FsType = GetFileSystemType (mFsHandle);
|
|
ShellPrint (L"Current FileSystem: %a\n", (FsType != EnumFileSystemMax) ?
|
|
GetFsTypeString (FsType) : "Not Detected");
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Basic file system test commands
|
|
|
|
@param[in] Shell shell instance
|
|
@param[in] Argc number of command line arguments
|
|
@param[in] Argv command line arguments
|
|
|
|
@retval EFI_SUCCESS
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
ShellCommandFsFunc (
|
|
IN SHELL *Shell,
|
|
IN UINTN Argc,
|
|
IN CHAR16 *Argv[]
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
OS_BOOT_MEDIUM_TYPE DeviceType;
|
|
UINT8 DeviceInstance;
|
|
UINT32 HwPartNo;
|
|
UINT32 SwPartNo;
|
|
CHAR16 *SubCmd;
|
|
CHAR16 *String;
|
|
UINTN Result;
|
|
UINTN LoadAddr;
|
|
|
|
if (Argc < 2) {
|
|
goto Usage;
|
|
}
|
|
|
|
SubCmd = Argv[1];
|
|
if (StrCmp (SubCmd, L"init") == 0) {
|
|
if (Argc < 3) {
|
|
DeviceType = 0;
|
|
DeviceInstance = 0;
|
|
} else {
|
|
Status = StrHexToUintnS (Argv[2], &String, &Result);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Usage;
|
|
}
|
|
DeviceType = (OS_BOOT_MEDIUM_TYPE)Result;
|
|
|
|
Result = 0;
|
|
if (String[0] == L':') {
|
|
String++;
|
|
Status = StrHexToUintnS (String, NULL, &Result);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Usage;
|
|
}
|
|
}
|
|
DeviceInstance = (UINT8)Result;
|
|
}
|
|
|
|
HwPartNo = (Argc < 4) ? 0 : (UINT32)StrHexToUintn (Argv[3]);
|
|
SwPartNo = (Argc < 5) ? 0 : (UINT32)StrHexToUintn (Argv[4]);
|
|
Status = CmdFsInit (DeviceType, DeviceInstance, HwPartNo, SwPartNo);
|
|
} else if (StrCmp (SubCmd, L"close") == 0) {
|
|
Status = CmdFsClose ();
|
|
} else if (StrCmp (SubCmd, L"ls") == 0) {
|
|
Status = CmdFsFsListDir ((Argc < 3) ? L"/" : Argv[2]);
|
|
} else if (StrCmp (SubCmd, L"info") == 0) {
|
|
Status = CmdFsInfo ();
|
|
} else if (StrCmp (SubCmd, L"load") == 0) {
|
|
LoadAddr = (Argc < 4) ? 0 : StrHexToUintn (Argv[3]);
|
|
Status = CmdFsLoad ((Argc < 3) ? L"/" : Argv[2], LoadAddr);
|
|
} else {
|
|
goto Usage;
|
|
}
|
|
return Status;
|
|
|
|
Usage:
|
|
ShellPrint (L"Usage: %s init [DevType[:DevInstance]] [HwPart] [SwPart]\n", Argv[0]);
|
|
ShellPrint (L" %s close\n", Argv[0]);
|
|
ShellPrint (L" %s info\n", Argv[0]);
|
|
ShellPrint (L" %s ls [dir or file path]\n", Argv[0]);
|
|
ShellPrint (L" %s load [dir or file path] [Address]\n", Argv[0]);
|
|
|
|
ShellPrint (L"\nDevType:DevInstance - Media type and instance number in the same media type\n");
|
|
PrintPlatformDevices ();
|
|
ShellPrint (L"HwPart - HW partition or port number\n");
|
|
ShellPrint (L"SwPart - Logical partition number from MBR or GPT\n");
|
|
|
|
return EFI_ABORTED;
|
|
}
|