mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-27 20:38:52 +09:00
![Sughosh Ganu](/assets/img/avatar_default.png)
Fix the build warning when building for 32 bit systems by using the length modifier for size_t. lib/efi_loader/efi_esrt.c: In function ‘efi_esrt_populate’: include/efi_loader.h:126:8: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 8 has type ‘size_t’ {aka ‘unsigned int’} [-Wformat=] Signed-off-by: Sughosh Ganu <sughosh.ganu@linaro.org> Reviewed-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
511 lines
14 KiB
C
511 lines
14 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* EFI application ESRT tables support
|
|
*
|
|
* Copyright (C) 2021 Arm Ltd.
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <efi_loader.h>
|
|
#include <log.h>
|
|
#include <efi_api.h>
|
|
#include <malloc.h>
|
|
|
|
const efi_guid_t efi_esrt_guid = EFI_SYSTEM_RESOURCE_TABLE_GUID;
|
|
|
|
static struct efi_system_resource_table *esrt;
|
|
|
|
#define EFI_ESRT_VERSION 1
|
|
|
|
/**
|
|
* efi_esrt_image_info_to_entry() - copy the information present in a fw image
|
|
* descriptor to a ESRT entry.
|
|
* The function ensures the ESRT entry matches the image_type_id in @img_info.
|
|
* In case of a mismatch we leave the entry unchanged.
|
|
*
|
|
* @img_info: the source image info descriptor
|
|
* @entry: pointer to the ESRT entry to be filled
|
|
* @desc_version: the version of the elements in img_info
|
|
* @image_type: the image type value to be set in the ESRT entry
|
|
* @flags: the capsule flags value to be set in the ESRT entry
|
|
*
|
|
* Return:
|
|
* - EFI_SUCCESS if the entry is correctly updated
|
|
* - EFI_INVALID_PARAMETER if entry does not match image_type_id in @img_info.
|
|
*/
|
|
static efi_status_t
|
|
efi_esrt_image_info_to_entry(struct efi_firmware_image_descriptor *img_info,
|
|
struct efi_system_resource_entry *entry,
|
|
u32 desc_version, u32 image_type, u32 flags)
|
|
{
|
|
if (guidcmp(&entry->fw_class, &img_info->image_type_id)) {
|
|
EFI_PRINT("ESRT entry %pUL mismatches img_type_id %pUL\n",
|
|
&entry->fw_class, &img_info->image_type_id);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
entry->fw_version = img_info->version;
|
|
|
|
entry->fw_type = image_type;
|
|
entry->capsule_flags = flags;
|
|
|
|
/*
|
|
* The field lowest_supported_image_version is only present
|
|
* on image info structure of version 2 or greater.
|
|
* See the EFI_FIRMWARE_IMAGE_DESCRIPTOR definition in UEFI.
|
|
*/
|
|
if (desc_version >= 2)
|
|
entry->lowest_supported_fw_version =
|
|
img_info->lowest_supported_image_version;
|
|
else
|
|
entry->lowest_supported_fw_version = 0;
|
|
|
|
/*
|
|
* The fields last_attempt_version and last_attempt_status
|
|
* are only present on image info structure of version 3 or
|
|
* greater.
|
|
* See the EFI_FIRMWARE_IMAGE_DESCRIPTOR definition in UEFI.
|
|
*/
|
|
if (desc_version >= 3) {
|
|
entry->last_attempt_version =
|
|
img_info->last_attempt_version;
|
|
|
|
entry->last_attempt_status =
|
|
img_info->last_attempt_status;
|
|
} else {
|
|
entry->last_attempt_version = 0;
|
|
entry->last_attempt_status = LAST_ATTEMPT_STATUS_SUCCESS;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* efi_esrt_entries_to_size() - Obtain the bytes used by an ESRT
|
|
* datastructure with @num_entries.
|
|
*
|
|
* @num_entries: the number of entries in the ESRT.
|
|
*
|
|
* Return: the number of bytes an ESRT with @num_entries occupies in memory.
|
|
*/
|
|
static
|
|
inline u32 efi_esrt_entries_to_size(u32 num_entries)
|
|
{
|
|
u32 esrt_size = sizeof(struct efi_system_resource_table) +
|
|
num_entries * sizeof(struct efi_system_resource_entry);
|
|
|
|
return esrt_size;
|
|
}
|
|
|
|
/**
|
|
* efi_esrt_allocate_install() - Allocates @num_entries for the ESRT and
|
|
* performs basic ESRT initialization.
|
|
*
|
|
* @num_entries: the number of entries that the ESRT will hold.
|
|
*
|
|
* Return:
|
|
* - pointer to the ESRT if successful.
|
|
* - NULL otherwise.
|
|
*/
|
|
static
|
|
efi_status_t efi_esrt_allocate_install(u32 num_entries)
|
|
{
|
|
efi_status_t ret;
|
|
struct efi_system_resource_table *new_esrt;
|
|
u32 size = efi_esrt_entries_to_size(num_entries);
|
|
efi_guid_t esrt_guid = efi_esrt_guid;
|
|
|
|
/* Reserve num_pages for ESRT */
|
|
ret = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, size,
|
|
(void **)&new_esrt);
|
|
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT cannot allocate memory for %d entries (%d bytes)\n",
|
|
num_entries, efi_esrt_entries_to_size(num_entries));
|
|
|
|
return ret;
|
|
}
|
|
|
|
new_esrt->fw_resource_count_max = num_entries;
|
|
new_esrt->fw_resource_count = 0;
|
|
new_esrt->fw_resource_version = EFI_ESRT_VERSION;
|
|
|
|
/* Install the ESRT in the system configuration table. */
|
|
ret = efi_install_configuration_table(&esrt_guid, (void *)new_esrt);
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to install the ESRT in the system table\n");
|
|
return ret;
|
|
}
|
|
|
|
/* If there was a previous ESRT, deallocate its memory now. */
|
|
if (esrt)
|
|
ret = EFI_CALL(efi_free_pool(esrt));
|
|
|
|
esrt = new_esrt;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* esrt_find_entry() - Obtain the ESRT entry for the image with GUID
|
|
* @img_fw_class.
|
|
*
|
|
* If the img_fw_class is not yet present in the ESRT, this function
|
|
* reserves the tail element of the current ESRT as the entry for that fw_class.
|
|
* The number of elements in the ESRT is updated in that case.
|
|
*
|
|
* @img_fw_class: the GUID of the FW image which ESRT entry we want to obtain.
|
|
*
|
|
* Return:
|
|
* - A pointer to the ESRT entry for the image with GUID img_fw_class,
|
|
* - NULL if:
|
|
* - there is no more space in the ESRT,
|
|
* - ESRT is not initialized,
|
|
*/
|
|
static
|
|
struct efi_system_resource_entry *esrt_find_entry(efi_guid_t *img_fw_class)
|
|
{
|
|
u32 filled_entries;
|
|
u32 max_entries;
|
|
struct efi_system_resource_entry *entry;
|
|
|
|
if (!esrt) {
|
|
EFI_PRINT("ESRT access before initialized\n");
|
|
return NULL;
|
|
}
|
|
|
|
filled_entries = esrt->fw_resource_count;
|
|
entry = esrt->entries;
|
|
|
|
/* Check if the image with img_fw_class is already in the ESRT. */
|
|
for (u32 idx = 0; idx < filled_entries; idx++) {
|
|
if (!guidcmp(&entry[idx].fw_class, img_fw_class)) {
|
|
EFI_PRINT("ESRT found entry for image %pUl at index %d\n",
|
|
img_fw_class, idx);
|
|
return &entry[idx];
|
|
}
|
|
}
|
|
|
|
max_entries = esrt->fw_resource_count_max;
|
|
/*
|
|
* Since the image with img_fw_class is not present in the ESRT, check
|
|
* if ESRT is full before appending the new entry to it.
|
|
*/
|
|
if (filled_entries == max_entries) {
|
|
EFI_PRINT("ESRT full, this should not happen\n");
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* This is a new entry for a fw image, increment the element
|
|
* number in the table and set the fw_class field.
|
|
*/
|
|
esrt->fw_resource_count++;
|
|
entry[filled_entries].fw_class = *img_fw_class;
|
|
EFI_PRINT("ESRT allocated new entry for image %pUl at index %d\n",
|
|
img_fw_class, filled_entries);
|
|
|
|
return &entry[filled_entries];
|
|
}
|
|
|
|
/**
|
|
* efi_esrt_add_from_fmp() - Populates a sequence of ESRT entries from the FW
|
|
* images in the FMP.
|
|
*
|
|
* @fmp: the FMP instance from which FW images are added to the ESRT
|
|
*
|
|
* Return:
|
|
* - EFI_SUCCESS if all the FW images in the FMP are added to the ESRT
|
|
* - Error status otherwise
|
|
*/
|
|
static
|
|
efi_status_t efi_esrt_add_from_fmp(struct efi_firmware_management_protocol *fmp)
|
|
{
|
|
struct efi_system_resource_entry *entry = NULL;
|
|
size_t info_size = 0;
|
|
struct efi_firmware_image_descriptor *img_info = NULL;
|
|
u32 desc_version;
|
|
u8 desc_count;
|
|
size_t desc_size;
|
|
u32 package_version;
|
|
u16 *package_version_name;
|
|
efi_status_t ret = EFI_SUCCESS;
|
|
|
|
/*
|
|
* TODO: set the field image_type depending on the FW image type
|
|
* defined in a platform basis.
|
|
*/
|
|
u32 image_type = ESRT_FW_TYPE_UNKNOWN;
|
|
|
|
/* TODO: set the capsule flags as a function of the FW image type. */
|
|
u32 flags = 0;
|
|
|
|
ret = EFI_CALL(fmp->get_image_info(fmp, &info_size, img_info,
|
|
&desc_version, &desc_count,
|
|
&desc_size, NULL, NULL));
|
|
|
|
if (ret != EFI_BUFFER_TOO_SMALL) {
|
|
/*
|
|
* An input of info_size=0 should always lead
|
|
* fmp->get_image_info to return BUFFER_TO_SMALL.
|
|
*/
|
|
EFI_PRINT("Erroneous FMP implementation\n");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
ret = EFI_CALL(efi_allocate_pool(EFI_BOOT_SERVICES_DATA, info_size,
|
|
(void **)&img_info));
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to allocate memory for image info.\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = EFI_CALL(fmp->get_image_info(fmp, &info_size, img_info,
|
|
&desc_version, &desc_count,
|
|
&desc_size, &package_version,
|
|
&package_version_name));
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to obtain the FMP image info\n");
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Iterate over all the FW images in the FMP.
|
|
*/
|
|
for (u32 desc_idx = 0; desc_idx < desc_count; desc_idx++) {
|
|
struct efi_firmware_image_descriptor *cur_img_info =
|
|
(struct efi_firmware_image_descriptor *)
|
|
((uintptr_t)img_info + desc_idx * desc_size);
|
|
|
|
/*
|
|
* Obtain the ESRT entry for the FW image with fw_class
|
|
* equal to cur_img_info->image_type_id.
|
|
*/
|
|
entry = esrt_find_entry(&cur_img_info->image_type_id);
|
|
|
|
if (entry) {
|
|
ret = efi_esrt_image_info_to_entry(cur_img_info, entry,
|
|
desc_version,
|
|
image_type, flags);
|
|
if (ret != EFI_SUCCESS)
|
|
EFI_PRINT("ESRT entry mismatches image_type\n");
|
|
|
|
} else {
|
|
EFI_PRINT("ESRT failed to add entry for %pUl\n",
|
|
&cur_img_info->image_type_id);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
out:
|
|
EFI_CALL(efi_free_pool(img_info));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* efi_esrt_populate() - Populates the ESRT entries from the FMP instances
|
|
* present in the system.
|
|
* If an ESRT already exists, the old ESRT is replaced in the system table.
|
|
* The memory of the old ESRT is deallocated.
|
|
*
|
|
* Return:
|
|
* - EFI_SUCCESS if the ESRT is correctly created
|
|
* - error code otherwise.
|
|
*/
|
|
efi_status_t efi_esrt_populate(void)
|
|
{
|
|
efi_handle_t *base_handle = NULL;
|
|
efi_handle_t *it_handle;
|
|
size_t no_handles = 0;
|
|
struct efi_firmware_management_protocol *fmp;
|
|
efi_status_t ret;
|
|
u32 num_entries = 0;
|
|
struct efi_handler *handler;
|
|
|
|
/*
|
|
* Obtain the number of registered FMP handles.
|
|
*/
|
|
ret = EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL,
|
|
&efi_guid_firmware_management_protocol,
|
|
NULL, &no_handles,
|
|
(efi_handle_t **)&base_handle));
|
|
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT There are no FMP instances\n");
|
|
|
|
ret = efi_esrt_allocate_install(0);
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to create table with 0 entries\n");
|
|
return ret;
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
EFI_PRINT("ESRT populate esrt from (%zd) available FMP handles\n",
|
|
no_handles);
|
|
|
|
/*
|
|
* Iterate over all FMPs to determine an upper bound on the number of
|
|
* ESRT entries.
|
|
*/
|
|
it_handle = base_handle;
|
|
for (u32 idx = 0; idx < no_handles; idx++, it_handle++) {
|
|
struct efi_firmware_image_descriptor *img_info = NULL;
|
|
size_t info_size = 0;
|
|
u32 desc_version = 0;
|
|
u8 desc_count = 0;
|
|
size_t desc_size = 0;
|
|
u32 package_version;
|
|
u16 *package_version_name;
|
|
|
|
ret = efi_search_protocol(*it_handle,
|
|
&efi_guid_firmware_management_protocol,
|
|
&handler);
|
|
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT Unable to find FMP handle (%d)\n",
|
|
idx);
|
|
goto out;
|
|
}
|
|
fmp = handler->protocol_interface;
|
|
|
|
ret = EFI_CALL(fmp->get_image_info(fmp, &info_size, NULL,
|
|
&desc_version, &desc_count,
|
|
&desc_size, &package_version,
|
|
&package_version_name));
|
|
|
|
if (ret != EFI_BUFFER_TOO_SMALL) {
|
|
/*
|
|
* An input of info_size=0 should always lead
|
|
* fmp->get_image_info to return BUFFER_TO_SMALL.
|
|
*/
|
|
EFI_PRINT("ESRT erroneous FMP implementation\n");
|
|
ret = EFI_INVALID_PARAMETER;
|
|
goto out;
|
|
}
|
|
|
|
ret = EFI_CALL(efi_allocate_pool(EFI_BOOT_SERVICES_DATA, info_size,
|
|
(void **)&img_info));
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to allocate memory for image info\n");
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Calls to a FMP get_image_info method do not return the
|
|
* desc_count value if the return status differs from EFI_SUCCESS.
|
|
* We need to repeat the call to get_image_info with a properly
|
|
* sized buffer in order to obtain the real number of images
|
|
* handled by the FMP.
|
|
*/
|
|
ret = EFI_CALL(fmp->get_image_info(fmp, &info_size, img_info,
|
|
&desc_version, &desc_count,
|
|
&desc_size, &package_version,
|
|
&package_version_name));
|
|
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to obtain image info from FMP\n");
|
|
EFI_CALL(efi_free_pool(img_info));
|
|
goto out;
|
|
}
|
|
|
|
num_entries += desc_count;
|
|
|
|
EFI_CALL(efi_free_pool(img_info));
|
|
}
|
|
|
|
EFI_PRINT("ESRT create table with %d entries\n", num_entries);
|
|
/*
|
|
* Allocate an ESRT with the sufficient number of entries to accommodate
|
|
* all the FMPs in the system.
|
|
*/
|
|
ret = efi_esrt_allocate_install(num_entries);
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to initialize table\n");
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Populate the ESRT entries with all existing FMP.
|
|
*/
|
|
it_handle = base_handle;
|
|
for (u32 idx = 0; idx < no_handles; idx++, it_handle++) {
|
|
ret = EFI_CALL(efi_search_protocol(*it_handle,
|
|
&efi_guid_firmware_management_protocol,
|
|
&handler));
|
|
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT unable to find FMP handle (%d)\n",
|
|
idx);
|
|
break;
|
|
}
|
|
fmp = handler->protocol_interface;
|
|
|
|
ret = efi_esrt_add_from_fmp(fmp);
|
|
if (ret != EFI_SUCCESS)
|
|
EFI_PRINT("ESRT failed to add FMP to the table\n");
|
|
}
|
|
|
|
out:
|
|
|
|
EFI_CALL(efi_free_pool(base_handle));
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* efi_esrt_new_fmp_notify() - Callback for the EVT_NOTIFY_SIGNAL event raised
|
|
* when a new FMP protocol instance is registered in the system.
|
|
*/
|
|
static void EFIAPI efi_esrt_new_fmp_notify(struct efi_event *event,
|
|
void *context)
|
|
{
|
|
efi_status_t ret;
|
|
|
|
EFI_ENTRY();
|
|
|
|
ret = efi_esrt_populate();
|
|
if (ret != EFI_SUCCESS)
|
|
EFI_PRINT("ESRT failed to populate ESRT entry\n");
|
|
|
|
EFI_EXIT(ret);
|
|
}
|
|
|
|
/**
|
|
* efi_esrt_register() - Install the ESRT system table.
|
|
*
|
|
* Return: status code
|
|
*/
|
|
efi_status_t efi_esrt_register(void)
|
|
{
|
|
struct efi_event *ev = NULL;
|
|
void *registration;
|
|
efi_status_t ret;
|
|
|
|
EFI_PRINT("ESRT creation start\n");
|
|
|
|
ret = efi_esrt_populate();
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to initiate the table\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = EFI_CALL(efi_create_event(EVT_NOTIFY_SIGNAL, TPL_CALLBACK,
|
|
efi_esrt_new_fmp_notify, NULL, NULL, &ev));
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to create event\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = EFI_CALL(efi_register_protocol_notify(&efi_guid_firmware_management_protocol,
|
|
ev, ®istration));
|
|
if (ret != EFI_SUCCESS) {
|
|
EFI_PRINT("ESRT failed to register FMP callback\n");
|
|
return ret;
|
|
}
|
|
|
|
EFI_PRINT("ESRT table created\n");
|
|
|
|
return ret;
|
|
}
|