This time around we have a lot of EFI patches from Heinrich. Highlights are: - Allow EFI applications to register as drivers - Allow exposure of U-Boot block devices from an EFI payload - Compatibility improvements -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQIcBAABAgAGBQJaZwoHAAoJECszeR4D/txgKU0QAMRg5zm95ClGRBjxVbAW7M73 T7pHQBbsoaddfK0zOAltLo5wOLhLNJPb93L0gxjChx6o5PDV6iFISAYRnJiQsVyj XI5Ve2XV8DRBMdaKVxeq1Z7syjYllhdkzBeQbitw6TfIDy+qeA/x/Z1Jz6gYnTDh ZmbP0HrTk59Vg80ZLa4XcBumqesfBnUAEDFx9sYX9T8/7bx3QWQfwAJ3XHYKkDmM aaXFq/02/z0ZgDPinkG00AIkKme+QRAFCd+leACkDGPR9pAC4mf6df/006a0Sl/s qw5j5J06yOZ0ykTxwmREsGg62IqCTPA51mSiBvWS37vZeUUO0WhyysuUvQ5YVv+U UII5YN/0PGVGVZ4hM1s3yEijEf48n1YncASRyYVfCtJjC/WJ2IUlthH85MEBrrn4 IqVHeoLJg5/a3T2Tdo83q/AD9saFshaVsT42C04JB07/29SKjNjZ9sUMMBatOlAP HleCy3jgodwB4kF1Tld6oeakvuc0xOhCOckD3rWUhsi9eN9liZiv7AlXFiXxPUgz tWcJtluaZ/vhXXJWdCqwf2KIq0fmawgBUsSwLByPrZKTp9OojGsA52Ro6jAuu2Mq vKqZhRpSF7DtAhALcex5V2uwCc5npehTTXIHYG/bmzBQWrEWfBlYA7dSjMiuQbuD 0+1EicqsGp8Chr1H37bC =XZ4q -----END PGP SIGNATURE----- Merge tag 'signed-efi-next' of git://github.com/agraf/u-boot Patch queue for efi - 2018-01-23 This time around we have a lot of EFI patches from Heinrich. Highlights are: - Allow EFI applications to register as drivers - Allow exposure of U-Boot block devices from an EFI payload - Compatibility improvementsmaster
Tom Rini
7 years ago
commit
a516416d75
@ -0,0 +1,30 @@ |
||||
/*
|
||||
* EFI application loader |
||||
* |
||||
* Copyright (c) 2017 Heinrich Schuchardt |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#ifndef _EFI_DRIVER_H |
||||
#define _EFI_DRIVER_H 1 |
||||
|
||||
#include <common.h> |
||||
#include <dm.h> |
||||
#include <efi_loader.h> |
||||
|
||||
struct efi_driver_ops { |
||||
const efi_guid_t *protocol; |
||||
const efi_guid_t *child_protocol; |
||||
int (*bind)(efi_handle_t handle, void *interface); |
||||
}; |
||||
|
||||
/*
|
||||
* This structure adds internal fields to the driver binding protocol. |
||||
*/ |
||||
struct efi_driver_binding_extended_protocol { |
||||
struct efi_driver_binding_protocol bp; |
||||
const struct efi_driver_ops *ops; |
||||
}; |
||||
|
||||
#endif /* _EFI_DRIVER_H */ |
||||
@ -0,0 +1,13 @@ |
||||
#
|
||||
# (C) Copyright 2017 Heinrich Schuchardt
|
||||
#
|
||||
# SPDX-License-Identifier: GPL-2.0+
|
||||
#
|
||||
|
||||
# This file only gets included with CONFIG_EFI_LOADER set, so all
|
||||
# object inclusion implicitly depends on it
|
||||
|
||||
obj-y += efi_uclass.o
|
||||
ifeq ($(CONFIG_BLK)$(CONFIG_PARTITIONS),yy) |
||||
obj-y += efi_block_device.o
|
||||
endif |
||||
@ -0,0 +1,210 @@ |
||||
/*
|
||||
* EFI block driver |
||||
* |
||||
* Copyright (c) 2017 Heinrich Schuchardt |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* The EFI uclass creates a handle for this driver and installs the |
||||
* driver binding protocol on it. |
||||
* |
||||
* The EFI block driver binds to controllers implementing the block io |
||||
* protocol. |
||||
* |
||||
* When the bind function of the EFI block driver is called it creates a |
||||
* new U-Boot block device. It installs child handles for all partitions and |
||||
* installs the simple file protocol on these. |
||||
* |
||||
* The read and write functions of the EFI block driver delegate calls to the |
||||
* controller that it is bound to. |
||||
* |
||||
* A usage example is as following: |
||||
* |
||||
* U-Boot loads the iPXE snp.efi executable. iPXE connects an iSCSI drive and |
||||
* exposes a handle with the block IO protocol. It calls ConnectController. |
||||
* |
||||
* Now the EFI block driver installs the partitions with the simple file |
||||
* protocol. |
||||
* |
||||
* iPXE uses the simple file protocol to load Grub or the Linux Kernel. |
||||
*/ |
||||
|
||||
#include <efi_driver.h> |
||||
#include <dm/device-internal.h> |
||||
#include <dm/root.h> |
||||
|
||||
/*
|
||||
* EFI attributes of the udevice handled by this driver. |
||||
* |
||||
* handle handle of the controller on which this driver is installed |
||||
* io block io protocol proxied by this driver |
||||
*/ |
||||
struct efi_blk_priv { |
||||
efi_handle_t handle; |
||||
struct efi_block_io *io; |
||||
}; |
||||
|
||||
/*
|
||||
* Read from block device |
||||
* |
||||
* @dev device |
||||
* @blknr first block to be read |
||||
* @blkcnt number of blocks to read |
||||
* @buffer output buffer |
||||
* @return number of blocks transferred |
||||
*/ |
||||
static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, |
||||
void *buffer) |
||||
{ |
||||
struct efi_blk_priv *priv = dev->priv; |
||||
struct efi_block_io *io = priv->io; |
||||
efi_status_t ret; |
||||
|
||||
EFI_PRINT("%s: read '%s', from block " LBAFU ", " LBAFU " blocks\n", |
||||
__func__, dev->name, blknr, blkcnt); |
||||
ret = EFI_CALL(io->read_blocks( |
||||
io, io->media->media_id, (u64)blknr, |
||||
(efi_uintn_t)blkcnt * |
||||
(efi_uintn_t)io->media->block_size, buffer)); |
||||
EFI_PRINT("%s: r = %u\n", __func__, |
||||
(unsigned int)(ret & ~EFI_ERROR_MASK)); |
||||
if (ret != EFI_SUCCESS) |
||||
return 0; |
||||
return blkcnt; |
||||
} |
||||
|
||||
/*
|
||||
* Write to block device |
||||
* |
||||
* @dev device |
||||
* @blknr first block to be write |
||||
* @blkcnt number of blocks to write |
||||
* @buffer input buffer |
||||
* @return number of blocks transferred |
||||
*/ |
||||
static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, |
||||
const void *buffer) |
||||
{ |
||||
struct efi_blk_priv *priv = dev->priv; |
||||
struct efi_block_io *io = priv->io; |
||||
efi_status_t ret; |
||||
|
||||
EFI_PRINT("%s: write '%s', from block " LBAFU ", " LBAFU " blocks\n", |
||||
__func__, dev->name, blknr, blkcnt); |
||||
ret = EFI_CALL(io->write_blocks( |
||||
io, io->media->media_id, (u64)blknr, |
||||
(efi_uintn_t)blkcnt * |
||||
(efi_uintn_t)io->media->block_size, |
||||
(void *)buffer)); |
||||
EFI_PRINT("%s: r = %u\n", __func__, |
||||
(unsigned int)(ret & ~EFI_ERROR_MASK)); |
||||
if (ret != EFI_SUCCESS) |
||||
return 0; |
||||
return blkcnt; |
||||
} |
||||
|
||||
/*
|
||||
* Create partions for the block device. |
||||
* |
||||
* @handle EFI handle of the block device |
||||
* @dev udevice of the block device |
||||
*/ |
||||
static int efi_bl_bind_partitions(efi_handle_t handle, struct udevice *dev) |
||||
{ |
||||
struct blk_desc *desc; |
||||
const char *if_typename; |
||||
|
||||
desc = dev_get_uclass_platdata(dev); |
||||
if_typename = blk_get_if_type_name(desc->if_type); |
||||
|
||||
return efi_disk_create_partitions(handle, desc, if_typename, |
||||
desc->devnum, dev->name); |
||||
} |
||||
|
||||
/*
|
||||
* Create a block device for a handle |
||||
* |
||||
* @handle handle |
||||
* @interface block io protocol |
||||
* @return 0 = success |
||||
*/ |
||||
static int efi_bl_bind(efi_handle_t handle, void *interface) |
||||
{ |
||||
struct udevice *bdev, *parent = dm_root(); |
||||
int ret, devnum; |
||||
char *name; |
||||
struct efi_object *obj = efi_search_obj(handle); |
||||
struct efi_block_io *io = interface; |
||||
int disks; |
||||
struct efi_blk_priv *priv; |
||||
|
||||
EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io); |
||||
|
||||
if (!obj) |
||||
return -ENOENT; |
||||
|
||||
devnum = blk_find_max_devnum(IF_TYPE_EFI); |
||||
if (devnum == -ENODEV) |
||||
devnum = 0; |
||||
else if (devnum < 0) |
||||
return devnum; |
||||
|
||||
name = calloc(1, 18); /* strlen("efiblk#2147483648") + 1 */ |
||||
if (!name) |
||||
return -ENOMEM; |
||||
sprintf(name, "efiblk#%d", devnum); |
||||
|
||||
/* Create driver model udevice for the EFI block io device */ |
||||
ret = blk_create_device(parent, "efi_blk", name, IF_TYPE_EFI, devnum, |
||||
io->media->block_size, |
||||
(lbaint_t)io->media->last_block, &bdev); |
||||
if (ret) |
||||
return ret; |
||||
if (!bdev) |
||||
return -ENOENT; |
||||
/* Allocate priv */ |
||||
ret = device_probe(bdev); |
||||
if (ret) |
||||
return ret; |
||||
EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name); |
||||
|
||||
priv = bdev->priv; |
||||
priv->handle = handle; |
||||
priv->io = interface; |
||||
|
||||
ret = blk_prepare_device(bdev); |
||||
|
||||
/* Create handles for the partions of the block device */ |
||||
disks = efi_bl_bind_partitions(handle, bdev); |
||||
EFI_PRINT("Found %d partitions\n", disks); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
/* Block device driver operators */ |
||||
static const struct blk_ops efi_blk_ops = { |
||||
.read = efi_bl_read, |
||||
.write = efi_bl_write, |
||||
}; |
||||
|
||||
/* Identify as block device driver */ |
||||
U_BOOT_DRIVER(efi_blk) = { |
||||
.name = "efi_blk", |
||||
.id = UCLASS_BLK, |
||||
.ops = &efi_blk_ops, |
||||
.priv_auto_alloc_size = sizeof(struct efi_blk_priv), |
||||
}; |
||||
|
||||
/* EFI driver operators */ |
||||
static const struct efi_driver_ops driver_ops = { |
||||
.protocol = &efi_block_io_guid, |
||||
.child_protocol = &efi_block_io_guid, |
||||
.bind = efi_bl_bind, |
||||
}; |
||||
|
||||
/* Identify as EFI driver */ |
||||
U_BOOT_DRIVER(efi_block) = { |
||||
.name = "EFI block driver", |
||||
.id = UCLASS_EFI, |
||||
.ops = &driver_ops, |
||||
}; |
||||
@ -0,0 +1,330 @@ |
||||
/*
|
||||
* Uclass for EFI drivers |
||||
* |
||||
* Copyright (c) 2017 Heinrich Schuchardt |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* For each EFI driver the uclass |
||||
* - creates a handle |
||||
* - installs the driver binding protocol |
||||
* |
||||
* The uclass provides the bind, start, and stop entry points for the driver |
||||
* binding protocol. |
||||
* |
||||
* In bind() and stop() it checks if the controller implements the protocol |
||||
* supported by the EFI driver. In the start() function it calls the bind() |
||||
* function of the EFI driver. In the stop() function it destroys the child |
||||
* controllers. |
||||
*/ |
||||
|
||||
#include <efi_driver.h> |
||||
|
||||
/*
|
||||
* Check node type. We do not support partitions as controller handles. |
||||
* |
||||
* @handle handle to be checked |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t check_node_type(efi_handle_t handle) |
||||
{ |
||||
efi_status_t r, ret = EFI_SUCCESS; |
||||
const struct efi_device_path *dp; |
||||
|
||||
/* Open the device path protocol */ |
||||
r = EFI_CALL(systab.boottime->open_protocol( |
||||
handle, &efi_guid_device_path, (void **)&dp, |
||||
NULL, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL)); |
||||
if (r == EFI_SUCCESS && dp) { |
||||
/* Get the last node */ |
||||
const struct efi_device_path *node = efi_dp_last_node(dp); |
||||
/* We do not support partitions as controller */ |
||||
if (!node || node->type == DEVICE_PATH_TYPE_MEDIA_DEVICE) |
||||
ret = EFI_UNSUPPORTED; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Check if the driver supports the controller. |
||||
* |
||||
* @this driver binding protocol |
||||
* @controller_handle handle of the controller |
||||
* @remaining_device_path path specifying the child controller |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI efi_uc_supported( |
||||
struct efi_driver_binding_protocol *this, |
||||
efi_handle_t controller_handle, |
||||
struct efi_device_path *remaining_device_path) |
||||
{ |
||||
efi_status_t r, ret; |
||||
void *interface; |
||||
struct efi_driver_binding_extended_protocol *bp = |
||||
(struct efi_driver_binding_extended_protocol *)this; |
||||
|
||||
EFI_ENTRY("%p, %p, %ls", this, controller_handle, |
||||
efi_dp_str(remaining_device_path)); |
||||
|
||||
ret = EFI_CALL(systab.boottime->open_protocol( |
||||
controller_handle, bp->ops->protocol, |
||||
&interface, this->driver_binding_handle, |
||||
controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER)); |
||||
switch (ret) { |
||||
case EFI_ACCESS_DENIED: |
||||
case EFI_ALREADY_STARTED: |
||||
goto out; |
||||
case EFI_SUCCESS: |
||||
break; |
||||
default: |
||||
ret = EFI_UNSUPPORTED; |
||||
goto out; |
||||
} |
||||
|
||||
ret = check_node_type(controller_handle); |
||||
|
||||
r = EFI_CALL(systab.boottime->close_protocol( |
||||
controller_handle, bp->ops->protocol, |
||||
this->driver_binding_handle, |
||||
controller_handle)); |
||||
if (r != EFI_SUCCESS) |
||||
ret = EFI_UNSUPPORTED; |
||||
out: |
||||
return EFI_EXIT(ret); |
||||
} |
||||
|
||||
/*
|
||||
* Create child controllers and attach driver. |
||||
* |
||||
* @this driver binding protocol |
||||
* @controller_handle handle of the controller |
||||
* @remaining_device_path path specifying the child controller |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI efi_uc_start( |
||||
struct efi_driver_binding_protocol *this, |
||||
efi_handle_t controller_handle, |
||||
struct efi_device_path *remaining_device_path) |
||||
{ |
||||
efi_status_t r, ret; |
||||
void *interface = NULL; |
||||
struct efi_driver_binding_extended_protocol *bp = |
||||
(struct efi_driver_binding_extended_protocol *)this; |
||||
|
||||
EFI_ENTRY("%p, %pUl, %ls", this, controller_handle, |
||||
efi_dp_str(remaining_device_path)); |
||||
|
||||
/* Attach driver to controller */ |
||||
ret = EFI_CALL(systab.boottime->open_protocol( |
||||
controller_handle, bp->ops->protocol, |
||||
&interface, this->driver_binding_handle, |
||||
controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER)); |
||||
switch (ret) { |
||||
case EFI_ACCESS_DENIED: |
||||
case EFI_ALREADY_STARTED: |
||||
goto out; |
||||
case EFI_SUCCESS: |
||||
break; |
||||
default: |
||||
ret = EFI_UNSUPPORTED; |
||||
goto out; |
||||
} |
||||
ret = check_node_type(controller_handle); |
||||
if (ret != EFI_SUCCESS) { |
||||
r = EFI_CALL(systab.boottime->close_protocol( |
||||
controller_handle, bp->ops->protocol, |
||||
this->driver_binding_handle, |
||||
controller_handle)); |
||||
if (r != EFI_SUCCESS) |
||||
EFI_PRINT("Failure to close handle\n"); |
||||
goto out; |
||||
} |
||||
|
||||
/* TODO: driver specific stuff */ |
||||
bp->ops->bind(controller_handle, interface); |
||||
|
||||
out: |
||||
return EFI_EXIT(ret); |
||||
} |
||||
|
||||
/*
|
||||
* Remove a single child controller from the parent controller. |
||||
* |
||||
* @controller_handle parent controller |
||||
* @child_handle child controller |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t disconnect_child(efi_handle_t controller_handle, |
||||
efi_handle_t child_handle) |
||||
{ |
||||
efi_status_t ret; |
||||
efi_guid_t *guid_controller = NULL; |
||||
efi_guid_t *guid_child_controller = NULL; |
||||
|
||||
ret = EFI_CALL(systab.boottime->close_protocol( |
||||
controller_handle, guid_controller, |
||||
child_handle, child_handle)); |
||||
if (ret != EFI_SUCCESS) { |
||||
EFI_PRINT("Cannot close protocol\n"); |
||||
return ret; |
||||
} |
||||
ret = EFI_CALL(systab.boottime->uninstall_protocol_interface( |
||||
child_handle, guid_child_controller, NULL)); |
||||
if (ret != EFI_SUCCESS) { |
||||
EFI_PRINT("Cannot uninstall protocol interface\n"); |
||||
return ret; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Remove child controllers and disconnect the controller. |
||||
* |
||||
* @this driver binding protocol |
||||
* @controller_handle handle of the controller |
||||
* @number_of_children number of child controllers to remove |
||||
* @child_handle_buffer handles of the child controllers to remove |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI efi_uc_stop( |
||||
struct efi_driver_binding_protocol *this, |
||||
efi_handle_t controller_handle, |
||||
size_t number_of_children, |
||||
efi_handle_t *child_handle_buffer) |
||||
{ |
||||
efi_status_t ret; |
||||
efi_uintn_t count; |
||||
struct efi_open_protocol_info_entry *entry_buffer; |
||||
efi_guid_t *guid_controller = NULL; |
||||
|
||||
EFI_ENTRY("%p, %pUl, %zu, %p", this, controller_handle, |
||||
number_of_children, child_handle_buffer); |
||||
|
||||
/* Destroy provided child controllers */ |
||||
if (number_of_children) { |
||||
efi_uintn_t i; |
||||
|
||||
for (i = 0; i < number_of_children; ++i) { |
||||
ret = disconnect_child(controller_handle, |
||||
child_handle_buffer[i]); |
||||
if (ret != EFI_SUCCESS) |
||||
return ret; |
||||
} |
||||
return EFI_SUCCESS; |
||||
} |
||||
|
||||
/* Destroy all children */ |
||||
ret = EFI_CALL(systab.boottime->open_protocol_information( |
||||
controller_handle, guid_controller, |
||||
&entry_buffer, &count)); |
||||
if (ret != EFI_SUCCESS) |
||||
goto out; |
||||
while (count) { |
||||
if (entry_buffer[--count].attributes & |
||||
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) { |
||||
ret = disconnect_child( |
||||
controller_handle, |
||||
entry_buffer[count].agent_handle); |
||||
if (ret != EFI_SUCCESS) |
||||
goto out; |
||||
} |
||||
} |
||||
ret = EFI_CALL(systab.boottime->free_pool(entry_buffer)); |
||||
if (ret != EFI_SUCCESS) |
||||
printf("%s(%u) %s: ERROR: Cannot free pool\n", |
||||
__FILE__, __LINE__, __func__); |
||||
|
||||
/* Detach driver from controller */ |
||||
ret = EFI_CALL(systab.boottime->close_protocol( |
||||
controller_handle, guid_controller, |
||||
this->driver_binding_handle, controller_handle)); |
||||
out: |
||||
return EFI_EXIT(ret); |
||||
} |
||||
|
||||
static efi_status_t efi_add_driver(struct driver *drv) |
||||
{ |
||||
efi_status_t ret; |
||||
const struct efi_driver_ops *ops = drv->ops; |
||||
struct efi_driver_binding_extended_protocol *bp; |
||||
|
||||
debug("EFI: Adding driver '%s'\n", drv->name); |
||||
if (!ops->protocol) { |
||||
printf("EFI: ERROR: protocol GUID missing for driver '%s'\n", |
||||
drv->name); |
||||
return EFI_INVALID_PARAMETER; |
||||
} |
||||
bp = calloc(1, sizeof(struct efi_driver_binding_extended_protocol)); |
||||
if (!bp) |
||||
return EFI_OUT_OF_RESOURCES; |
||||
|
||||
bp->bp.supported = efi_uc_supported; |
||||
bp->bp.start = efi_uc_start; |
||||
bp->bp.stop = efi_uc_stop; |
||||
bp->bp.version = 0xffffffff; |
||||
bp->ops = drv->ops; |
||||
|
||||
ret = efi_create_handle(&bp->bp.driver_binding_handle); |
||||
if (ret != EFI_SUCCESS) { |
||||
free(bp); |
||||
goto out; |
||||
} |
||||
bp->bp.image_handle = bp->bp.driver_binding_handle; |
||||
ret = efi_add_protocol(bp->bp.driver_binding_handle, |
||||
&efi_guid_driver_binding_protocol, bp); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_delete_handle(bp->bp.driver_binding_handle); |
||||
free(bp); |
||||
goto out; |
||||
} |
||||
out: |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Initialize the EFI drivers. |
||||
* Called by board_init_r(). |
||||
* |
||||
* @return 0 = success, any other value will stop further execution |
||||
*/ |
||||
int efi_driver_init(void) |
||||
{ |
||||
struct driver *drv; |
||||
int ret = 0; |
||||
|
||||
/* Save 'gd' pointer */ |
||||
efi_save_gd(); |
||||
|
||||
debug("EFI: Initializing EFI driver framework\n"); |
||||
for (drv = ll_entry_start(struct driver, driver); |
||||
drv < ll_entry_end(struct driver, driver); ++drv) { |
||||
if (drv->id == UCLASS_EFI) { |
||||
ret = efi_add_driver(drv); |
||||
if (ret) { |
||||
printf("EFI: ERROR: failed to add driver %s\n", |
||||
drv->name); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
static int efi_uc_init(struct uclass *class) |
||||
{ |
||||
printf("EFI: Initializing UCLASS_EFI\n"); |
||||
return 0; |
||||
} |
||||
|
||||
static int efi_uc_destroy(struct uclass *class) |
||||
{ |
||||
printf("Destroying UCLASS_EFI\n"); |
||||
return 0; |
||||
} |
||||
|
||||
UCLASS_DRIVER(efi) = { |
||||
.name = "efi", |
||||
.id = UCLASS_EFI, |
||||
.init = efi_uc_init, |
||||
.destroy = efi_uc_destroy, |
||||
}; |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,2 @@ |
||||
efi_miniapp_file_image.h |
||||
*.efi |
||||
@ -0,0 +1,395 @@ |
||||
/*
|
||||
* efi_selftest_block |
||||
* |
||||
* Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* This test checks the driver for block IO devices. |
||||
* A disk image is created in memory. |
||||
* A handle is created for the new block IO device. |
||||
* The block I/O protocol is installed on the handle. |
||||
* ConnectController is used to setup partitions and to install the simple |
||||
* file protocol. |
||||
* A known file is read from the file system and verified. |
||||
*/ |
||||
|
||||
#include <efi_selftest.h> |
||||
#include "efi_selftest_disk_image.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 |
||||
|
||||
static struct efi_boot_services *boottime; |
||||
|
||||
static const efi_guid_t block_io_protocol_guid = BLOCK_IO_GUID; |
||||
static const efi_guid_t guid_device_path = DEVICE_PATH_GUID; |
||||
static const efi_guid_t guid_simple_file_system_protocol = |
||||
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID; |
||||
static efi_guid_t guid_vendor = |
||||
EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d, |
||||
0x08, 0x72, 0x81, 0x9c, 0x65, 0x0c, 0xb7, 0xb8); |
||||
|
||||
static struct efi_device_path *dp; |
||||
|
||||
/* One 8 byte block of the compressed disk image */ |
||||
struct line { |
||||
size_t addr; |
||||
char *line; |
||||
}; |
||||
|
||||
/* Compressed disk image */ |
||||
struct compressed_disk_image { |
||||
size_t length; |
||||
struct line lines[]; |
||||
}; |
||||
|
||||
static const struct compressed_disk_image img = EFI_ST_DISK_IMG; |
||||
|
||||
/* Decompressed disk image */ |
||||
static u8 *image; |
||||
|
||||
/*
|
||||
* Reset service of the block IO protocol. |
||||
* |
||||
* @this block IO protocol |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI reset( |
||||
struct efi_block_io *this, |
||||
char extended_verification) |
||||
{ |
||||
return EFI_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* Read service of the block IO protocol. |
||||
* |
||||
* @this block IO protocol |
||||
* @media_id media id |
||||
* @lba start of the read in logical blocks |
||||
* @buffer_size number of bytes to read |
||||
* @buffer target buffer |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI read_blocks( |
||||
struct efi_block_io *this, u32 media_id, u64 lba, |
||||
efi_uintn_t buffer_size, void *buffer) |
||||
{ |
||||
u8 *start; |
||||
|
||||
if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length) |
||||
return EFI_INVALID_PARAMETER; |
||||
start = image + (lba << LB_BLOCK_SIZE); |
||||
|
||||
boottime->copy_mem(buffer, start, buffer_size); |
||||
|
||||
return EFI_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* Write service of the block IO protocol. |
||||
* |
||||
* @this block IO protocol |
||||
* @media_id media id |
||||
* @lba start of the write in logical blocks |
||||
* @buffer_size number of bytes to read |
||||
* @buffer source buffer |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI write_blocks( |
||||
struct efi_block_io *this, u32 media_id, u64 lba, |
||||
efi_uintn_t buffer_size, void *buffer) |
||||
{ |
||||
u8 *start; |
||||
|
||||
if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length) |
||||
return EFI_INVALID_PARAMETER; |
||||
start = image + (lba << LB_BLOCK_SIZE); |
||||
|
||||
boottime->copy_mem(start, buffer, buffer_size); |
||||
|
||||
return EFI_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* Flush service of the block IO protocol. |
||||
* |
||||
* @this block IO protocol |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI flush_blocks(struct efi_block_io *this) |
||||
{ |
||||
return EFI_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* 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; |
||||
return ret; |
||||
} |
||||
|
||||
static struct efi_block_io_media media; |
||||
|
||||
static struct efi_block_io block_io = { |
||||
.media = &media, |
||||
.reset = reset, |
||||
.read_blocks = read_blocks, |
||||
.write_blocks = write_blocks, |
||||
.flush_blocks = flush_blocks, |
||||
}; |
||||
|
||||
/* Handle for the block IO device */ |
||||
static efi_handle_t disk_handle; |
||||
|
||||
/*
|
||||
* Setup unit test. |
||||
* |
||||
* @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; |
||||
struct efi_device_path_vendor vendor_node; |
||||
struct efi_device_path end_node; |
||||
|
||||
boottime = systable->boottime; |
||||
|
||||
decompress(&image); |
||||
|
||||
block_io.media->block_size = 1 << LB_BLOCK_SIZE; |
||||
block_io.media->last_block = img.length >> LB_BLOCK_SIZE; |
||||
|
||||
ret = boottime->install_protocol_interface( |
||||
&disk_handle, &block_io_protocol_guid, |
||||
EFI_NATIVE_INTERFACE, &block_io); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to install block I/O protocol\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
|
||||
ret = boottime->allocate_pool(EFI_LOADER_DATA, |
||||
sizeof(struct efi_device_path_vendor) + |
||||
sizeof(struct efi_device_path), |
||||
(void **)&dp); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Out of memory\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
vendor_node.dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE; |
||||
vendor_node.dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR; |
||||
vendor_node.dp.length = sizeof(struct efi_device_path_vendor); |
||||
|
||||
boottime->copy_mem(&vendor_node.guid, &guid_vendor, |
||||
sizeof(efi_guid_t)); |
||||
boottime->copy_mem(dp, &vendor_node, |
||||
sizeof(struct efi_device_path_vendor)); |
||||
end_node.type = DEVICE_PATH_TYPE_END; |
||||
end_node.sub_type = DEVICE_PATH_SUB_TYPE_END; |
||||
end_node.length = sizeof(struct efi_device_path); |
||||
|
||||
boottime->copy_mem((char *)dp + sizeof(struct efi_device_path_vendor), |
||||
&end_node, sizeof(struct efi_device_path)); |
||||
ret = boottime->install_protocol_interface(&disk_handle, |
||||
&guid_device_path, |
||||
EFI_NATIVE_INTERFACE, |
||||
dp); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("InstallProtocolInterface failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* Tear down unit test. |
||||
* |
||||
* @return: EFI_ST_SUCCESS for success |
||||
*/ |
||||
static int teardown(void) |
||||
{ |
||||
efi_status_t r = EFI_ST_SUCCESS; |
||||
|
||||
if (disk_handle) { |
||||
r = boottime->uninstall_protocol_interface(disk_handle, |
||||
&guid_device_path, |
||||
dp); |
||||
if (r != EFI_SUCCESS) { |
||||
efi_st_error("Uninstall device path failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
r = boottime->uninstall_protocol_interface( |
||||
disk_handle, &block_io_protocol_guid, |
||||
&block_io); |
||||
if (r != EFI_SUCCESS) { |
||||
efi_st_todo( |
||||
"Failed to uninstall block I/O protocol\n"); |
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
} |
||||
|
||||
if (image) { |
||||
r = efi_free_pool(image); |
||||
if (r != EFI_SUCCESS) { |
||||
efi_st_error("Failed to free image\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
/*
|
||||
* Get length of device path without end tag. |
||||
* |
||||
* @dp device path |
||||
* @return length of device path in bytes |
||||
*/ |
||||
static efi_uintn_t dp_size(struct efi_device_path *dp) |
||||
{ |
||||
struct efi_device_path *pos = dp; |
||||
|
||||
while (pos->type != DEVICE_PATH_TYPE_END) |
||||
pos = (struct efi_device_path *)((char *)pos + pos->length); |
||||
return (char *)pos - (char *)dp; |
||||
} |
||||
|
||||
/*
|
||||
* Execute unit test. |
||||
* |
||||
* @return: EFI_ST_SUCCESS for success |
||||
*/ |
||||
static int execute(void) |
||||
{ |
||||
efi_status_t ret; |
||||
efi_uintn_t no_handles, i, len; |
||||
efi_handle_t *handles; |
||||
efi_handle_t handle_partition = NULL; |
||||
struct efi_device_path *dp_partition; |
||||
struct efi_simple_file_system_protocol *file_system; |
||||
struct efi_file_handle *root, *file; |
||||
u64 buf_size; |
||||
char buf[16] __aligned(ARCH_DMA_MINALIGN); |
||||
|
||||
ret = boottime->connect_controller(disk_handle, NULL, NULL, 1); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to connect controller\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
ret = boottime->locate_handle_buffer( |
||||
BY_PROTOCOL, &guid_device_path, NULL, |
||||
&no_handles, &handles); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to locate handles\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
len = dp_size(dp); |
||||
for (i = 0; i < no_handles; ++i) { |
||||
ret = boottime->open_protocol(handles[i], &guid_device_path, |
||||
(void **)&dp_partition, |
||||
NULL, NULL, |
||||
EFI_OPEN_PROTOCOL_GET_PROTOCOL); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to open device path protocol\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
if (len >= dp_size(dp_partition)) |
||||
continue; |
||||
if (efi_st_memcmp(dp, dp_partition, len)) |
||||
continue; |
||||
handle_partition = handles[i]; |
||||
break; |
||||
} |
||||
ret = boottime->free_pool(handles); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to free pool memory\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
if (!handle_partition) { |
||||
efi_st_error("Partition handle not found\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
ret = boottime->open_protocol(handle_partition, |
||||
&guid_simple_file_system_protocol, |
||||
(void **)&file_system, NULL, NULL, |
||||
EFI_OPEN_PROTOCOL_GET_PROTOCOL); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to open simple file system protocol\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
ret = file_system->open_volume(file_system, &root); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to open volume\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
ret = root->open(root, &file, (s16 *)L"hello.txt", EFI_FILE_MODE_READ, |
||||
0); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to open file\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
buf_size = sizeof(buf) - 1; |
||||
ret = file->read(file, &buf_size, buf); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to read file\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
if (efi_st_memcmp(buf, "Hello world!", 12)) { |
||||
efi_st_error("Unexpected file content\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
ret = file->close(file); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to close file\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
ret = root->close(root); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to close volume\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
|
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
EFI_UNIT_TEST(blkdev) = { |
||||
.name = "block device", |
||||
.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT, |
||||
.setup = setup, |
||||
.execute = execute, |
||||
.teardown = teardown, |
||||
}; |
||||
@ -0,0 +1,385 @@ |
||||
/*
|
||||
* efi_selftest_controllers |
||||
* |
||||
* Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* This unit test checks the following protocol services: |
||||
* ConnectController, DisconnectController, |
||||
* InstallProtocol, UninstallProtocol, |
||||
* OpenProtocol, CloseProtcol, OpenProtocolInformation |
||||
*/ |
||||
|
||||
#include <efi_selftest.h> |
||||
|
||||
#define NUMBER_OF_CHILD_CONTROLLERS 4 |
||||
|
||||
static struct efi_boot_services *boottime; |
||||
const efi_guid_t guid_driver_binding_protocol = |
||||
EFI_DRIVER_BINDING_PROTOCOL_GUID; |
||||
static efi_guid_t guid_controller = |
||||
EFI_GUID(0xe6ab1d96, 0x6bff, 0xdb42, |
||||
0xaa, 0x05, 0xc8, 0x1f, 0x7f, 0x45, 0x26, 0x34); |
||||
static efi_guid_t guid_child_controller = |
||||
EFI_GUID(0x1d41f6f5, 0x2c41, 0xddfb, |
||||
0xe2, 0x9b, 0xb8, 0x0e, 0x2e, 0xe8, 0x3a, 0x85); |
||||
static efi_handle_t handle_controller; |
||||
static efi_handle_t handle_child_controller[NUMBER_OF_CHILD_CONTROLLERS]; |
||||
static efi_handle_t handle_driver; |
||||
|
||||
/*
|
||||
* Count child controllers |
||||
* |
||||
* @handle handle on which child controllers are installed |
||||
* @protocol protocol for which the child controlles where installed |
||||
* @count number of child controllers |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t count_child_controllers(efi_handle_t handle, |
||||
efi_guid_t *protocol, |
||||
efi_uintn_t *count) |
||||
{ |
||||
efi_status_t ret; |
||||
efi_uintn_t entry_count; |
||||
struct efi_open_protocol_info_entry *entry_buffer; |
||||
|
||||
*count = 0; |
||||
ret = boottime->open_protocol_information(handle, protocol, |
||||
&entry_buffer, &entry_count); |
||||
if (ret != EFI_SUCCESS) |
||||
return ret; |
||||
if (!entry_count) |
||||
return EFI_SUCCESS; |
||||
while (entry_count) { |
||||
if (entry_buffer[--entry_count].attributes & |
||||
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) |
||||
++*count; |
||||
} |
||||
ret = boottime->free_pool(entry_buffer); |
||||
if (ret != EFI_SUCCESS) |
||||
efi_st_error("Cannot free buffer\n"); |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Check if the driver supports the controller. |
||||
* |
||||
* @this driver binding protocol |
||||
* @controller_handle handle of the controller |
||||
* @remaining_device_path path specifying the child controller |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI supported( |
||||
struct efi_driver_binding_protocol *this, |
||||
efi_handle_t controller_handle, |
||||
struct efi_device_path *remaining_device_path) |
||||
{ |
||||
efi_status_t ret; |
||||
void *interface; |
||||
|
||||
ret = boottime->open_protocol( |
||||
controller_handle, &guid_controller, |
||||
&interface, handle_driver, |
||||
controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER); |
||||
switch (ret) { |
||||
case EFI_ACCESS_DENIED: |
||||
case EFI_ALREADY_STARTED: |
||||
return ret; |
||||
case EFI_SUCCESS: |
||||
break; |
||||
default: |
||||
return EFI_UNSUPPORTED; |
||||
} |
||||
ret = boottime->close_protocol( |
||||
controller_handle, &guid_controller, |
||||
handle_driver, controller_handle); |
||||
if (ret != EFI_SUCCESS) |
||||
ret = EFI_UNSUPPORTED; |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Create child controllers and attach driver. |
||||
* |
||||
* @this driver binding protocol |
||||
* @controller_handle handle of the controller |
||||
* @remaining_device_path path specifying the child controller |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI start( |
||||
struct efi_driver_binding_protocol *this, |
||||
efi_handle_t controller_handle, |
||||
struct efi_device_path *remaining_device_path) |
||||
{ |
||||
size_t i; |
||||
efi_status_t ret; |
||||
void *interface; |
||||
|
||||
/* Attach driver to controller */ |
||||
ret = boottime->open_protocol( |
||||
controller_handle, &guid_controller, |
||||
&interface, handle_driver, |
||||
controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER); |
||||
switch (ret) { |
||||
case EFI_ACCESS_DENIED: |
||||
case EFI_ALREADY_STARTED: |
||||
return ret; |
||||
case EFI_SUCCESS: |
||||
break; |
||||
default: |
||||
return EFI_UNSUPPORTED; |
||||
} |
||||
|
||||
/* Create child controllers */ |
||||
for (i = 0; i < NUMBER_OF_CHILD_CONTROLLERS; ++i) { |
||||
ret = boottime->install_protocol_interface( |
||||
&handle_child_controller[i], &guid_child_controller, |
||||
EFI_NATIVE_INTERFACE, NULL); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("InstallProtocolInterface failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
ret = boottime->open_protocol( |
||||
controller_handle, &guid_controller, |
||||
&interface, handle_child_controller[i], |
||||
handle_child_controller[i], |
||||
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("OpenProtocol failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Remove a single child controller from the parent controller. |
||||
* |
||||
* @controller_handle parent controller |
||||
* @child_handle child controller |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t disconnect_child(efi_handle_t controller_handle, |
||||
efi_handle_t child_handle) |
||||
{ |
||||
efi_status_t ret; |
||||
|
||||
ret = boottime->close_protocol( |
||||
controller_handle, &guid_controller, |
||||
child_handle, child_handle); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Cannot close protocol\n"); |
||||
return ret; |
||||
} |
||||
ret = boottime->uninstall_protocol_interface( |
||||
child_handle, &guid_child_controller, NULL); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Cannot uninstall protocol interface\n"); |
||||
return ret; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Remove child controllers and disconnect the controller. |
||||
* |
||||
* @this driver binding protocol |
||||
* @controller_handle handle of the controller |
||||
* @number_of_children number of child controllers to remove |
||||
* @child_handle_buffer handles of the child controllers to remove |
||||
* @return status code |
||||
*/ |
||||
static efi_status_t EFIAPI stop( |
||||
struct efi_driver_binding_protocol *this, |
||||
efi_handle_t controller_handle, |
||||
size_t number_of_children, |
||||
efi_handle_t *child_handle_buffer) |
||||
{ |
||||
efi_status_t ret; |
||||
efi_uintn_t count; |
||||
struct efi_open_protocol_info_entry *entry_buffer; |
||||
|
||||
/* Destroy provided child controllers */ |
||||
if (number_of_children) { |
||||
efi_uintn_t i; |
||||
|
||||
for (i = 0; i < number_of_children; ++i) { |
||||
ret = disconnect_child(controller_handle, |
||||
child_handle_buffer[i]); |
||||
if (ret != EFI_SUCCESS) |
||||
return ret; |
||||
} |
||||
return EFI_SUCCESS; |
||||
} |
||||
|
||||
/* Destroy all children */ |
||||
ret = boottime->open_protocol_information( |
||||
controller_handle, &guid_controller, |
||||
&entry_buffer, &count); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("OpenProtocolInformation failed\n"); |
||||
return ret; |
||||
} |
||||
while (count) { |
||||
if (entry_buffer[--count].attributes & |
||||
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) { |
||||
ret = disconnect_child( |
||||
controller_handle, |
||||
entry_buffer[count].agent_handle); |
||||
if (ret != EFI_SUCCESS) |
||||
return ret; |
||||
} |
||||
} |
||||
ret = boottime->free_pool(entry_buffer); |
||||
if (ret != EFI_SUCCESS) |
||||
efi_st_error("Cannot free buffer\n"); |
||||
|
||||
/* Detach driver from controller */ |
||||
ret = boottime->close_protocol( |
||||
controller_handle, &guid_controller, |
||||
handle_driver, controller_handle); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Cannot close protocol\n"); |
||||
return ret; |
||||
} |
||||
return EFI_SUCCESS; |
||||
} |
||||
|
||||
/* Driver binding protocol interface */ |
||||
static struct efi_driver_binding_protocol binding_interface = { |
||||
supported, |
||||
start, |
||||
stop, |
||||
0xffffffff, |
||||
NULL, |
||||
NULL, |
||||
}; |
||||
|
||||
/*
|
||||
* Setup unit test. |
||||
* |
||||
* @handle handle of the loaded image |
||||
* @systable system table |
||||
*/ |
||||
static int setup(const efi_handle_t img_handle, |
||||
const struct efi_system_table *systable) |
||||
{ |
||||
efi_status_t ret; |
||||
|
||||
boottime = systable->boottime; |
||||
|
||||
/* Create controller handle */ |
||||
ret = boottime->install_protocol_interface( |
||||
&handle_controller, &guid_controller, |
||||
EFI_NATIVE_INTERFACE, NULL); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("InstallProtocolInterface failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
/* Create driver handle */ |
||||
ret = boottime->install_protocol_interface( |
||||
&handle_driver, &guid_driver_binding_protocol, |
||||
EFI_NATIVE_INTERFACE, &binding_interface); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("InstallProtocolInterface failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
|
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* Execute unit test. |
||||
* |
||||
* The number of child controllers is checked after each of the following |
||||
* actions: |
||||
* |
||||
* Connect a controller to a driver. |
||||
* Disconnect and destroy a child controller. |
||||
* Disconnect and destroy the remaining child controllers. |
||||
* |
||||
* Connect a controller to a driver. |
||||
* Uninstall the driver protocol from the controller. |
||||
*/ |
||||
static int execute(void) |
||||
{ |
||||
efi_status_t ret; |
||||
efi_uintn_t count; |
||||
|
||||
/* Connect controller to driver */ |
||||
ret = boottime->connect_controller(handle_controller, NULL, NULL, 1); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to connect controller\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
/* Check number of child controllers */ |
||||
ret = count_child_controllers(handle_controller, &guid_controller, |
||||
&count); |
||||
if (ret != EFI_SUCCESS || count != NUMBER_OF_CHILD_CONTROLLERS) { |
||||
efi_st_error("Number of children %u != %u\n", |
||||
(unsigned int)count, NUMBER_OF_CHILD_CONTROLLERS); |
||||
} |
||||
/* Destroy second child controller */ |
||||
ret = boottime->disconnect_controller(handle_controller, |
||||
handle_driver, |
||||
handle_child_controller[1]); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to disconnect child controller\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
/* Check number of child controllers */ |
||||
ret = count_child_controllers(handle_controller, &guid_controller, |
||||
&count); |
||||
if (ret != EFI_SUCCESS || count != NUMBER_OF_CHILD_CONTROLLERS - 1) { |
||||
efi_st_error("Destroying single child controller failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
/* Destroy remaining child controllers and disconnect controller */ |
||||
ret = boottime->disconnect_controller(handle_controller, NULL, NULL); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to disconnect controller\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
/* Check number of child controllers */ |
||||
ret = count_child_controllers(handle_controller, &guid_controller, |
||||
&count); |
||||
if (ret != EFI_SUCCESS || count) { |
||||
efi_st_error("Destroying child controllers failed\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
|
||||
/* Connect controller to driver */ |
||||
ret = boottime->connect_controller(handle_controller, NULL, NULL, 1); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to connect controller\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
/* Check number of child controllers */ |
||||
ret = count_child_controllers(handle_controller, &guid_controller, |
||||
&count); |
||||
if (ret != EFI_SUCCESS || count != NUMBER_OF_CHILD_CONTROLLERS) { |
||||
efi_st_error("Number of children %u != %u\n", |
||||
(unsigned int)count, NUMBER_OF_CHILD_CONTROLLERS); |
||||
} |
||||
/* Uninstall controller protocol */ |
||||
ret = boottime->uninstall_protocol_interface(handle_controller, |
||||
&guid_controller, NULL); |
||||
if (ret != EFI_SUCCESS) { |
||||
efi_st_error("Failed to uninstall protocols\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
/* Check number of child controllers */ |
||||
ret = count_child_controllers(handle_controller, &guid_controller, |
||||
&count); |
||||
if (ret == EFI_SUCCESS) |
||||
efi_st_error("Uninstall failed\n"); |
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
EFI_UNIT_TEST(controllers) = { |
||||
.name = "controllers", |
||||
.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT, |
||||
.setup = setup, |
||||
.execute = execute, |
||||
}; |
||||
@ -0,0 +1,69 @@ |
||||
/*
|
||||
* Non-zero 8 byte strings of a disk image |
||||
* |
||||
* Generated with tools/file2include |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#define EFI_ST_DISK_IMG { 0x00010000, { \ |
||||
{0x000001b8, "\x94\x37\x69\xfc\x00\x00\x00\x00"}, /* .7i..... */ \
|
||||
{0x000001c0, "\x02\x00\x83\x02\x02\x00\x01\x00"}, /* ........ */ \
|
||||
{0x000001c8, "\x00\x00\x7f\x00\x00\x00\x00\x00"}, /* ........ */ \
|
||||
{0x000001f8, "\x00\x00\x00\x00\x00\x00\x55\xaa"}, /* ......U. */ \
|
||||
{0x00000200, "\xeb\x3c\x90\x6d\x6b\x66\x73\x2e"}, /* .<.mkfs. */ \
|
||||
{0x00000208, "\x66\x61\x74\x00\x02\x04\x01\x00"}, /* fat..... */ \
|
||||
{0x00000210, "\x02\x00\x02\x7f\x00\xf8\x01\x00"}, /* ........ */ \
|
||||
{0x00000218, "\x20\x00\x40\x00\x00\x00\x00\x00"}, /* .@..... */ \
|
||||
{0x00000220, "\x00\x00\x00\x00\x80\x00\x29\x86"}, /* ......). */ \
|
||||
{0x00000228, "\xe8\x82\x80\x4e\x4f\x20\x4e\x41"}, /* ...NO NA */ \
|
||||
{0x00000230, "\x4d\x45\x20\x20\x20\x20\x46\x41"}, /* ME FA */ \
|
||||
{0x00000238, "\x54\x31\x32\x20\x20\x20\x0e\x1f"}, /* T12 .. */ \
|
||||
{0x00000240, "\xbe\x5b\x7c\xac\x22\xc0\x74\x0b"}, /* .[|.".t. */ \
|
||||
{0x00000248, "\x56\xb4\x0e\xbb\x07\x00\xcd\x10"}, /* V....... */ \
|
||||
{0x00000250, "\x5e\xeb\xf0\x32\xe4\xcd\x16\xcd"}, /* ^..2.... */ \
|
||||
{0x00000258, "\x19\xeb\xfe\x54\x68\x69\x73\x20"}, /* ...This */ \
|
||||
{0x00000260, "\x69\x73\x20\x6e\x6f\x74\x20\x61"}, /* is not a */ \
|
||||
{0x00000268, "\x20\x62\x6f\x6f\x74\x61\x62\x6c"}, /* bootabl */ \
|
||||
{0x00000270, "\x65\x20\x64\x69\x73\x6b\x2e\x20"}, /* e disk. */ \
|
||||
{0x00000278, "\x20\x50\x6c\x65\x61\x73\x65\x20"}, /* Please */ \
|
||||
{0x00000280, "\x69\x6e\x73\x65\x72\x74\x20\x61"}, /* insert a */ \
|
||||
{0x00000288, "\x20\x62\x6f\x6f\x74\x61\x62\x6c"}, /* bootabl */ \
|
||||
{0x00000290, "\x65\x20\x66\x6c\x6f\x70\x70\x79"}, /* e floppy */ \
|
||||
{0x00000298, "\x20\x61\x6e\x64\x0d\x0a\x70\x72"}, /* and..pr */ \
|
||||
{0x000002a0, "\x65\x73\x73\x20\x61\x6e\x79\x20"}, /* ess any */ \
|
||||
{0x000002a8, "\x6b\x65\x79\x20\x74\x6f\x20\x74"}, /* key to t */ \
|
||||
{0x000002b0, "\x72\x79\x20\x61\x67\x61\x69\x6e"}, /* ry again */ \
|
||||
{0x000002b8, "\x20\x2e\x2e\x2e\x20\x0d\x0a\x00"}, /* ... ... */ \
|
||||
{0x000003f8, "\x00\x00\x00\x00\x00\x00\x55\xaa"}, /* ......U. */ \
|
||||
{0x00000400, "\xf8\xff\xff\x00\x00\x00\x00\xf0"}, /* ........ */ \
|
||||
{0x00000408, "\xff\x00\x00\x00\x00\x00\x00\x00"}, /* ........ */ \
|
||||
{0x00000600, "\xf8\xff\xff\x00\x00\x00\x00\xf0"}, /* ........ */ \
|
||||
{0x00000608, "\xff\x00\x00\x00\x00\x00\x00\x00"}, /* ........ */ \
|
||||
{0x00000800, "\xe5\x70\x00\x00\x00\xff\xff\xff"}, /* .p...... */ \
|
||||
{0x00000808, "\xff\xff\xff\x0f\x00\x0e\xff\xff"}, /* ........ */ \
|
||||
{0x00000810, "\xff\xff\xff\xff\xff\xff\xff\xff"}, /* ........ */ \
|
||||
{0x00000818, "\xff\xff\x00\x00\xff\xff\xff\xff"}, /* ........ */ \
|
||||
{0x00000820, "\xe5\x2e\x00\x68\x00\x65\x00\x6c"}, /* ...h.e.l */ \
|
||||
{0x00000828, "\x00\x6c\x00\x0f\x00\x0e\x6f\x00"}, /* .l....o. */ \
|
||||
{0x00000830, "\x2e\x00\x74\x00\x78\x00\x74\x00"}, /* ..t.x.t. */ \
|
||||
{0x00000838, "\x2e\x00\x00\x00\x73\x00\x77\x00"}, /* ....s.w. */ \
|
||||
{0x00000840, "\xe5\x45\x4c\x4c\x4f\x54\x7e\x31"}, /* .ELLOT~1 */ \
|
||||
{0x00000848, "\x53\x57\x50\x20\x00\x64\xd0\x8a"}, /* SWP .d.. */ \
|
||||
{0x00000850, "\x92\x4b\x92\x4b\x00\x00\xd0\x8a"}, /* .K.K.... */ \
|
||||
{0x00000858, "\x92\x4b\x00\x00\x00\x00\x00\x00"}, /* .K...... */ \
|
||||
{0x00000860, "\x41\x68\x00\x65\x00\x6c\x00\x6c"}, /* Ah.e.l.l */ \
|
||||
{0x00000868, "\x00\x6f\x00\x0f\x00\xf1\x2e\x00"}, /* .o...... */ \
|
||||
{0x00000870, "\x74\x00\x78\x00\x74\x00\x00\x00"}, /* t.x.t... */ \
|
||||
{0x00000878, "\xff\xff\x00\x00\xff\xff\xff\xff"}, /* ........ */ \
|
||||
{0x00000880, "\x48\x45\x4c\x4c\x4f\x20\x20\x20"}, /* HELLO */ \
|
||||
{0x00000888, "\x54\x58\x54\x20\x00\x64\xd4\x8a"}, /* TXT .d.. */ \
|
||||
{0x00000890, "\x92\x4b\x92\x4b\x00\x00\xd4\x8a"}, /* .K.K.... */ \
|
||||
{0x00000898, "\x92\x4b\x05\x00\x0d\x00\x00\x00"}, /* .K...... */ \
|
||||
{0x000008a0, "\xe5\x45\x4c\x4c\x4f\x54\x7e\x31"}, /* .ELLOT~1 */ \
|
||||
{0x000008a8, "\x53\x57\x58\x20\x00\x64\xd0\x8a"}, /* SWX .d.. */ \
|
||||
{0x000008b0, "\x92\x4b\x92\x4b\x00\x00\xd0\x8a"}, /* .K.K.... */ \
|
||||
{0x000008b8, "\x92\x4b\x00\x00\x00\x00\x00\x00"}, /* .K...... */ \
|
||||
{0x00006000, "\x48\x65\x6c\x6c\x6f\x20\x77\x6f"}, /* Hello wo */ \
|
||||
{0x00006008, "\x72\x6c\x64\x21\x0a\x00\x00\x00"}, /* rld!.... */ \
|
||||
{0, NULL} } } |
||||
@ -0,0 +1,37 @@ |
||||
/*
|
||||
* efi_selftest_miniapp_exit |
||||
* |
||||
* Copyright (c) 2018 Heinrich Schuchardt |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* This EFI application is run by the StartImage selftest. |
||||
* It uses the Exit boot service to return. |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <efi_api.h> |
||||
|
||||
/*
|
||||
* Entry point of the EFI application. |
||||
* |
||||
* @handle handle of the loaded image |
||||
* @systable system table |
||||
* @return status code |
||||
*/ |
||||
efi_status_t EFIAPI efi_main(efi_handle_t handle, |
||||
struct efi_system_table *systable) |
||||
{ |
||||
struct efi_simple_text_output_protocol *con_out = systable->con_out; |
||||
|
||||
con_out->output_string(con_out, L"EFI application calling Exit\n"); |
||||
|
||||
/* The return value is checked by the calling test */ |
||||
systable->boottime->exit(handle, EFI_UNSUPPORTED, 0, NULL); |
||||
|
||||
/*
|
||||
* This statement should not be reached. |
||||
* To enable testing use a different return value. |
||||
*/ |
||||
return EFI_SUCCESS; |
||||
} |
||||
@ -0,0 +1,32 @@ |
||||
/*
|
||||
* efi_selftest_miniapp_return |
||||
* |
||||
* Copyright (c) 2018 Heinrich Schuchardt |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* This EFI application is run by the StartImage selftest. |
||||
* It returns directly without calling the Exit boot service. |
||||
*/ |
||||
|
||||
#include <common.h> |
||||
#include <efi_api.h> |
||||
|
||||
/*
|
||||
* Entry point of the EFI application. |
||||
* |
||||
* @handle handle of the loaded image |
||||
* @systable system table |
||||
* @return status code |
||||
*/ |
||||
efi_status_t EFIAPI efi_main(efi_handle_t handle, |
||||
struct efi_system_table *systable) |
||||
{ |
||||
struct efi_simple_text_output_protocol *con_out = systable->con_out; |
||||
|
||||
con_out->output_string(con_out, |
||||
L"EFI application returning w/o calling Exit\n"); |
||||
|
||||
/* The return value is checked by the calling test */ |
||||
return EFI_INCOMPATIBLE_VERSION; |
||||
} |
||||
@ -0,0 +1,149 @@ |
||||
/*
|
||||
* efi_selftest_start_image |
||||
* |
||||
* Copyright (c) 2018 Heinrich Schuchardt <xypron.glpk@gmx.de> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* This test checks the StartImage boot service. |
||||
* The efi_selftest_miniapp_exit.efi application is loaded into memory |
||||
* and started. |
||||
*/ |
||||
|
||||
#include <efi_selftest.h> |
||||
/* Include containing the miniapp.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 |
||||
|
||||
static efi_handle_t image_handle; |
||||
static struct efi_boot_services *boottime; |
||||
|
||||
/* 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[]; |
||||
}; |
||||
|
||||
static struct compressed_file_image img = EFI_ST_DISK_IMG; |
||||
|
||||
/* Decompressed file image */ |
||||
static u8 *image; |
||||
|
||||
/*
|
||||
* 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; |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Setup unit test. |
||||
* |
||||
* @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) |
||||
{ |
||||
image_handle = handle; |
||||
boottime = systable->boottime; |
||||
|
||||
/* Load the application image into memory */ |
||||
decompress(&image); |
||||
|
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* Tear down unit test. |
||||
* |
||||
* @return: EFI_ST_SUCCESS for success |
||||
*/ |
||||
static int teardown(void) |
||||
{ |
||||
efi_status_t r = EFI_ST_SUCCESS; |
||||
|
||||
if (image) { |
||||
r = efi_free_pool(image); |
||||
if (r != EFI_SUCCESS) { |
||||
efi_st_error("Failed to free image\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
/*
|
||||
* 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, image_handle, NULL, image, |
||||
img.length, &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; |
||||
} |
||||
|
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
EFI_UNIT_TEST(startimage_exit) = { |
||||
.name = "start image exit", |
||||
.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT, |
||||
.setup = setup, |
||||
.execute = execute, |
||||
.teardown = teardown, |
||||
}; |
||||
@ -0,0 +1,149 @@ |
||||
/*
|
||||
* efi_selftest_start_image |
||||
* |
||||
* Copyright (c) 2018 Heinrich Schuchardt <xypron.glpk@gmx.de> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* This test checks the StartImage boot service. |
||||
* The efi_selftest_miniapp_return.efi application is loaded into memory |
||||
* and started. |
||||
*/ |
||||
|
||||
#include <efi_selftest.h> |
||||
/* Include containing the miniapp.efi application */ |
||||
#include "efi_miniapp_file_image_return.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 |
||||
|
||||
static efi_handle_t image_handle; |
||||
static struct efi_boot_services *boottime; |
||||
|
||||
/* 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[]; |
||||
}; |
||||
|
||||
static struct compressed_file_image img = EFI_ST_DISK_IMG; |
||||
|
||||
/* Decompressed file image */ |
||||
static u8 *image; |
||||
|
||||
/*
|
||||
* 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; |
||||
return ret; |
||||
} |
||||
|
||||
/*
|
||||
* Setup unit test. |
||||
* |
||||
* @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) |
||||
{ |
||||
image_handle = handle; |
||||
boottime = systable->boottime; |
||||
|
||||
/* Load the application image into memory */ |
||||
decompress(&image); |
||||
|
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
/*
|
||||
* Tear down unit test. |
||||
* |
||||
* @return: EFI_ST_SUCCESS for success |
||||
*/ |
||||
static int teardown(void) |
||||
{ |
||||
efi_status_t r = EFI_ST_SUCCESS; |
||||
|
||||
if (image) { |
||||
r = efi_free_pool(image); |
||||
if (r != EFI_SUCCESS) { |
||||
efi_st_error("Failed to free image\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
/*
|
||||
* 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, image_handle, NULL, image, |
||||
img.length, &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_INCOMPATIBLE_VERSION) { |
||||
efi_st_error("Wrong return value from application\n"); |
||||
return EFI_ST_FAILURE; |
||||
} |
||||
|
||||
return EFI_ST_SUCCESS; |
||||
} |
||||
|
||||
EFI_UNIT_TEST(startimage) = { |
||||
.name = "start image return", |
||||
.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT, |
||||
.setup = setup, |
||||
.execute = execute, |
||||
.teardown = teardown, |
||||
}; |
||||
@ -0,0 +1,106 @@ |
||||
/*
|
||||
* Convert a file image to a C define |
||||
* |
||||
* Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
* |
||||
* For testing EFI disk management we need an in memory image of |
||||
* a disk. |
||||
* |
||||
* The tool file2include converts a file to a C include. The file |
||||
* is separated into strings of 8 bytes. Only the non-zero strings |
||||
* are written to the include. The output format has been designed |
||||
* to maintain readability. |
||||
* |
||||
* As the disk image needed for testing contains mostly zeroes a high |
||||
* compression ratio can be attained. |
||||
*/ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <stdint.h> |
||||
#include <malloc.h> |
||||
|
||||
/* Size of the blocks written to the compressed file */ |
||||
#define BLOCK_SIZE 8 |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
FILE *file; |
||||
int ret; |
||||
unsigned char *buf; |
||||
size_t count, i, j; |
||||
|
||||
/* Provide usage help */ |
||||
if (argc != 2) { |
||||
printf("Usage:\n%s FILENAME\n", argv[0]); |
||||
return EXIT_FAILURE; |
||||
} |
||||
/* Open file */ |
||||
file = fopen(argv[1], "r"); |
||||
if (!file) { |
||||
perror("fopen"); |
||||
return EXIT_FAILURE; |
||||
} |
||||
/* Get file length */ |
||||
ret = fseek(file, 0, SEEK_END); |
||||
if (ret < 0) { |
||||
perror("fseek"); |
||||
return EXIT_FAILURE; |
||||
} |
||||
count = ftell(file); |
||||
if (!count) { |
||||
fprintf(stderr, "File %s has length 0\n", argv[1]); |
||||
return EXIT_FAILURE; |
||||
} |
||||
rewind(file); |
||||
/* Read file */ |
||||
buf = malloc(count); |
||||
if (!buf) { |
||||
perror("calloc"); |
||||
return EXIT_FAILURE; |
||||
} |
||||
count = fread(buf, 1, count, file); |
||||
|
||||
/* Generate output */ |
||||
printf("/*\n"); |
||||
printf(" * Non-zero %u byte strings of a disk image\n", BLOCK_SIZE); |
||||
printf(" *\n"); |
||||
printf(" * Generated with tools/file2include\n"); |
||||
printf(" *\n"); |
||||
printf(" * SPDX-License-Identifier: GPL-2.0+\n"); |
||||
printf(" */\n\n"); |
||||
printf("#define EFI_ST_DISK_IMG { 0x%08zx, { \\\n", count); |
||||
|
||||
for (i = 0; i < count; i += BLOCK_SIZE) { |
||||
int c = 0; |
||||
|
||||
for (j = i; j < i + BLOCK_SIZE && j < count; ++j) { |
||||
if (buf[j]) |
||||
c = 1; |
||||
} |
||||
if (!c) |
||||
continue; |
||||
printf("\t{0x%08zx, \"", i); |
||||
for (j = i; j < i + BLOCK_SIZE && j < count; ++j) |
||||
printf("\\x%02x", buf[j]); |
||||
printf("\"}, /* "); |
||||
for (j = i; j < i + BLOCK_SIZE && j < count; ++j) { |
||||
if (buf[j] >= 0x20 && buf[j] <= 0x7e) |
||||
printf("%c", buf[j]); |
||||
else |
||||
printf("."); |
||||
} |
||||
printf(" */ \\\n"); |
||||
} |
||||
printf("\t{0, NULL} } }\n"); |
||||
|
||||
/* Release resources */ |
||||
free(buf); |
||||
ret = fclose(file); |
||||
if (ret) { |
||||
perror("fclose"); |
||||
return EXIT_FAILURE; |
||||
} |
||||
return EXIT_SUCCESS; |
||||
} |
||||
Loading…
Reference in new issue