blob: 833cbb995dd3f2bb1d447ecccd457aa03a3738a7 [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0+
#include <linux/efi.h>
#include <linux/module.h>
#include <linux/pstore.h>
#include <linux/slab.h>
#include <linux/ucs2_string.h>
MODULE_IMPORT_NS(EFIVAR);
#define DUMP_NAME_LEN 66
static unsigned int record_size = 1024;
module_param(record_size, uint, 0444);
MODULE_PARM_DESC(record_size, "size of each pstore UEFI var (in bytes, min/default=1024)");
#define PSTORE_EFI_ATTRIBUTES \
(EFI_VARIABLE_NON_VOLATILE | \
EFI_VARIABLE_BOOTSERVICE_ACCESS | \
EFI_VARIABLE_RUNTIME_ACCESS)
static bool pstore_disable = IS_ENABLED(CONFIG_EFI_VARS_PSTORE_DEFAULT_DISABLE);
static int efivars_pstore_init(void);
static void efivars_pstore_exit(void);
static int efi_pstore_disable_set(const char *val, const struct kernel_param *kp)
{
int err;
bool old_pstore_disable = pstore_disable;
err = param_set_bool(val, kp);
if (err)
return err;
if (old_pstore_disable != pstore_disable) {
if (pstore_disable)
efivars_pstore_exit();
else
efivars_pstore_init();
}
return 0;
}
static const struct kernel_param_ops pstore_disable_ops = {
.set = efi_pstore_disable_set,
.get = param_get_bool,
};
module_param_cb(pstore_disable, &pstore_disable_ops, &pstore_disable, 0644);
__MODULE_PARM_TYPE(pstore_disable, "bool");
static int efi_pstore_open(struct pstore_info *psi)
{
int err;
err = efivar_lock();
if (err)
return err;
psi->data = kzalloc(record_size, GFP_KERNEL);
if (!psi->data)
return -ENOMEM;
return 0;
}
static int efi_pstore_close(struct pstore_info *psi)
{
efivar_unlock();
kfree(psi->data);
return 0;
}
static inline u64 generic_id(u64 timestamp, unsigned int part, int count)
{
return (timestamp * 100 + part) * 1000 + count;
}
static int efi_pstore_read_func(struct pstore_record *record,
efi_char16_t *varname)
{
unsigned long wlen, size = record_size;
char name[DUMP_NAME_LEN], data_type;
efi_status_t status;
int cnt;
unsigned int part;
u64 time;
ucs2_as_utf8(name, varname, DUMP_NAME_LEN);
if (sscanf(name, "dump-type%u-%u-%d-%llu-%c",
&record->type, &part, &cnt, &time, &data_type) == 5) {
record->id = generic_id(time, part, cnt);
record->part = part;
record->count = cnt;
record->time.tv_sec = time;
record->time.tv_nsec = 0;
if (data_type == 'C')
record->compressed = true;
else
record->compressed = false;
record->ecc_notice_size = 0;
} else if (sscanf(name, "dump-type%u-%u-%d-%llu",
&record->type, &part, &cnt, &time) == 4) {
record->id = generic_id(time, part, cnt);
record->part = part;
record->count = cnt;
record->time.tv_sec = time;
record->time.tv_nsec = 0;
record->compressed = false;
record->ecc_notice_size = 0;
} else if (sscanf(name, "dump-type%u-%u-%llu",
&record->type, &part, &time) == 3) {
/*
* Check if an old format,
* which doesn't support holding
* multiple logs, remains.
*/
record->id = generic_id(time, part, 0);
record->part = part;
record->count = 0;
record->time.tv_sec = time;
record->time.tv_nsec = 0;
record->compressed = false;
record->ecc_notice_size = 0;
} else
return 0;
record->buf = kmalloc(size, GFP_KERNEL);
if (!record->buf)
return -ENOMEM;
status = efivar_get_variable(varname, &LINUX_EFI_CRASH_GUID, NULL,
&size, record->buf);
if (status != EFI_SUCCESS) {
kfree(record->buf);
return -EIO;
}
/*
* Store the name of the variable in the pstore_record priv field, so
* we can reuse it later if we need to delete the EFI variable from the
* variable store.
*/
wlen = (ucs2_strnlen(varname, DUMP_NAME_LEN) + 1) * sizeof(efi_char16_t);
record->priv = kmemdup(varname, wlen, GFP_KERNEL);
if (!record->priv) {
kfree(record->buf);
return -ENOMEM;
}
return size;
}
static ssize_t efi_pstore_read(struct pstore_record *record)
{
efi_char16_t *varname = record->psi->data;
efi_guid_t guid = LINUX_EFI_CRASH_GUID;
unsigned long varname_size;
efi_status_t status;
for (;;) {
varname_size = 1024;
/*
* If this is the first read() call in the pstore enumeration,
* varname will be the empty string, and the GetNextVariable()
* runtime service call will return the first EFI variable in
* its own enumeration order, ignoring the guid argument.
*
* Subsequent calls to GetNextVariable() must pass the name and
* guid values returned by the previous call, which is why we
* store varname in record->psi->data. Given that we only
* enumerate variables with the efi-pstore GUID, there is no
* need to record the guid return value.
*/
status = efivar_get_next_variable(&varname_size, varname, &guid);
if (status == EFI_NOT_FOUND)
return 0;
if (status != EFI_SUCCESS)
return -EIO;
/* skip variables that don't concern us */
if (efi_guidcmp(guid, LINUX_EFI_CRASH_GUID))
continue;
return efi_pstore_read_func(record, varname);
}
}
static int efi_pstore_write(struct pstore_record *record)
{
char name[DUMP_NAME_LEN];
efi_char16_t efi_name[DUMP_NAME_LEN];
efi_status_t status;
int i;
record->id = generic_id(record->time.tv_sec, record->part,
record->count);
/* Since we copy the entire length of name, make sure it is wiped. */
memset(name, 0, sizeof(name));
snprintf(name, sizeof(name), "dump-type%u-%u-%d-%lld-%c",
record->type, record->part, record->count,
(long long)record->time.tv_sec,
record->compressed ? 'C' : 'D');
for (i = 0; i < DUMP_NAME_LEN; i++)
efi_name[i] = name[i];
if (efivar_trylock())
return -EBUSY;
status = efivar_set_variable_locked(efi_name, &LINUX_EFI_CRASH_GUID,
PSTORE_EFI_ATTRIBUTES,
record->size, record->psi->buf,
true);
efivar_unlock();
return status == EFI_SUCCESS ? 0 : -EIO;
};
static int efi_pstore_erase(struct pstore_record *record)
{
efi_status_t status;
status = efivar_set_variable(record->priv, &LINUX_EFI_CRASH_GUID,
PSTORE_EFI_ATTRIBUTES, 0, NULL);
if (status != EFI_SUCCESS && status != EFI_NOT_FOUND)
return -EIO;
return 0;
}
static struct pstore_info efi_pstore_info = {
.owner = THIS_MODULE,
.name = KBUILD_MODNAME,
.flags = PSTORE_FLAGS_DMESG,
.open = efi_pstore_open,
.close = efi_pstore_close,
.read = efi_pstore_read,
.write = efi_pstore_write,
.erase = efi_pstore_erase,
};
static int efivars_pstore_init(void)
{
if (!efivar_supports_writes())
return 0;
if (pstore_disable)
return 0;
/*
* Notice that 1024 is the minimum here to prevent issues with
* decompression algorithms that were spotted during tests;
* even in the case of not using compression, smaller values would
* just pollute more the pstore FS with many small collected files.
*/
if (record_size < 1024)
record_size = 1024;
efi_pstore_info.buf = kmalloc(record_size, GFP_KERNEL);
if (!efi_pstore_info.buf)
return -ENOMEM;
efi_pstore_info.bufsize = record_size;
if (pstore_register(&efi_pstore_info)) {
kfree(efi_pstore_info.buf);
efi_pstore_info.buf = NULL;
efi_pstore_info.bufsize = 0;
}
return 0;
}
static void efivars_pstore_exit(void)
{
if (!efi_pstore_info.bufsize)
return;
pstore_unregister(&efi_pstore_info);
kfree(efi_pstore_info.buf);
efi_pstore_info.buf = NULL;
efi_pstore_info.bufsize = 0;
}
module_init(efivars_pstore_init);
module_exit(efivars_pstore_exit);
MODULE_DESCRIPTION("EFI variable backend for pstore");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:efivars");