Merge branch 'x86-efi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip
Pull x86 EFI updates from Ingo Molnar:
"EFI changes:
- Use idiomatic negative error values in efivar_create_sysfs_entry()
instead of returning '1' to indicate error (Dan Carpenter)
- Implement new support to expose the EFI System Resource Tables in
sysfs, which provides information for performing firmware updates
(Peter Jones)
- Documentation cleanup in the EFI handover protocol section which
falsely claimed that 'cmdline_size' needed to be filled out by the
boot loader (Alex Smith)
- Align the order of SMBIOS tables in /sys/firmware/efi/systab to
match the way that we do things for ACPI and add documentation to
Documentation/ABI (Jean Delvare)"
* 'x86-efi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
efi: Work around ia64 build problem with ESRT driver
efi: Add 'systab' information to Documentation/ABI
efi: dmi: List SMBIOS3 table before SMBIOS table
efi/esrt: Fix some compiler warnings
x86, doc: Remove cmdline_size from list of fields to be filled in for EFI handover
efi: Add esrt support
efi: efivar_create_sysfs_entry() should return negative error codes
This commit is contained in:
Linus Torvalds
commit
cfe3eceb7a
|
|
@ -18,3 +18,13 @@ Contact: Dave Young <dyoung@redhat.com>
|
|||
Description: It shows the physical address of config table entry in the EFI
|
||||
system table.
|
||||
Users: Kexec
|
||||
|
||||
What: /sys/firmware/efi/systab
|
||||
Date: April 2005
|
||||
Contact: linux-efi@vger.kernel.org
|
||||
Description: Displays the physical addresses of all EFI Configuration
|
||||
Tables found via the EFI System Table. The order in
|
||||
which the tables are printed forms an ABI and newer
|
||||
versions are always printed first, i.e. ACPI20 comes
|
||||
before ACPI.
|
||||
Users: dmidecode
|
||||
|
|
|
|||
|
|
@ -0,0 +1,81 @@
|
|||
What: /sys/firmware/efi/esrt/
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: Provides userland access to read the EFI System Resource Table
|
||||
(ESRT), a catalog of firmware for which can be updated with
|
||||
the UEFI UpdateCapsule mechanism described in section 7.5 of
|
||||
the UEFI Standard.
|
||||
Users: fwupdate - https://github.com/rhinstaller/fwupdate
|
||||
|
||||
What: /sys/firmware/efi/esrt/fw_resource_count
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: The number of entries in the ESRT
|
||||
|
||||
What: /sys/firmware/efi/esrt/fw_resource_count_max
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: The maximum number of entries that /could/ be registered
|
||||
in the allocation the table is currently in. This is
|
||||
really only useful to the system firmware itself.
|
||||
|
||||
What: /sys/firmware/efi/esrt/fw_resource_version
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: The version of the ESRT structure provided by the firmware.
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: Each ESRT entry is identified by a GUID, and each gets a
|
||||
subdirectory under entries/ .
|
||||
example: /sys/firmware/efi/esrt/entries/entry0/
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/fw_type
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: What kind of firmware entry this is:
|
||||
0 - Unknown
|
||||
1 - System Firmware
|
||||
2 - Device Firmware
|
||||
3 - UEFI Driver
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/fw_class
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: This is the entry's guid, and will match the directory name.
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/fw_version
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: The version of the firmware currently installed. This is a
|
||||
32-bit unsigned integer.
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/lowest_supported_fw_version
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: The lowest version of the firmware that can be installed.
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/capsule_flags
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: Flags that must be passed to UpdateCapsule()
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/last_attempt_version
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: The last firmware version for which an update was attempted.
|
||||
|
||||
What: /sys/firmware/efi/esrt/entries/entry$N/last_attempt_status
|
||||
Date: February 2015
|
||||
Contact: Peter Jones <pjones@redhat.com>
|
||||
Description: The result of the last firmware update attempt for the
|
||||
firmware resource entry.
|
||||
0 - Success
|
||||
1 - Insufficient resources
|
||||
2 - Incorrect version
|
||||
3 - Invalid format
|
||||
4 - Authentication error
|
||||
5 - AC power event
|
||||
6 - Battery power event
|
||||
|
||||
|
|
@ -1124,7 +1124,6 @@ The boot loader *must* fill out the following fields in bp,
|
|||
|
||||
o hdr.code32_start
|
||||
o hdr.cmd_line_ptr
|
||||
o hdr.cmdline_size
|
||||
o hdr.ramdisk_image (if applicable)
|
||||
o hdr.ramdisk_size (if applicable)
|
||||
|
||||
|
|
|
|||
|
|
@ -501,6 +501,8 @@ void __init efi_init(void)
|
|||
|
||||
if (efi_enabled(EFI_DBG))
|
||||
print_efi_memmap();
|
||||
|
||||
efi_esrt_init();
|
||||
}
|
||||
|
||||
void __init efi_late_init(void)
|
||||
|
|
|
|||
|
|
@ -18,6 +18,11 @@ config EFI_VARS
|
|||
Subsequent efibootmgr releases may be found at:
|
||||
<http://github.com/vathpela/efibootmgr>
|
||||
|
||||
config EFI_ESRT
|
||||
bool
|
||||
depends on EFI && !IA64
|
||||
default y
|
||||
|
||||
config EFI_VARS_PSTORE
|
||||
tristate "Register efivars backend for pstore"
|
||||
depends on EFI_VARS && PSTORE
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
#
|
||||
obj-$(CONFIG_EFI) += efi.o vars.o reboot.o
|
||||
obj-$(CONFIG_EFI_VARS) += efivars.o
|
||||
obj-$(CONFIG_EFI_ESRT) += esrt.o
|
||||
obj-$(CONFIG_EFI_VARS_PSTORE) += efi-pstore.o
|
||||
obj-$(CONFIG_UEFI_CPER) += cper.o
|
||||
obj-$(CONFIG_EFI_RUNTIME_MAP) += runtime-map.o
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ struct efi __read_mostly efi = {
|
|||
.fw_vendor = EFI_INVALID_TABLE_ADDR,
|
||||
.runtime = EFI_INVALID_TABLE_ADDR,
|
||||
.config_table = EFI_INVALID_TABLE_ADDR,
|
||||
.esrt = EFI_INVALID_TABLE_ADDR,
|
||||
};
|
||||
EXPORT_SYMBOL(efi);
|
||||
|
||||
|
|
@ -64,7 +65,7 @@ static int __init parse_efi_cmdline(char *str)
|
|||
}
|
||||
early_param("efi", parse_efi_cmdline);
|
||||
|
||||
static struct kobject *efi_kobj;
|
||||
struct kobject *efi_kobj;
|
||||
static struct kobject *efivars_kobj;
|
||||
|
||||
/*
|
||||
|
|
@ -85,10 +86,15 @@ static ssize_t systab_show(struct kobject *kobj,
|
|||
str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
|
||||
if (efi.acpi != EFI_INVALID_TABLE_ADDR)
|
||||
str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
|
||||
if (efi.smbios != EFI_INVALID_TABLE_ADDR)
|
||||
str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
|
||||
/*
|
||||
* If both SMBIOS and SMBIOS3 entry points are implemented, the
|
||||
* SMBIOS3 entry point shall be preferred, so we list it first to
|
||||
* let applications stop parsing after the first match.
|
||||
*/
|
||||
if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
|
||||
str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
|
||||
if (efi.smbios != EFI_INVALID_TABLE_ADDR)
|
||||
str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
|
||||
if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
|
||||
str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
|
||||
if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
|
||||
|
|
@ -232,6 +238,84 @@ err_put:
|
|||
|
||||
subsys_initcall(efisubsys_init);
|
||||
|
||||
/*
|
||||
* Find the efi memory descriptor for a given physical address. Given a
|
||||
* physicall address, determine if it exists within an EFI Memory Map entry,
|
||||
* and if so, populate the supplied memory descriptor with the appropriate
|
||||
* data.
|
||||
*/
|
||||
int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
|
||||
{
|
||||
struct efi_memory_map *map = efi.memmap;
|
||||
void *p, *e;
|
||||
|
||||
if (!efi_enabled(EFI_MEMMAP)) {
|
||||
pr_err_once("EFI_MEMMAP is not enabled.\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!map) {
|
||||
pr_err_once("efi.memmap is not set.\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (!out_md) {
|
||||
pr_err_once("out_md is null.\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (WARN_ON_ONCE(!map->phys_map))
|
||||
return -EINVAL;
|
||||
if (WARN_ON_ONCE(map->nr_map == 0) || WARN_ON_ONCE(map->desc_size == 0))
|
||||
return -EINVAL;
|
||||
|
||||
e = map->phys_map + map->nr_map * map->desc_size;
|
||||
for (p = map->phys_map; p < e; p += map->desc_size) {
|
||||
efi_memory_desc_t *md;
|
||||
u64 size;
|
||||
u64 end;
|
||||
|
||||
/*
|
||||
* If a driver calls this after efi_free_boot_services,
|
||||
* ->map will be NULL, and the target may also not be mapped.
|
||||
* So just always get our own virtual map on the CPU.
|
||||
*
|
||||
*/
|
||||
md = early_memremap((phys_addr_t)p, sizeof (*md));
|
||||
if (!md) {
|
||||
pr_err_once("early_memremap(%p, %zu) failed.\n",
|
||||
p, sizeof (*md));
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
|
||||
md->type != EFI_BOOT_SERVICES_DATA &&
|
||||
md->type != EFI_RUNTIME_SERVICES_DATA) {
|
||||
early_memunmap(md, sizeof (*md));
|
||||
continue;
|
||||
}
|
||||
|
||||
size = md->num_pages << EFI_PAGE_SHIFT;
|
||||
end = md->phys_addr + size;
|
||||
if (phys_addr >= md->phys_addr && phys_addr < end) {
|
||||
memcpy(out_md, md, sizeof(*out_md));
|
||||
early_memunmap(md, sizeof (*md));
|
||||
return 0;
|
||||
}
|
||||
|
||||
early_memunmap(md, sizeof (*md));
|
||||
}
|
||||
pr_err_once("requested map not found.\n");
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
/*
|
||||
* Calculate the highest address of an efi memory descriptor.
|
||||
*/
|
||||
u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
|
||||
{
|
||||
u64 size = md->num_pages << EFI_PAGE_SHIFT;
|
||||
u64 end = md->phys_addr + size;
|
||||
return end;
|
||||
}
|
||||
|
||||
/*
|
||||
* We can't ioremap data in EFI boot services RAM, because we've already mapped
|
||||
|
|
@ -274,6 +358,7 @@ static __initdata efi_config_table_type_t common_tables[] = {
|
|||
{SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
|
||||
{SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
|
||||
{UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
|
||||
{EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
|
||||
{NULL_GUID, NULL, NULL},
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -535,7 +535,7 @@ static ssize_t efivar_delete(struct file *filp, struct kobject *kobj,
|
|||
* efivar_create_sysfs_entry - create a new entry in sysfs
|
||||
* @new_var: efivar entry to create
|
||||
*
|
||||
* Returns 1 on failure, 0 on success
|
||||
* Returns 0 on success, negative error code on failure
|
||||
*/
|
||||
static int
|
||||
efivar_create_sysfs_entry(struct efivar_entry *new_var)
|
||||
|
|
@ -544,6 +544,7 @@ efivar_create_sysfs_entry(struct efivar_entry *new_var)
|
|||
char *short_name;
|
||||
unsigned long variable_name_size;
|
||||
efi_char16_t *variable_name;
|
||||
int ret;
|
||||
|
||||
variable_name = new_var->var.VariableName;
|
||||
variable_name_size = ucs2_strlen(variable_name) * sizeof(efi_char16_t);
|
||||
|
|
@ -558,7 +559,7 @@ efivar_create_sysfs_entry(struct efivar_entry *new_var)
|
|||
short_name = kzalloc(short_name_size, GFP_KERNEL);
|
||||
|
||||
if (!short_name)
|
||||
return 1;
|
||||
return -ENOMEM;
|
||||
|
||||
/* Convert Unicode to normal chars (assume top bits are 0),
|
||||
ala UTF-8 */
|
||||
|
|
@ -574,11 +575,11 @@ efivar_create_sysfs_entry(struct efivar_entry *new_var)
|
|||
|
||||
new_var->kobj.kset = efivars_kset;
|
||||
|
||||
i = kobject_init_and_add(&new_var->kobj, &efivar_ktype,
|
||||
ret = kobject_init_and_add(&new_var->kobj, &efivar_ktype,
|
||||
NULL, "%s", short_name);
|
||||
kfree(short_name);
|
||||
if (i)
|
||||
return 1;
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
kobject_uevent(&new_var->kobj, KOBJ_ADD);
|
||||
efivar_entry_add(new_var, &efivar_sysfs_list);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,471 @@
|
|||
/*
|
||||
* esrt.c
|
||||
*
|
||||
* This module exports EFI System Resource Table (ESRT) entries into userspace
|
||||
* through the sysfs file system. The ESRT provides a read-only catalog of
|
||||
* system components for which the system accepts firmware upgrades via UEFI's
|
||||
* "Capsule Update" feature. This module allows userland utilities to evaluate
|
||||
* what firmware updates can be applied to this system, and potentially arrange
|
||||
* for those updates to occur.
|
||||
*
|
||||
* Data is currently found below /sys/firmware/efi/esrt/...
|
||||
*/
|
||||
#define pr_fmt(fmt) "esrt: " fmt
|
||||
|
||||
#include <linux/capability.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/efi.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/kobject.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/memblock.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include <asm/io.h>
|
||||
#include <asm/early_ioremap.h>
|
||||
|
||||
struct efi_system_resource_entry_v1 {
|
||||
efi_guid_t fw_class;
|
||||
u32 fw_type;
|
||||
u32 fw_version;
|
||||
u32 lowest_supported_fw_version;
|
||||
u32 capsule_flags;
|
||||
u32 last_attempt_version;
|
||||
u32 last_attempt_status;
|
||||
};
|
||||
|
||||
/*
|
||||
* _count and _version are what they seem like. _max is actually just
|
||||
* accounting info for the firmware when creating the table; it should never
|
||||
* have been exposed to us. To wit, the spec says:
|
||||
* The maximum number of resource array entries that can be within the
|
||||
* table without reallocating the table, must not be zero.
|
||||
* Since there's no guidance about what that means in terms of memory layout,
|
||||
* it means nothing to us.
|
||||
*/
|
||||
struct efi_system_resource_table {
|
||||
u32 fw_resource_count;
|
||||
u32 fw_resource_count_max;
|
||||
u64 fw_resource_version;
|
||||
u8 entries[];
|
||||
};
|
||||
|
||||
static phys_addr_t esrt_data;
|
||||
static size_t esrt_data_size;
|
||||
|
||||
static struct efi_system_resource_table *esrt;
|
||||
|
||||
struct esre_entry {
|
||||
union {
|
||||
struct efi_system_resource_entry_v1 *esre1;
|
||||
} esre;
|
||||
|
||||
struct kobject kobj;
|
||||
struct list_head list;
|
||||
};
|
||||
|
||||
/* global list of esre_entry. */
|
||||
static LIST_HEAD(entry_list);
|
||||
|
||||
/* entry attribute */
|
||||
struct esre_attribute {
|
||||
struct attribute attr;
|
||||
ssize_t (*show)(struct esre_entry *entry, char *buf);
|
||||
ssize_t (*store)(struct esre_entry *entry,
|
||||
const char *buf, size_t count);
|
||||
};
|
||||
|
||||
static struct esre_entry *to_entry(struct kobject *kobj)
|
||||
{
|
||||
return container_of(kobj, struct esre_entry, kobj);
|
||||
}
|
||||
|
||||
static struct esre_attribute *to_attr(struct attribute *attr)
|
||||
{
|
||||
return container_of(attr, struct esre_attribute, attr);
|
||||
}
|
||||
|
||||
static ssize_t esre_attr_show(struct kobject *kobj,
|
||||
struct attribute *_attr, char *buf)
|
||||
{
|
||||
struct esre_entry *entry = to_entry(kobj);
|
||||
struct esre_attribute *attr = to_attr(_attr);
|
||||
|
||||
/* Don't tell normal users what firmware versions we've got... */
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EACCES;
|
||||
|
||||
return attr->show(entry, buf);
|
||||
}
|
||||
|
||||
static const struct sysfs_ops esre_attr_ops = {
|
||||
.show = esre_attr_show,
|
||||
};
|
||||
|
||||
/* Generic ESRT Entry ("ESRE") support. */
|
||||
static ssize_t esre_fw_class_show(struct esre_entry *entry, char *buf)
|
||||
{
|
||||
char *str = buf;
|
||||
|
||||
efi_guid_to_str(&entry->esre.esre1->fw_class, str);
|
||||
str += strlen(str);
|
||||
str += sprintf(str, "\n");
|
||||
|
||||
return str - buf;
|
||||
}
|
||||
|
||||
static struct esre_attribute esre_fw_class = __ATTR(fw_class, 0400,
|
||||
esre_fw_class_show, NULL);
|
||||
|
||||
#define esre_attr_decl(name, size, fmt) \
|
||||
static ssize_t esre_##name##_show(struct esre_entry *entry, char *buf) \
|
||||
{ \
|
||||
return sprintf(buf, fmt "\n", \
|
||||
le##size##_to_cpu(entry->esre.esre1->name)); \
|
||||
} \
|
||||
\
|
||||
static struct esre_attribute esre_##name = __ATTR(name, 0400, \
|
||||
esre_##name##_show, NULL)
|
||||
|
||||
esre_attr_decl(fw_type, 32, "%u");
|
||||
esre_attr_decl(fw_version, 32, "%u");
|
||||
esre_attr_decl(lowest_supported_fw_version, 32, "%u");
|
||||
esre_attr_decl(capsule_flags, 32, "0x%x");
|
||||
esre_attr_decl(last_attempt_version, 32, "%u");
|
||||
esre_attr_decl(last_attempt_status, 32, "%u");
|
||||
|
||||
static struct attribute *esre1_attrs[] = {
|
||||
&esre_fw_class.attr,
|
||||
&esre_fw_type.attr,
|
||||
&esre_fw_version.attr,
|
||||
&esre_lowest_supported_fw_version.attr,
|
||||
&esre_capsule_flags.attr,
|
||||
&esre_last_attempt_version.attr,
|
||||
&esre_last_attempt_status.attr,
|
||||
NULL
|
||||
};
|
||||
static void esre_release(struct kobject *kobj)
|
||||
{
|
||||
struct esre_entry *entry = to_entry(kobj);
|
||||
|
||||
list_del(&entry->list);
|
||||
kfree(entry);
|
||||
}
|
||||
|
||||
static struct kobj_type esre1_ktype = {
|
||||
.release = esre_release,
|
||||
.sysfs_ops = &esre_attr_ops,
|
||||
.default_attrs = esre1_attrs,
|
||||
};
|
||||
|
||||
|
||||
static struct kobject *esrt_kobj;
|
||||
static struct kset *esrt_kset;
|
||||
|
||||
static int esre_create_sysfs_entry(void *esre, int entry_num)
|
||||
{
|
||||
struct esre_entry *entry;
|
||||
char name[20];
|
||||
|
||||
entry = kzalloc(sizeof(*entry), GFP_KERNEL);
|
||||
if (!entry)
|
||||
return -ENOMEM;
|
||||
|
||||
sprintf(name, "entry%d", entry_num);
|
||||
|
||||
entry->kobj.kset = esrt_kset;
|
||||
|
||||
if (esrt->fw_resource_version == 1) {
|
||||
int rc = 0;
|
||||
|
||||
entry->esre.esre1 = esre;
|
||||
rc = kobject_init_and_add(&entry->kobj, &esre1_ktype, NULL,
|
||||
"%s", name);
|
||||
if (rc) {
|
||||
kfree(entry);
|
||||
return rc;
|
||||
}
|
||||
}
|
||||
|
||||
list_add_tail(&entry->list, &entry_list);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* support for displaying ESRT fields at the top level */
|
||||
#define esrt_attr_decl(name, size, fmt) \
|
||||
static ssize_t esrt_##name##_show(struct kobject *kobj, \
|
||||
struct kobj_attribute *attr, char *buf)\
|
||||
{ \
|
||||
return sprintf(buf, fmt "\n", le##size##_to_cpu(esrt->name)); \
|
||||
} \
|
||||
\
|
||||
static struct kobj_attribute esrt_##name = __ATTR(name, 0400, \
|
||||
esrt_##name##_show, NULL)
|
||||
|
||||
esrt_attr_decl(fw_resource_count, 32, "%u");
|
||||
esrt_attr_decl(fw_resource_count_max, 32, "%u");
|
||||
esrt_attr_decl(fw_resource_version, 64, "%llu");
|
||||
|
||||
static struct attribute *esrt_attrs[] = {
|
||||
&esrt_fw_resource_count.attr,
|
||||
&esrt_fw_resource_count_max.attr,
|
||||
&esrt_fw_resource_version.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static inline int esrt_table_exists(void)
|
||||
{
|
||||
if (!efi_enabled(EFI_CONFIG_TABLES))
|
||||
return 0;
|
||||
if (efi.esrt == EFI_INVALID_TABLE_ADDR)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static umode_t esrt_attr_is_visible(struct kobject *kobj,
|
||||
struct attribute *attr, int n)
|
||||
{
|
||||
if (!esrt_table_exists())
|
||||
return 0;
|
||||
return attr->mode;
|
||||
}
|
||||
|
||||
static struct attribute_group esrt_attr_group = {
|
||||
.attrs = esrt_attrs,
|
||||
.is_visible = esrt_attr_is_visible,
|
||||
};
|
||||
|
||||
/*
|
||||
* remap the table, copy it to kmalloced pages, and unmap it.
|
||||
*/
|
||||
void __init efi_esrt_init(void)
|
||||
{
|
||||
void *va;
|
||||
struct efi_system_resource_table tmpesrt;
|
||||
struct efi_system_resource_entry_v1 *v1_entries;
|
||||
size_t size, max, entry_size, entries_size;
|
||||
efi_memory_desc_t md;
|
||||
int rc;
|
||||
phys_addr_t end;
|
||||
|
||||
pr_debug("esrt-init: loading.\n");
|
||||
if (!esrt_table_exists())
|
||||
return;
|
||||
|
||||
rc = efi_mem_desc_lookup(efi.esrt, &md);
|
||||
if (rc < 0) {
|
||||
pr_err("ESRT header is not in the memory map.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
max = efi_mem_desc_end(&md);
|
||||
if (max < efi.esrt) {
|
||||
pr_err("EFI memory descriptor is invalid. (esrt: %p max: %p)\n",
|
||||
(void *)efi.esrt, (void *)max);
|
||||
return;
|
||||
}
|
||||
|
||||
size = sizeof(*esrt);
|
||||
max -= efi.esrt;
|
||||
|
||||
if (max < size) {
|
||||
pr_err("ESRT header doen't fit on single memory map entry. (size: %zu max: %zu)\n",
|
||||
size, max);
|
||||
return;
|
||||
}
|
||||
|
||||
va = early_memremap(efi.esrt, size);
|
||||
if (!va) {
|
||||
pr_err("early_memremap(%p, %zu) failed.\n", (void *)efi.esrt,
|
||||
size);
|
||||
return;
|
||||
}
|
||||
|
||||
memcpy(&tmpesrt, va, sizeof(tmpesrt));
|
||||
|
||||
if (tmpesrt.fw_resource_version == 1) {
|
||||
entry_size = sizeof (*v1_entries);
|
||||
} else {
|
||||
pr_err("Unsupported ESRT version %lld.\n",
|
||||
tmpesrt.fw_resource_version);
|
||||
return;
|
||||
}
|
||||
|
||||
if (tmpesrt.fw_resource_count > 0 && max - size < entry_size) {
|
||||
pr_err("ESRT memory map entry can only hold the header. (max: %zu size: %zu)\n",
|
||||
max - size, entry_size);
|
||||
goto err_memunmap;
|
||||
}
|
||||
|
||||
/*
|
||||
* The format doesn't really give us any boundary to test here,
|
||||
* so I'm making up 128 as the max number of individually updatable
|
||||
* components we support.
|
||||
* 128 should be pretty excessive, but there's still some chance
|
||||
* somebody will do that someday and we'll need to raise this.
|
||||
*/
|
||||
if (tmpesrt.fw_resource_count > 128) {
|
||||
pr_err("ESRT says fw_resource_count has very large value %d.\n",
|
||||
tmpesrt.fw_resource_count);
|
||||
goto err_memunmap;
|
||||
}
|
||||
|
||||
/*
|
||||
* We know it can't be larger than N * sizeof() here, and N is limited
|
||||
* by the previous test to a small number, so there's no overflow.
|
||||
*/
|
||||
entries_size = tmpesrt.fw_resource_count * entry_size;
|
||||
if (max < size + entries_size) {
|
||||
pr_err("ESRT does not fit on single memory map entry (size: %zu max: %zu)\n",
|
||||
size, max);
|
||||
goto err_memunmap;
|
||||
}
|
||||
|
||||
/* remap it with our (plausible) new pages */
|
||||
early_memunmap(va, size);
|
||||
size += entries_size;
|
||||
va = early_memremap(efi.esrt, size);
|
||||
if (!va) {
|
||||
pr_err("early_memremap(%p, %zu) failed.\n", (void *)efi.esrt,
|
||||
size);
|
||||
return;
|
||||
}
|
||||
|
||||
esrt_data = (phys_addr_t)efi.esrt;
|
||||
esrt_data_size = size;
|
||||
|
||||
end = esrt_data + size;
|
||||
pr_info("Reserving ESRT space from %pa to %pa.\n", &esrt_data, &end);
|
||||
memblock_reserve(esrt_data, esrt_data_size);
|
||||
|
||||
pr_debug("esrt-init: loaded.\n");
|
||||
err_memunmap:
|
||||
early_memunmap(va, size);
|
||||
}
|
||||
|
||||
static int __init register_entries(void)
|
||||
{
|
||||
struct efi_system_resource_entry_v1 *v1_entries = (void *)esrt->entries;
|
||||
int i, rc;
|
||||
|
||||
if (!esrt_table_exists())
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < le32_to_cpu(esrt->fw_resource_count); i++) {
|
||||
void *esre = NULL;
|
||||
if (esrt->fw_resource_version == 1) {
|
||||
esre = &v1_entries[i];
|
||||
} else {
|
||||
pr_err("Unsupported ESRT version %lld.\n",
|
||||
esrt->fw_resource_version);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
rc = esre_create_sysfs_entry(esre, i);
|
||||
if (rc < 0) {
|
||||
pr_err("ESRT entry creation failed with error %d.\n",
|
||||
rc);
|
||||
return rc;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cleanup_entry_list(void)
|
||||
{
|
||||
struct esre_entry *entry, *next;
|
||||
|
||||
list_for_each_entry_safe(entry, next, &entry_list, list) {
|
||||
kobject_put(&entry->kobj);
|
||||
}
|
||||
}
|
||||
|
||||
static int __init esrt_sysfs_init(void)
|
||||
{
|
||||
int error;
|
||||
struct efi_system_resource_table __iomem *ioesrt;
|
||||
|
||||
pr_debug("esrt-sysfs: loading.\n");
|
||||
if (!esrt_data || !esrt_data_size)
|
||||
return -ENOSYS;
|
||||
|
||||
ioesrt = ioremap(esrt_data, esrt_data_size);
|
||||
if (!ioesrt) {
|
||||
pr_err("ioremap(%pa, %zu) failed.\n", &esrt_data,
|
||||
esrt_data_size);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
esrt = kmalloc(esrt_data_size, GFP_KERNEL);
|
||||
if (!esrt) {
|
||||
pr_err("kmalloc failed. (wanted %zu bytes)\n", esrt_data_size);
|
||||
iounmap(ioesrt);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
memcpy_fromio(esrt, ioesrt, esrt_data_size);
|
||||
|
||||
esrt_kobj = kobject_create_and_add("esrt", efi_kobj);
|
||||
if (!esrt_kobj) {
|
||||
pr_err("Firmware table registration failed.\n");
|
||||
error = -ENOMEM;
|
||||
goto err;
|
||||
}
|
||||
|
||||
error = sysfs_create_group(esrt_kobj, &esrt_attr_group);
|
||||
if (error) {
|
||||
pr_err("Sysfs attribute export failed with error %d.\n",
|
||||
error);
|
||||
goto err_remove_esrt;
|
||||
}
|
||||
|
||||
esrt_kset = kset_create_and_add("entries", NULL, esrt_kobj);
|
||||
if (!esrt_kset) {
|
||||
pr_err("kset creation failed.\n");
|
||||
error = -ENOMEM;
|
||||
goto err_remove_group;
|
||||
}
|
||||
|
||||
error = register_entries();
|
||||
if (error)
|
||||
goto err_cleanup_list;
|
||||
|
||||
memblock_remove(esrt_data, esrt_data_size);
|
||||
|
||||
pr_debug("esrt-sysfs: loaded.\n");
|
||||
|
||||
return 0;
|
||||
err_cleanup_list:
|
||||
cleanup_entry_list();
|
||||
kset_unregister(esrt_kset);
|
||||
err_remove_group:
|
||||
sysfs_remove_group(esrt_kobj, &esrt_attr_group);
|
||||
err_remove_esrt:
|
||||
kobject_put(esrt_kobj);
|
||||
err:
|
||||
kfree(esrt);
|
||||
esrt = NULL;
|
||||
return error;
|
||||
}
|
||||
|
||||
static void __exit esrt_sysfs_exit(void)
|
||||
{
|
||||
pr_debug("esrt-sysfs: unloading.\n");
|
||||
cleanup_entry_list();
|
||||
kset_unregister(esrt_kset);
|
||||
sysfs_remove_group(esrt_kobj, &esrt_attr_group);
|
||||
kfree(esrt);
|
||||
esrt = NULL;
|
||||
kobject_del(esrt_kobj);
|
||||
kobject_put(esrt_kobj);
|
||||
}
|
||||
|
||||
module_init(esrt_sysfs_init);
|
||||
module_exit(esrt_sysfs_exit);
|
||||
|
||||
MODULE_AUTHOR("Peter Jones <pjones@redhat.com>");
|
||||
MODULE_DESCRIPTION("EFI System Resource Table support");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
@ -583,6 +583,9 @@ void efi_native_runtime_setup(void);
|
|||
#define EFI_FILE_INFO_ID \
|
||||
EFI_GUID( 0x9576e92, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b )
|
||||
|
||||
#define EFI_SYSTEM_RESOURCE_TABLE_GUID \
|
||||
EFI_GUID( 0xb122a263, 0x3661, 0x4f68, 0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80 )
|
||||
|
||||
#define EFI_FILE_SYSTEM_GUID \
|
||||
EFI_GUID( 0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b )
|
||||
|
||||
|
|
@ -823,6 +826,7 @@ extern struct efi {
|
|||
unsigned long fw_vendor; /* fw_vendor */
|
||||
unsigned long runtime; /* runtime table */
|
||||
unsigned long config_table; /* config tables */
|
||||
unsigned long esrt; /* ESRT table */
|
||||
efi_get_time_t *get_time;
|
||||
efi_set_time_t *set_time;
|
||||
efi_get_wakeup_time_t *get_wakeup_time;
|
||||
|
|
@ -875,6 +879,11 @@ static inline efi_status_t efi_query_variable_store(u32 attributes, unsigned lon
|
|||
#endif
|
||||
extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
|
||||
extern int efi_config_init(efi_config_table_type_t *arch_tables);
|
||||
#ifdef CONFIG_EFI_ESRT
|
||||
extern void __init efi_esrt_init(void);
|
||||
#else
|
||||
static inline void efi_esrt_init(void) { }
|
||||
#endif
|
||||
extern int efi_config_parse_tables(void *config_tables, int count, int sz,
|
||||
efi_config_table_type_t *arch_tables);
|
||||
extern u64 efi_get_iobase (void);
|
||||
|
|
@ -882,12 +891,15 @@ extern u32 efi_mem_type (unsigned long phys_addr);
|
|||
extern u64 efi_mem_attributes (unsigned long phys_addr);
|
||||
extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);
|
||||
extern int __init efi_uart_console_only (void);
|
||||
extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
|
||||
extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
|
||||
extern void efi_initialize_iomem_resources(struct resource *code_resource,
|
||||
struct resource *data_resource, struct resource *bss_resource);
|
||||
extern void efi_get_time(struct timespec *now);
|
||||
extern void efi_reserve_boot_services(void);
|
||||
extern int efi_get_fdt_params(struct efi_fdt_params *params, int verbose);
|
||||
extern struct efi_memory_map memmap;
|
||||
extern struct kobject *efi_kobj;
|
||||
|
||||
extern int efi_reboot_quirk_mode;
|
||||
extern bool efi_poweroff_required(void);
|
||||
|
|
|
|||
Loading…
Reference in New Issue