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