mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-11-11 23:47:24 +00:00
156ccbc3c4
At present we use wide characters for unicode but this is not necessary. Change the code to use the 'u' literal instead. This helps to fix build warnings for sandbox on rpi. Signed-off-by: Simon Glass <sjg@chromium.org> Suggested-by: Heinrich Schuchardt <xypron.glpk@gmx.de> Reviewed-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
528 lines
12 KiB
C
528 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* efi_selftest_loadimage
|
|
*
|
|
* Copyright (c) 2019 Heinrich Schuchardt <xypron.glpk@gmx.de>
|
|
*
|
|
* This test checks the LoadImage and StartImage boot service.
|
|
*
|
|
* The efi_selftest_miniapp_exit.efi application is loaded via a file device
|
|
* path and started.
|
|
*/
|
|
|
|
#include <efi_selftest.h>
|
|
/* Include containing the efi_selftest_miniapp_exit.efi application */
|
|
#include "efi_miniapp_file_image_exit.h"
|
|
|
|
/* Block size of compressed disk image */
|
|
#define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8
|
|
|
|
/* Binary logarithm of the block size */
|
|
#define LB_BLOCK_SIZE 9
|
|
|
|
#define FILE_NAME u"app.efi"
|
|
#define VOLUME_NAME u"EfiDisk"
|
|
|
|
static struct efi_boot_services *boottime;
|
|
static efi_handle_t handle_image;
|
|
static efi_handle_t handle_volume;
|
|
|
|
static const efi_guid_t guid_device_path = EFI_DEVICE_PATH_PROTOCOL_GUID;
|
|
static const efi_guid_t guid_simple_file_system_protocol =
|
|
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
|
|
static const efi_guid_t guid_file_info = EFI_FILE_INFO_GUID;
|
|
static const efi_guid_t guid_file_system_info = EFI_FILE_SYSTEM_INFO_GUID;
|
|
|
|
/* One 8 byte block of the compressed disk image */
|
|
struct line {
|
|
size_t addr;
|
|
char *line;
|
|
};
|
|
|
|
/* Compressed file image */
|
|
struct compressed_file_image {
|
|
size_t length;
|
|
struct line lines[];
|
|
};
|
|
|
|
/* File info including file name */
|
|
struct file_info {
|
|
struct efi_file_info info;
|
|
u16 file_name[sizeof(FILE_NAME)];
|
|
};
|
|
|
|
/* File system info including volume name */
|
|
struct file_system_info {
|
|
struct efi_file_system_info info;
|
|
u16 file_name[sizeof(VOLUME_NAME)];
|
|
};
|
|
|
|
/* Compressed file image */
|
|
static struct compressed_file_image img = EFI_ST_DISK_IMG;
|
|
|
|
/* Pointer to decompressed file image */
|
|
static u8 *image;
|
|
|
|
/* File info */
|
|
static struct file_info priv_file_info = {
|
|
{
|
|
.size = sizeof(struct file_info),
|
|
.attribute = EFI_FILE_READ_ONLY,
|
|
},
|
|
FILE_NAME,
|
|
};
|
|
|
|
/* Pointer to file info */
|
|
struct efi_file_info *file_info = &priv_file_info.info;
|
|
|
|
/* Volume device path */
|
|
static struct {
|
|
struct efi_device_path_vendor vendor;
|
|
struct efi_device_path end;
|
|
} __packed dp_volume = {
|
|
.vendor = {
|
|
.dp = {
|
|
.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
|
|
.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
|
|
.length = sizeof(struct efi_device_path_vendor),
|
|
},
|
|
.guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
|
|
0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
|
|
},
|
|
.end = {
|
|
.type = DEVICE_PATH_TYPE_END,
|
|
.sub_type = DEVICE_PATH_SUB_TYPE_END,
|
|
.length = sizeof(struct efi_device_path),
|
|
}
|
|
};
|
|
|
|
/* File device path */
|
|
static struct {
|
|
struct efi_device_path_vendor vendor;
|
|
struct efi_device_path path;
|
|
u16 file[sizeof(FILE_NAME)];
|
|
struct efi_device_path end;
|
|
} __packed dp_file = {
|
|
.vendor = {
|
|
.dp = {
|
|
.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
|
|
.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
|
|
.length = sizeof(struct efi_device_path_vendor),
|
|
},
|
|
.guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
|
|
0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
|
|
},
|
|
.path = {
|
|
.type = DEVICE_PATH_TYPE_MEDIA_DEVICE,
|
|
.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH,
|
|
.length = sizeof(struct efi_device_path) + sizeof(dp_file.file),
|
|
},
|
|
.file = FILE_NAME,
|
|
.end = {
|
|
.type = DEVICE_PATH_TYPE_END,
|
|
.sub_type = DEVICE_PATH_SUB_TYPE_END,
|
|
.length = sizeof(struct efi_device_path),
|
|
}
|
|
};
|
|
|
|
/* File system info */
|
|
static struct file_system_info priv_file_system_info = {
|
|
{
|
|
.size = sizeof(struct file_system_info),
|
|
.read_only = true,
|
|
.volume_size = 0x100000,
|
|
.free_space = 0x0,
|
|
.block_size = 0x200,
|
|
},
|
|
VOLUME_NAME
|
|
};
|
|
|
|
/* Pointer to file system info */
|
|
static struct efi_file_system_info *file_system_info =
|
|
&priv_file_system_info.info;
|
|
|
|
/* Forward definitions of file and file system functions */
|
|
static efi_status_t EFIAPI open_volume
|
|
(struct efi_simple_file_system_protocol *this,
|
|
struct efi_file_handle **root);
|
|
|
|
static efi_status_t EFIAPI open
|
|
(struct efi_file_handle *this,
|
|
struct efi_file_handle **new_handle,
|
|
u16 *file_name, u64 open_mode, u64 attributes);
|
|
|
|
static efi_status_t EFIAPI close(struct efi_file_handle *this);
|
|
|
|
static efi_status_t EFIAPI delete(struct efi_file_handle *this);
|
|
|
|
static efi_status_t EFIAPI read
|
|
(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer);
|
|
|
|
static efi_status_t EFIAPI write
|
|
(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer);
|
|
|
|
static efi_status_t EFIAPI getpos(struct efi_file_handle *this, u64 *pos);
|
|
|
|
static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos);
|
|
|
|
static efi_status_t EFIAPI getinfo
|
|
(struct efi_file_handle *this, const efi_guid_t *info_type,
|
|
efi_uintn_t *buffer_size, void *buffer);
|
|
|
|
static efi_status_t EFIAPI setinfo
|
|
(struct efi_file_handle *this, const efi_guid_t *info_type,
|
|
efi_uintn_t buffer_size, void *buffer);
|
|
|
|
static efi_status_t EFIAPI flush(struct efi_file_handle *this);
|
|
|
|
/* Internal information about status of file system */
|
|
static struct {
|
|
/* Difference of volume open count minus volume close count */
|
|
int volume_open_count;
|
|
/* Difference of file open count minus file close count */
|
|
int file_open_count;
|
|
/* File size */
|
|
u64 file_size;
|
|
/* Current position in file */
|
|
u64 file_pos;
|
|
} priv;
|
|
|
|
/* EFI_FILE_PROTOCOL for file */
|
|
static struct efi_file_handle file = {
|
|
.rev = 0x00010000,
|
|
.open = open,
|
|
.close = close,
|
|
.delete = delete,
|
|
.read = read,
|
|
.write = write,
|
|
.getpos = getpos,
|
|
.setpos = setpos,
|
|
.getinfo = getinfo,
|
|
.setinfo = setinfo,
|
|
.flush = flush,
|
|
};
|
|
|
|
/* EFI_FILE_PROTOCOL for root directory */
|
|
static struct efi_file_handle volume = {
|
|
.rev = 0x00010000,
|
|
.open = open,
|
|
.close = close,
|
|
.delete = delete,
|
|
.read = read,
|
|
.write = write,
|
|
.getpos = getpos,
|
|
.setpos = setpos,
|
|
.getinfo = getinfo,
|
|
.setinfo = setinfo,
|
|
.flush = flush,
|
|
};
|
|
|
|
/* EFI_SIMPLE_FILE_SYSTEM_PROTOCOL of the block device */
|
|
struct efi_simple_file_system_protocol file_system = {
|
|
.rev = 0x00010000,
|
|
.open_volume = open_volume,
|
|
};
|
|
|
|
static efi_status_t EFIAPI open_volume
|
|
(struct efi_simple_file_system_protocol *this,
|
|
struct efi_file_handle **root)
|
|
{
|
|
if (this != &file_system || !root)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
*root = &volume;
|
|
priv.volume_open_count++;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
static efi_status_t EFIAPI open
|
|
(struct efi_file_handle *this,
|
|
struct efi_file_handle **new_handle,
|
|
u16 *file_name, u64 open_mode, u64 attributes)
|
|
{
|
|
if (this != &volume)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
*new_handle = &file;
|
|
priv.file_pos = 0;
|
|
priv.file_open_count++;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
static efi_status_t EFIAPI close(struct efi_file_handle *this)
|
|
{
|
|
if (this == &file)
|
|
priv.file_open_count--;
|
|
else if (this == &volume)
|
|
priv.volume_open_count--;
|
|
else
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
static efi_status_t EFIAPI delete(struct efi_file_handle *this)
|
|
{
|
|
if (this != &file)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
static efi_status_t EFIAPI read
|
|
(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer)
|
|
{
|
|
if (this != &file)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
if (priv.file_pos >= img.length)
|
|
*buffer_size = 0;
|
|
else if (priv.file_pos + *buffer_size > img.length)
|
|
*buffer_size = img.length - priv.file_pos;
|
|
|
|
boottime->copy_mem(buffer, &image[priv.file_pos], *buffer_size);
|
|
priv.file_pos += *buffer_size;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
static efi_status_t EFIAPI write
|
|
(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer)
|
|
{
|
|
if (this != &file)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
static efi_status_t EFIAPI getpos(struct efi_file_handle *this, u64 *pos)
|
|
{
|
|
if (this != &file)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
*pos = priv.file_pos;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos)
|
|
{
|
|
if (this != &file)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
priv.file_pos = pos;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
static efi_status_t EFIAPI getinfo
|
|
(struct efi_file_handle *this, const efi_guid_t *info_type,
|
|
efi_uintn_t *buffer_size, void *buffer)
|
|
{
|
|
if (this == &file) {
|
|
if (memcmp(info_type, &guid_file_info, sizeof(efi_guid_t)))
|
|
return EFI_INVALID_PARAMETER;
|
|
if (*buffer_size >= sizeof(struct file_info)) {
|
|
boottime->copy_mem(buffer, file_info,
|
|
sizeof(struct file_info));
|
|
} else {
|
|
*buffer_size = sizeof(struct file_info);
|
|
return EFI_BUFFER_TOO_SMALL;
|
|
}
|
|
} else if (this == &volume) {
|
|
if (memcmp(info_type, &guid_file_system_info,
|
|
sizeof(efi_guid_t)))
|
|
return EFI_INVALID_PARAMETER;
|
|
if (*buffer_size >= sizeof(struct file_system_info)) {
|
|
boottime->copy_mem(buffer, file_system_info,
|
|
sizeof(struct file_system_info));
|
|
} else {
|
|
*buffer_size = sizeof(struct file_system_info);
|
|
return EFI_BUFFER_TOO_SMALL;
|
|
}
|
|
} else {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
static efi_status_t EFIAPI setinfo
|
|
(struct efi_file_handle *this, const efi_guid_t *info_type,
|
|
efi_uintn_t buffer_size, void *buffer)
|
|
{
|
|
if (this != &file)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
static efi_status_t EFIAPI flush(struct efi_file_handle *this)
|
|
{
|
|
if (this != &file)
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
/*
|
|
* Decompress the disk image.
|
|
*
|
|
* @image decompressed disk image
|
|
* Return: status code
|
|
*/
|
|
static efi_status_t decompress(u8 **image)
|
|
{
|
|
u8 *buf;
|
|
size_t i;
|
|
size_t addr;
|
|
size_t len;
|
|
efi_status_t ret;
|
|
|
|
ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
|
|
(void **)&buf);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("Out of memory\n");
|
|
return ret;
|
|
}
|
|
boottime->set_mem(buf, img.length, 0);
|
|
|
|
for (i = 0; ; ++i) {
|
|
if (!img.lines[i].line)
|
|
break;
|
|
addr = img.lines[i].addr;
|
|
len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
|
|
if (addr + len > img.length)
|
|
len = img.length - addr;
|
|
boottime->copy_mem(buf + addr, img.lines[i].line, len);
|
|
}
|
|
*image = buf;
|
|
priv.file_size = img.length;
|
|
file_info->file_size = img.length;
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Setup unit test.
|
|
*
|
|
* Decompress application image and provide a handle for the in memory block
|
|
* device.
|
|
*
|
|
* @handle: handle of the loaded image
|
|
* @systable: system table
|
|
* Return: EFI_ST_SUCCESS for success
|
|
*/
|
|
static int setup(const efi_handle_t handle,
|
|
const struct efi_system_table *systable)
|
|
{
|
|
efi_status_t ret;
|
|
|
|
handle_image = handle;
|
|
boottime = systable->boottime;
|
|
|
|
/* Load the application image into memory */
|
|
decompress(&image);
|
|
|
|
ret = boottime->install_protocol_interface
|
|
(&handle_volume, &guid_device_path, EFI_NATIVE_INTERFACE,
|
|
&dp_volume);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("Failed to install device path\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
ret = boottime->install_protocol_interface
|
|
(&handle_volume, &guid_simple_file_system_protocol,
|
|
EFI_NATIVE_INTERFACE, &file_system);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("Failed to install simple file system protocol\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
return EFI_ST_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Tear down unit test.
|
|
*
|
|
* Uninstall protocols and free memory.
|
|
*
|
|
* Return: EFI_ST_SUCCESS for success
|
|
*/
|
|
static int teardown(void)
|
|
{
|
|
efi_status_t ret = EFI_ST_SUCCESS;
|
|
|
|
if (handle_volume) {
|
|
ret = boottime->uninstall_protocol_interface
|
|
(handle_volume, &guid_simple_file_system_protocol,
|
|
&file_system);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error
|
|
("Failed to uninstall simple file system protocol\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
ret = boottime->uninstall_protocol_interface
|
|
(handle_volume, &guid_device_path, &dp_volume);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error
|
|
("Failed to uninstall device path protocol\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
}
|
|
|
|
if (image) {
|
|
ret = boottime->free_pool(image);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("Failed to free image\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Execute unit test.
|
|
*
|
|
* Load and start the application image.
|
|
*
|
|
* Return: EFI_ST_SUCCESS for success
|
|
*/
|
|
static int execute(void)
|
|
{
|
|
efi_status_t ret;
|
|
efi_handle_t handle;
|
|
|
|
ret = boottime->load_image(false, handle_image, &dp_file.vendor.dp,
|
|
NULL, 0, &handle);
|
|
if (ret != EFI_SUCCESS) {
|
|
efi_st_error("Failed to load image\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
ret = boottime->start_image(handle, NULL, NULL);
|
|
if (ret != EFI_UNSUPPORTED) {
|
|
efi_st_error("Wrong return value from application\n");
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
if (priv.file_open_count) {
|
|
efi_st_error("File open count = %d, expected 0\n",
|
|
priv.file_open_count);
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
if (priv.volume_open_count) {
|
|
efi_st_error("Volume open count = %d, expected 0\n",
|
|
priv.volume_open_count);
|
|
return EFI_ST_FAILURE;
|
|
}
|
|
|
|
return EFI_ST_SUCCESS;
|
|
}
|
|
|
|
EFI_UNIT_TEST(loadimage) = {
|
|
.name = "load image from file",
|
|
.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
|
|
.setup = setup,
|
|
.execute = execute,
|
|
.teardown = teardown,
|
|
};
|