[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;
}

struct pstore_read_data {
	u64 *id;
	enum pstore_type_id *type;
	int *count;
	struct timespec *timespec;
	bool *compressed;
	char **buf;
};

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

static int efi_pstore_read_func(struct efivar_entry *entry, void *data)
{
	efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
	struct pstore_read_data *cb_data = data;
	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",
		   cb_data->type, &part, &cnt, &time, &data_type) == 5) {
		*cb_data->id = generic_id(time, part, cnt);
		*cb_data->count = cnt;
		cb_data->timespec->tv_sec = time;
		cb_data->timespec->tv_nsec = 0;
		if (data_type == 'C')
			*cb_data->compressed = true;
		else
			*cb_data->compressed = false;
	} else if (sscanf(name, "dump-type%u-%u-%d-%lu",
		   cb_data->type, &part, &cnt, &time) == 4) {
		*cb_data->id = generic_id(time, part, cnt);
		*cb_data->count = cnt;
		cb_data->timespec->tv_sec = time;
		cb_data->timespec->tv_nsec = 0;
		*cb_data->compressed = false;
	} else if (sscanf(name, "dump-type%u-%u-%lu",
			  cb_data->type, &part, &time) == 3) {
		/*
		 * Check if an old format,
		 * which doesn't support holding
		 * multiple logs, remains.
		 */
		*cb_data->id = generic_id(time, part, 0);
		*cb_data->count = 0;
		cb_data->timespec->tv_sec = time;
		cb_data->timespec->tv_nsec = 0;
		*cb_data->compressed = false;
	} 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(*cb_data->buf, entry->var.Data,
	       (size_t)min_t(unsigned long, EFIVARS_DATA_SIZE_MAX, size));

	return size;
}

/**
 * efi_pstore_scan_sysfs_enter
 * @entry: 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 void __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);
		efivar_entry_iter_begin();
	} else if (turn_off_scanning)
		entry->scanning = false;
}

/**
 * efi_pstore_scan_sysfs_exit
 * @pos: scanning entry
 * @next: next entry
 * @head: list head
 * @stop: a flag checking if scanning will stop
 */
static void efi_pstore_scan_sysfs_exit(struct efivar_entry *pos,
				       struct efivar_entry *next,
				       struct list_head *head, bool stop)
{
	__efi_pstore_scan_sysfs_exit(pos, true);
	if (stop)
		__efi_pstore_scan_sysfs_exit(next, &next->list != head);
}

/**
 * efi_pstore_sysfs_entry_iter
 *
 * @data: function-specific data to pass to callback
 * @pos: entry to begin iterating from
 *
 * You MUST call efivar_enter_iter_begin() before this function, and
 * efivar_entry_iter_end() afterwards.
 *
 * It is possible to begin iteration from an arbitrary entry within
 * the list by passing @pos. @pos is updated on return to point to
 * the next entry of the last one passed to efi_pstore_read_func().
 * To begin iterating from the beginning of the list @pos must be %NULL.
 */
static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos)
{
	struct efivar_entry *entry, *n;
	struct list_head *head = &efivar_sysfs_list;
	int size = 0;

	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, data);
			efi_pstore_scan_sysfs_exit(entry, n, head, size < 0);
			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), data);
		efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0);
		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(u64 *id, enum pstore_type_id *type,
			       int *count, struct timespec *timespec,
			       char **buf, bool *compressed,
			       struct pstore_info *psi)
{
	struct pstore_read_data data;
	ssize_t size;

	data.id = id;
	data.type = type;
	data.count = count;
	data.timespec = timespec;
	data.compressed = compressed;
	data.buf = buf;

	*data.buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL);
	if (!*data.buf)
		return -ENOMEM;

	efivar_entry_iter_begin();
	size = efi_pstore_sysfs_entry_iter(&data,
					   (struct efivar_entry **)&psi->data);
	efivar_entry_iter_end();
	if (size <= 0)
		kfree(*data.buf);
	return size;
}

static int efi_pstore_write(enum pstore_type_id type,
		enum kmsg_dump_reason reason, u64 *id,
		unsigned int part, int count, bool compressed, size_t size,
		struct pstore_info *psi)
{
	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;

	sprintf(name, "dump-type%u-%u-%d-%lu-%c", type, part, count,
		get_seconds(), compressed ? 'C' : 'D');

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

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

	if (reason == KMSG_DUMP_OOPS)
		efivar_run_worker();

	*id = part;
	return ret;
};

struct pstore_erase_data {
	u64 id;
	enum pstore_type_id type;
	int count;
	struct timespec time;
	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.
		 */
		sprintf(name_old, "dump-type%u-%u-%lu", ed->type,
			(unsigned int)ed->id, ed->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(enum pstore_type_id type, u64 id, int count,
			    struct timespec time, struct pstore_info *psi)
{
	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;
	unsigned int part;

	do_div(id, 1000);
	part = do_div(id, 100);
	sprintf(name, "dump-type%u-%u-%d-%lu", type, part, count, time.tv_sec);

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

	edata.id = part;
	edata.type = type;
	edata.count = count;
	edata.time = time;
	edata.name = efi_name;

	efivar_entry_iter_begin();
	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_FRAGILE,
	.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)
{
}

module_init(efivars_pstore_init);
module_exit(efivars_pstore_exit);

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