[mirror_ubuntu-bionic-kernel.git] / drivers / firmware / efi / efi-pstore.c

#include <linux/efi.h>
#include <linux/module.h>
#include <linux/pstore.h>
#include <linux/slab.h>
#include <linux/ucs2_string.h>

#define DUMP_NAME_LEN 52

static bool efivars_pstore_disable =
	IS_ENABLED(CONFIG_EFI_VARS_PSTORE_DEFAULT_DISABLE);

module_param_named(pstore_disable, efivars_pstore_disable, bool, 0644);

#define PSTORE_EFI_ATTRIBUTES \
	(EFI_VARIABLE_NON_VOLATILE | \
	 EFI_VARIABLE_BOOTSERVICE_ACCESS | \
	 EFI_VARIABLE_RUNTIME_ACCESS)

static int efi_pstore_open(struct pstore_info *psi)
{
	psi->data = NULL;
	return 0;
}

static int efi_pstore_close(struct pstore_info *psi)
{
	psi->data = NULL;
	return 0;
}

static inline u64 generic_id(unsigned long timestamp,
			     unsigned int part, int count)
{
	return ((u64) timestamp * 100 + part) * 1000 + count;
}

static int efi_pstore_read_func(struct efivar_entry *entry,
				struct pstore_record *record)
{
	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
	char name[DUMP_NAME_LEN], data_type;
	int i;
	int cnt;
	unsigned int part;
	unsigned long time, size;

	if (efi_guidcmp(entry->var.VendorGuid, vendor))
		return 0;

	for (i = 0; i < DUMP_NAME_LEN; i++)
		name[i] = entry->var.VariableName[i];

	if (sscanf(name, "dump-type%u-%u-%d-%lu-%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-%lu",
		   &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-%lu",
			  &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;

	entry->var.DataSize = 1024;
	__efivar_entry_get(entry, &entry->var.Attributes,
			   &entry->var.DataSize, entry->var.Data);
	size = entry->var.DataSize;
	memcpy(record->buf, entry->var.Data,
	       (size_t)min_t(unsigned long, EFIVARS_DATA_SIZE_MAX, size));

	return size;
}

/**
 * efi_pstore_scan_sysfs_enter
 * @pos: scanning entry
 * @next: next entry
 * @head: list head
 */
static void efi_pstore_scan_sysfs_enter(struct efivar_entry *pos,
					struct efivar_entry *next,
					struct list_head *head)
{
	pos->scanning = true;
	if (&next->list != head)
		next->scanning = true;
}

/**
 * __efi_pstore_scan_sysfs_exit
 * @entry: deleting entry
 * @turn_off_scanning: Check if a scanning flag should be turned off
 */
static inline int __efi_pstore_scan_sysfs_exit(struct efivar_entry *entry,
						bool turn_off_scanning)
{
	if (entry->deleting) {
		list_del(&entry->list);
		efivar_entry_iter_end();
		efivar_unregister(entry);
		if (efivar_entry_iter_begin())
			return -EINTR;
	} else if (turn_off_scanning)
		entry->scanning = false;

	return 0;
}

/**
 * efi_pstore_scan_sysfs_exit
 * @pos: scanning entry
 * @next: next entry
 * @head: list head
 * @stop: a flag checking if scanning will stop
 */
static int efi_pstore_scan_sysfs_exit(struct efivar_entry *pos,
				       struct efivar_entry *next,
				       struct list_head *head, bool stop)
{
	int ret = __efi_pstore_scan_sysfs_exit(pos, true);

	if (ret)
		return ret;

	if (stop)
		ret = __efi_pstore_scan_sysfs_exit(next, &next->list != head);
	return ret;
}

/**
 * efi_pstore_sysfs_entry_iter
 *
 * @record: pstore record to pass to callback
 *
 * You MUST call efivar_enter_iter_begin() before this function, and
 * efivar_entry_iter_end() afterwards.
 *
 */
static int efi_pstore_sysfs_entry_iter(struct pstore_record *record)
{
	struct efivar_entry **pos = (struct efivar_entry **)&record->psi->data;
	struct efivar_entry *entry, *n;
	struct list_head *head = &efivar_sysfs_list;
	int size = 0;
	int ret;

	if (!*pos) {
		list_for_each_entry_safe(entry, n, head, list) {
			efi_pstore_scan_sysfs_enter(entry, n, head);

			size = efi_pstore_read_func(entry, record);
			ret = efi_pstore_scan_sysfs_exit(entry, n, head,
							 size < 0);
			if (ret)
				return ret;
			if (size)
				break;
		}
		*pos = n;
		return size;
	}

	list_for_each_entry_safe_from((*pos), n, head, list) {
		efi_pstore_scan_sysfs_enter((*pos), n, head);

		size = efi_pstore_read_func((*pos), record);
		ret = efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0);
		if (ret)
			return ret;
		if (size)
			break;
	}
	*pos = n;
	return size;
}

/**
 * efi_pstore_read
 *
 * This function returns a size of NVRAM entry logged via efi_pstore_write().
 * The meaning and behavior of efi_pstore/pstore are as below.
 *
 * size > 0: Got data of an entry logged via efi_pstore_write() successfully,
 *           and pstore filesystem will continue reading subsequent entries.
 * size == 0: Entry was not logged via efi_pstore_write(),
 *            and efi_pstore driver will continue reading subsequent entries.
 * size < 0: Failed to get data of entry logging via efi_pstore_write(),
 *           and pstore will stop reading entry.
 */
static ssize_t efi_pstore_read(struct pstore_record *record)
{
	ssize_t size;

	record->buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL);
	if (!record->buf)
		return -ENOMEM;

	if (efivar_entry_iter_begin()) {
		size = -EINTR;
		goto out;
	}
	size = efi_pstore_sysfs_entry_iter(record);
	efivar_entry_iter_end();

out:
	if (size <= 0) {
		kfree(record->buf);
		record->buf = NULL;
	}
	return size;
}

static int efi_pstore_write(struct pstore_record *record)
{
	char name[DUMP_NAME_LEN];
	efi_char16_t efi_name[DUMP_NAME_LEN];
	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
	int i, ret = 0;

	record->time.tv_sec = get_seconds();
	record->time.tv_nsec = 0;

	record->id = generic_id(record->time.tv_sec, record->part,
				record->count);

	snprintf(name, sizeof(name), "dump-type%u-%u-%d-%lu-%c",
		 record->type, record->part, record->count,
		 record->time.tv_sec, record->compressed ? 'C' : 'D');

	for (i = 0; i < DUMP_NAME_LEN; i++)
		efi_name[i] = name[i];

	ret = efivar_entry_set_safe(efi_name, vendor, PSTORE_EFI_ATTRIBUTES,
			      !pstore_cannot_block_path(record->reason),
			      record->size, record->psi->buf);

	if (record->reason == KMSG_DUMP_OOPS)
		efivar_run_worker();

	return ret;
};

struct pstore_erase_data {
	struct pstore_record *record;
	efi_char16_t *name;
};

/*
 * Clean up an entry with the same name
 */
static int efi_pstore_erase_func(struct efivar_entry *entry, void *data)
{
	struct pstore_erase_data *ed = data;
	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
	efi_char16_t efi_name_old[DUMP_NAME_LEN];
	efi_char16_t *efi_name = ed->name;
	unsigned long ucs2_len = ucs2_strlen(ed->name);
	char name_old[DUMP_NAME_LEN];
	int i;

	if (efi_guidcmp(entry->var.VendorGuid, vendor))
		return 0;

	if (ucs2_strncmp(entry->var.VariableName,
			  efi_name, (size_t)ucs2_len)) {
		/*
		 * Check if an old format, which doesn't support
		 * holding multiple logs, remains.
		 */
		snprintf(name_old, sizeof(name_old), "dump-type%u-%u-%lu",
			ed->record->type, ed->record->part,
			ed->record->time.tv_sec);

		for (i = 0; i < DUMP_NAME_LEN; i++)
			efi_name_old[i] = name_old[i];

		if (ucs2_strncmp(entry->var.VariableName, efi_name_old,
				  ucs2_strlen(efi_name_old)))
			return 0;
	}

	if (entry->scanning) {
		/*
		 * Skip deletion because this entry will be deleted
		 * after scanning is completed.
		 */
		entry->deleting = true;
	} else
		list_del(&entry->list);

	/* found */
	__efivar_entry_delete(entry);

	return 1;
}

static int efi_pstore_erase(struct pstore_record *record)
{
	struct pstore_erase_data edata;
	struct efivar_entry *entry = NULL;
	char name[DUMP_NAME_LEN];
	efi_char16_t efi_name[DUMP_NAME_LEN];
	int found, i;

	snprintf(name, sizeof(name), "dump-type%u-%u-%d-%lu",
		 record->type, record->part, record->count,
		 record->time.tv_sec);

	for (i = 0; i < DUMP_NAME_LEN; i++)
		efi_name[i] = name[i];

	edata.record = record;
	edata.name = efi_name;

	if (efivar_entry_iter_begin())
		return -EINTR;
	found = __efivar_entry_iter(efi_pstore_erase_func, &efivar_sysfs_list, &edata, &entry);

	if (found && !entry->scanning) {
		efivar_entry_iter_end();
		efivar_unregister(entry);
	} else
		efivar_entry_iter_end();

	return 0;
}

static struct pstore_info efi_pstore_info = {
	.owner		= THIS_MODULE,
	.name		= "efi",
	.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 __init int efivars_pstore_init(void)
{
	if (!efi_enabled(EFI_RUNTIME_SERVICES))
		return 0;

	if (!efivars_kobject())
		return 0;

	if (efivars_pstore_disable)
		return 0;

	efi_pstore_info.buf = kmalloc(4096, GFP_KERNEL);
	if (!efi_pstore_info.buf)
		return -ENOMEM;

	efi_pstore_info.bufsize = 1024;
	spin_lock_init(&efi_pstore_info.buf_lock);

	if (pstore_register(&efi_pstore_info)) {
		kfree(efi_pstore_info.buf);
		efi_pstore_info.buf = NULL;
		efi_pstore_info.bufsize = 0;
	}

	return 0;
}

static __exit 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");
Commit	Line	Data
04851772 MF	1	#include <linux/efi.h>
	2	#include <linux/module.h>
	3	#include <linux/pstore.h>
20b4fb48	4	#include <linux/slab.h>
a614e192	5	#include <linux/ucs2_string.h>
04851772 MF	6
	7	#define DUMP_NAME_LEN 52
	8
	9	static bool efivars_pstore_disable =
	10	IS_ENABLED(CONFIG_EFI_VARS_PSTORE_DEFAULT_DISABLE);
	11
	12	module_param_named(pstore_disable, efivars_pstore_disable, bool, 0644);
	13
	14	#define PSTORE_EFI_ATTRIBUTES \
	15	(EFI_VARIABLE_NON_VOLATILE \| \
	16	EFI_VARIABLE_BOOTSERVICE_ACCESS \| \
	17	EFI_VARIABLE_RUNTIME_ACCESS)
	18
	19	static int efi_pstore_open(struct pstore_info *psi)
	20	{
04851772 MF	21	psi->data = NULL;
	22	return 0;
	23	}
	24
	25	static int efi_pstore_close(struct pstore_info *psi)
	26	{
04851772 MF	27	psi->data = NULL;
	28	return 0;
	29	}
	30
fdeadb43 MX	31	static inline u64 generic_id(unsigned long timestamp,
	32	unsigned int part, int count)
	33	{
783ee431	34	return ((u64) timestamp * 100 + part) * 1000 + count;
fdeadb43 MX	35	}
fdeadb43 MX	36
125cc42b KC	37	static int efi_pstore_read_func(struct efivar_entry *entry,
125cc42b KC	38	struct pstore_record *record)
04851772 MF	39	{
04851772 MF	40	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
f8c62f34	41	char name[DUMP_NAME_LEN], data_type;
04851772 MF	42	int i;
	43	int cnt;
	44	unsigned int part;
	45	unsigned long time, size;
	46
	47	if (efi_guidcmp(entry->var.VendorGuid, vendor))
	48	return 0;
	49
	50	for (i = 0; i < DUMP_NAME_LEN; i++)
	51	name[i] = entry->var.VariableName[i];
	52
f8c62f34	53	if (sscanf(name, "dump-type%u-%u-%d-%lu-%c",
125cc42b KC	54	&record->type, &part, &cnt, &time, &data_type) == 5) {
125cc42b KC	55	record->id = generic_id(time, part, cnt);
c10e8031	56	record->part = part;
125cc42b KC	57	record->count = cnt;
	58	record->time.tv_sec = time;
	59	record->time.tv_nsec = 0;
f8c62f34	60	if (data_type == 'C')
125cc42b	61	record->compressed = true;
f8c62f34	62	else
125cc42b KC	63	record->compressed = false;
125cc42b KC	64	record->ecc_notice_size = 0;
f8c62f34	65	} else if (sscanf(name, "dump-type%u-%u-%d-%lu",
125cc42b KC	66	&record->type, &part, &cnt, &time) == 4) {
125cc42b KC	67	record->id = generic_id(time, part, cnt);
c10e8031	68	record->part = part;
125cc42b KC	69	record->count = cnt;
	70	record->time.tv_sec = time;
	71	record->time.tv_nsec = 0;
	72	record->compressed = false;
	73	record->ecc_notice_size = 0;
04851772	74	} else if (sscanf(name, "dump-type%u-%u-%lu",
125cc42b	75	&record->type, &part, &time) == 3) {
04851772 MF	76	/*
	77	* Check if an old format,
	78	* which doesn't support holding
	79	* multiple logs, remains.
	80	*/
125cc42b	81	record->id = generic_id(time, part, 0);
c10e8031	82	record->part = part;
125cc42b KC	83	record->count = 0;
	84	record->time.tv_sec = time;
	85	record->time.tv_nsec = 0;
	86	record->compressed = false;
	87	record->ecc_notice_size = 0;
04851772 MF	88	} else
	89	return 0;
	90
8a415b8c MF	91	entry->var.DataSize = 1024;
	92	__efivar_entry_get(entry, &entry->var.Attributes,
	93	&entry->var.DataSize, entry->var.Data);
	94	size = entry->var.DataSize;
125cc42b	95	memcpy(record->buf, entry->var.Data,
e0d59733	96	(size_t)min_t(unsigned long, EFIVARS_DATA_SIZE_MAX, size));
8a415b8c	97
04851772 MF	98	return size;
	99	}
	100
e0d59733 SA	101	/**
e0d59733 SA	102	* efi_pstore_scan_sysfs_enter
a07e7449	103	* @pos: scanning entry
e0d59733 SA	104	* @next: next entry
	105	* @head: list head
	106	*/
	107	static void efi_pstore_scan_sysfs_enter(struct efivar_entry *pos,
	108	struct efivar_entry *next,
	109	struct list_head *head)
	110	{
	111	pos->scanning = true;
	112	if (&next->list != head)
	113	next->scanning = true;
	114	}
	115
	116	/**
	117	* __efi_pstore_scan_sysfs_exit
	118	* @entry: deleting entry
	119	* @turn_off_scanning: Check if a scanning flag should be turned off
	120	*/
21b3ddd3	121	static inline int __efi_pstore_scan_sysfs_exit(struct efivar_entry *entry,
e0d59733 SA	122	bool turn_off_scanning)
	123	{
	124	if (entry->deleting) {
	125	list_del(&entry->list);
	126	efivar_entry_iter_end();
	127	efivar_unregister(entry);
21b3ddd3 SC	128	if (efivar_entry_iter_begin())
21b3ddd3 SC	129	return -EINTR;
e0d59733 SA	130	} else if (turn_off_scanning)
e0d59733 SA	131	entry->scanning = false;
21b3ddd3 SC	132
21b3ddd3 SC	133	return 0;
e0d59733 SA	134	}
	135
	136	/**
	137	* efi_pstore_scan_sysfs_exit
	138	* @pos: scanning entry
	139	* @next: next entry
	140	* @head: list head
	141	* @stop: a flag checking if scanning will stop
	142	*/
21b3ddd3	143	static int efi_pstore_scan_sysfs_exit(struct efivar_entry *pos,
e0d59733 SA	144	struct efivar_entry *next,
	145	struct list_head *head, bool stop)
	146	{
21b3ddd3 SC	147	int ret = __efi_pstore_scan_sysfs_exit(pos, true);
	148
	149	if (ret)
	150	return ret;
	151
e0d59733	152	if (stop)
21b3ddd3 SC	153	ret = __efi_pstore_scan_sysfs_exit(next, &next->list != head);
21b3ddd3 SC	154	return ret;
e0d59733 SA	155	}
	156
	157	/**
	158	* efi_pstore_sysfs_entry_iter
	159	*
125cc42b	160	* @record: pstore record to pass to callback
e0d59733 SA	161	*
	162	* You MUST call efivar_enter_iter_begin() before this function, and
	163	* efivar_entry_iter_end() afterwards.
	164	*
e0d59733	165	*/
6f61dd3a	166	static int efi_pstore_sysfs_entry_iter(struct pstore_record *record)
e0d59733	167	{
6f61dd3a	168	struct efivar_entry pos = (struct efivar_entry )&record->psi->data;
e0d59733 SA	169	struct efivar_entry entry, n;
	170	struct list_head *head = &efivar_sysfs_list;
	171	int size = 0;
21b3ddd3	172	int ret;
e0d59733 SA	173
	174	if (!*pos) {
	175	list_for_each_entry_safe(entry, n, head, list) {
	176	efi_pstore_scan_sysfs_enter(entry, n, head);
	177
125cc42b	178	size = efi_pstore_read_func(entry, record);
21b3ddd3 SC	179	ret = efi_pstore_scan_sysfs_exit(entry, n, head,
	180	size < 0);
	181	if (ret)
	182	return ret;
e0d59733 SA	183	if (size)
	184	break;
	185	}
	186	*pos = n;
	187	return size;
	188	}
	189
	190	list_for_each_entry_safe_from((*pos), n, head, list) {
	191	efi_pstore_scan_sysfs_enter((*pos), n, head);
	192
125cc42b	193	size = efi_pstore_read_func((*pos), record);
21b3ddd3 SC	194	ret = efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0);
	195	if (ret)
	196	return ret;
e0d59733 SA	197	if (size)
	198	break;
	199	}
	200	*pos = n;
	201	return size;
	202	}
	203
	204	/**
	205	* efi_pstore_read
	206	*
	207	* This function returns a size of NVRAM entry logged via efi_pstore_write().
	208	* The meaning and behavior of efi_pstore/pstore are as below.
	209	*
	210	* size > 0: Got data of an entry logged via efi_pstore_write() successfully,
	211	* and pstore filesystem will continue reading subsequent entries.
	212	* size == 0: Entry was not logged via efi_pstore_write(),
	213	* and efi_pstore driver will continue reading subsequent entries.
	214	* size < 0: Failed to get data of entry logging via efi_pstore_write(),
	215	* and pstore will stop reading entry.
	216	*/
125cc42b	217	static ssize_t efi_pstore_read(struct pstore_record *record)
04851772	218	{
e0d59733	219	ssize_t size;
04851772	220
125cc42b KC	221	record->buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL);
125cc42b KC	222	if (!record->buf)
e0d59733 SA	223	return -ENOMEM;
e0d59733 SA	224
21b3ddd3	225	if (efivar_entry_iter_begin()) {
125cc42b KC	226	size = -EINTR;
125cc42b KC	227	goto out;
21b3ddd3	228	}
6f61dd3a	229	size = efi_pstore_sysfs_entry_iter(record);
e0d59733	230	efivar_entry_iter_end();
125cc42b KC	231
	232	out:
	233	if (size <= 0) {
	234	kfree(record->buf);
	235	record->buf = NULL;
	236	}
e0d59733	237	return size;
04851772 MF	238	}
04851772 MF	239
76cc9580	240	static int efi_pstore_write(struct pstore_record *record)
04851772 MF	241	{
	242	char name[DUMP_NAME_LEN];
	243	efi_char16_t efi_name[DUMP_NAME_LEN];
	244	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
	245	int i, ret = 0;
	246
c10e8031 KC	247	record->time.tv_sec = get_seconds();
	248	record->time.tv_nsec = 0;
	249
	250	record->id = generic_id(record->time.tv_sec, record->part,
	251	record->count);
	252
76cc9580 KC	253	snprintf(name, sizeof(name), "dump-type%u-%u-%d-%lu-%c",
76cc9580 KC	254	record->type, record->part, record->count,
c10e8031	255	record->time.tv_sec, record->compressed ? 'C' : 'D');
04851772 MF	256
	257	for (i = 0; i < DUMP_NAME_LEN; i++)
	258	efi_name[i] = name[i];
	259
fee929ba	260	ret = efivar_entry_set_safe(efi_name, vendor, PSTORE_EFI_ATTRIBUTES,
76cc9580 KC	261	!pstore_cannot_block_path(record->reason),
76cc9580 KC	262	record->size, record->psi->buf);
04851772	263
76cc9580	264	if (record->reason == KMSG_DUMP_OOPS)
04851772 MF	265	efivar_run_worker();
04851772 MF	266
04851772 MF	267	return ret;
	268	};
	269
	270	struct pstore_erase_data {
a61072aa	271	struct pstore_record *record;
04851772 MF	272	efi_char16_t *name;
	273	};
	274
	275	/*
	276	* Clean up an entry with the same name
	277	*/
	278	static int efi_pstore_erase_func(struct efivar_entry entry, void data)
	279	{
	280	struct pstore_erase_data *ed = data;
	281	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
	282	efi_char16_t efi_name_old[DUMP_NAME_LEN];
	283	efi_char16_t *efi_name = ed->name;
a614e192	284	unsigned long ucs2_len = ucs2_strlen(ed->name);
04851772 MF	285	char name_old[DUMP_NAME_LEN];
	286	int i;
	287
	288	if (efi_guidcmp(entry->var.VendorGuid, vendor))
	289	return 0;
	290
a614e192 MF	291	if (ucs2_strncmp(entry->var.VariableName,
a614e192 MF	292	efi_name, (size_t)ucs2_len)) {
04851772 MF	293	/*
	294	* Check if an old format, which doesn't support
	295	* holding multiple logs, remains.
	296	*/
a61072aa	297	snprintf(name_old, sizeof(name_old), "dump-type%u-%u-%lu",
c10e8031	298	ed->record->type, ed->record->part,
a61072aa	299	ed->record->time.tv_sec);
04851772 MF	300
	301	for (i = 0; i < DUMP_NAME_LEN; i++)
	302	efi_name_old[i] = name_old[i];
	303
a614e192 MF	304	if (ucs2_strncmp(entry->var.VariableName, efi_name_old,
a614e192 MF	305	ucs2_strlen(efi_name_old)))
04851772 MF	306	return 0;
	307	}
	308
e0d59733 SA	309	if (entry->scanning) {
	310	/*
	311	* Skip deletion because this entry will be deleted
	312	* after scanning is completed.
	313	*/
	314	entry->deleting = true;
	315	} else
	316	list_del(&entry->list);
	317
04851772 MF	318	/* found */
04851772 MF	319	__efivar_entry_delete(entry);
12abcfde	320
04851772 MF	321	return 1;
	322	}
	323
a61072aa	324	static int efi_pstore_erase(struct pstore_record *record)
04851772 MF	325	{
04851772 MF	326	struct pstore_erase_data edata;
4ee39e97	327	struct efivar_entry *entry = NULL;
04851772 MF	328	char name[DUMP_NAME_LEN];
	329	efi_char16_t efi_name[DUMP_NAME_LEN];
	330	int found, i;
	331
a61072aa KC	332	snprintf(name, sizeof(name), "dump-type%u-%u-%d-%lu",
	333	record->type, record->part, record->count,
	334	record->time.tv_sec);
04851772 MF	335
	336	for (i = 0; i < DUMP_NAME_LEN; i++)
	337	efi_name[i] = name[i];
	338
a61072aa	339	edata.record = record;
04851772 MF	340	edata.name = efi_name;
04851772 MF	341
21b3ddd3 SC	342	if (efivar_entry_iter_begin())
21b3ddd3 SC	343	return -EINTR;
04851772	344	found = __efivar_entry_iter(efi_pstore_erase_func, &efivar_sysfs_list, &edata, &entry);
04851772	345
e0d59733 SA	346	if (found && !entry->scanning) {
e0d59733 SA	347	efivar_entry_iter_end();
04851772	348	efivar_unregister(entry);
e0d59733 SA	349	} else
e0d59733 SA	350	efivar_entry_iter_end();
04851772 MF	351
	352	return 0;
	353	}
	354
	355	static struct pstore_info efi_pstore_info = {
	356	.owner = THIS_MODULE,
	357	.name = "efi",
c950fd6f	358	.flags = PSTORE_FLAGS_DMESG,
04851772 MF	359	.open = efi_pstore_open,
	360	.close = efi_pstore_close,
	361	.read = efi_pstore_read,
	362	.write = efi_pstore_write,
	363	.erase = efi_pstore_erase,
	364	};
	365
	366	static __init int efivars_pstore_init(void)
	367	{
	368	if (!efi_enabled(EFI_RUNTIME_SERVICES))
	369	return 0;
	370
	371	if (!efivars_kobject())
	372	return 0;
	373
	374	if (efivars_pstore_disable)
	375	return 0;
	376
	377	efi_pstore_info.buf = kmalloc(4096, GFP_KERNEL);
	378	if (!efi_pstore_info.buf)
	379	return -ENOMEM;
	380
	381	efi_pstore_info.bufsize = 1024;
	382	spin_lock_init(&efi_pstore_info.buf_lock);
	383
0d838347 LS	384	if (pstore_register(&efi_pstore_info)) {
	385	kfree(efi_pstore_info.buf);
	386	efi_pstore_info.buf = NULL;
	387	efi_pstore_info.bufsize = 0;
	388	}
04851772 MF	389
	390	return 0;
	391	}
	392
	393	static __exit void efivars_pstore_exit(void)
	394	{
cae73167 GT	395	if (!efi_pstore_info.bufsize)
	396	return;
	397
	398	pstore_unregister(&efi_pstore_info);
	399	kfree(efi_pstore_info.buf);
	400	efi_pstore_info.buf = NULL;
	401	efi_pstore_info.bufsize = 0;
04851772 MF	402	}
	403
	404	module_init(efivars_pstore_init);
	405	module_exit(efivars_pstore_exit);
	406
	407	MODULE_DESCRIPTION("EFI variable backend for pstore");
	408	MODULE_LICENSE("GPL");
9ac4d5ab	409	MODULE_ALIAS("platform:efivars");