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