1#include <linux/efi.h>
2#include <linux/module.h>
3#include <linux/pstore.h>
4#include <linux/slab.h>
5#include <linux/ucs2_string.h>
6
7#define DUMP_NAME_LEN 52
8
9static bool efivars_pstore_disable =
10 IS_ENABLED(CONFIG_EFI_VARS_PSTORE_DEFAULT_DISABLE);
11
12module_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
19static int efi_pstore_open(struct pstore_info *psi)
20{
21 psi->data = NULL;
22 return 0;
23}
24
25static int efi_pstore_close(struct pstore_info *psi)
26{
27 psi->data = NULL;
28 return 0;
29}
30
31struct pstore_read_data {
32 u64 *id;
33 enum pstore_type_id *type;
34 int *count;
35 struct timespec *timespec;
36 bool *compressed;
37 ssize_t *ecc_notice_size;
38 char **buf;
39};
40
41static inline u64 generic_id(unsigned long timestamp,
42 unsigned int part, int count)
43{
44 return ((u64) timestamp * 100 + part) * 1000 + count;
45}
46
47static int efi_pstore_read_func(struct efivar_entry *entry, void *data)
48{
49 efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
50 struct pstore_read_data *cb_data = data;
51 char name[DUMP_NAME_LEN], data_type;
52 int i;
53 int cnt;
54 unsigned int part;
55 unsigned long time, size;
56
57 if (efi_guidcmp(entry->var.VendorGuid, vendor))
58 return 0;
59
60 for (i = 0; i < DUMP_NAME_LEN; i++)
61 name[i] = entry->var.VariableName[i];
62
63 if (sscanf(name, "dump-type%u-%u-%d-%lu-%c",
64 cb_data->type, &part, &cnt, &time, &data_type) == 5) {
65 *cb_data->id = generic_id(time, part, cnt);
66 *cb_data->count = cnt;
67 cb_data->timespec->tv_sec = time;
68 cb_data->timespec->tv_nsec = 0;
69 if (data_type == 'C')
70 *cb_data->compressed = true;
71 else
72 *cb_data->compressed = false;
73 *cb_data->ecc_notice_size = 0;
74 } else if (sscanf(name, "dump-type%u-%u-%d-%lu",
75 cb_data->type, &part, &cnt, &time) == 4) {
76 *cb_data->id = generic_id(time, part, cnt);
77 *cb_data->count = cnt;
78 cb_data->timespec->tv_sec = time;
79 cb_data->timespec->tv_nsec = 0;
80 *cb_data->compressed = false;
81 *cb_data->ecc_notice_size = 0;
82 } else if (sscanf(name, "dump-type%u-%u-%lu",
83 cb_data->type, &part, &time) == 3) {
84
85
86
87
88
89 *cb_data->id = generic_id(time, part, 0);
90 *cb_data->count = 0;
91 cb_data->timespec->tv_sec = time;
92 cb_data->timespec->tv_nsec = 0;
93 *cb_data->compressed = false;
94 *cb_data->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(*cb_data->buf, entry->var.Data,
103 (size_t)min_t(unsigned long, EFIVARS_DATA_SIZE_MAX, size));
104
105 return size;
106}
107
108
109
110
111
112
113
114static 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
125
126
127
128static 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 efivar_unregister(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
145
146
147
148
149
150static 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
166
167
168
169
170
171
172
173
174
175
176
177
178static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos)
179{
180 struct efivar_entry *entry, *n;
181 struct list_head *head = &efivar_sysfs_list;
182 int size = 0;
183 int ret;
184
185 if (!*pos) {
186 list_for_each_entry_safe(entry, n, head, list) {
187 efi_pstore_scan_sysfs_enter(entry, n, head);
188
189 size = efi_pstore_read_func(entry, data);
190 ret = efi_pstore_scan_sysfs_exit(entry, n, head,
191 size < 0);
192 if (ret)
193 return ret;
194 if (size)
195 break;
196 }
197 *pos = n;
198 return size;
199 }
200
201 list_for_each_entry_safe_from((*pos), n, head, list) {
202 efi_pstore_scan_sysfs_enter((*pos), n, head);
203
204 size = efi_pstore_read_func((*pos), data);
205 ret = efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0);
206 if (ret)
207 return ret;
208 if (size)
209 break;
210 }
211 *pos = n;
212 return size;
213}
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
229 int *count, struct timespec *timespec,
230 char **buf, bool *compressed,
231 ssize_t *ecc_notice_size,
232 struct pstore_info *psi)
233{
234 struct pstore_read_data data;
235 ssize_t size;
236
237 data.id = id;
238 data.type = type;
239 data.count = count;
240 data.timespec = timespec;
241 data.compressed = compressed;
242 data.ecc_notice_size = ecc_notice_size;
243 data.buf = buf;
244
245 *data.buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL);
246 if (!*data.buf)
247 return -ENOMEM;
248
249 if (efivar_entry_iter_begin()) {
250 kfree(*data.buf);
251 return -EINTR;
252 }
253 size = efi_pstore_sysfs_entry_iter(&data,
254 (struct efivar_entry **)&psi->data);
255 efivar_entry_iter_end();
256 if (size <= 0)
257 kfree(*data.buf);
258 return size;
259}
260
261static int efi_pstore_write(enum pstore_type_id type,
262 enum kmsg_dump_reason reason, u64 *id,
263 unsigned int part, int count, bool compressed, size_t size,
264 struct pstore_info *psi)
265{
266 char name[DUMP_NAME_LEN];
267 efi_char16_t efi_name[DUMP_NAME_LEN];
268 efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
269 int i, ret = 0;
270
271 sprintf(name, "dump-type%u-%u-%d-%lu-%c", type, part, count,
272 get_seconds(), compressed ? 'C' : 'D');
273
274 for (i = 0; i < DUMP_NAME_LEN; i++)
275 efi_name[i] = name[i];
276
277 efivar_entry_set_safe(efi_name, vendor, PSTORE_EFI_ATTRIBUTES,
278 !pstore_cannot_block_path(reason),
279 size, psi->buf);
280
281 if (reason == KMSG_DUMP_OOPS)
282 efivar_run_worker();
283
284 *id = part;
285 return ret;
286};
287
288struct pstore_erase_data {
289 u64 id;
290 enum pstore_type_id type;
291 int count;
292 struct timespec time;
293 efi_char16_t *name;
294};
295
296
297
298
299static int efi_pstore_erase_func(struct efivar_entry *entry, void *data)
300{
301 struct pstore_erase_data *ed = data;
302 efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
303 efi_char16_t efi_name_old[DUMP_NAME_LEN];
304 efi_char16_t *efi_name = ed->name;
305 unsigned long ucs2_len = ucs2_strlen(ed->name);
306 char name_old[DUMP_NAME_LEN];
307 int i;
308
309 if (efi_guidcmp(entry->var.VendorGuid, vendor))
310 return 0;
311
312 if (ucs2_strncmp(entry->var.VariableName,
313 efi_name, (size_t)ucs2_len)) {
314
315
316
317
318 sprintf(name_old, "dump-type%u-%u-%lu", ed->type,
319 (unsigned int)ed->id, ed->time.tv_sec);
320
321 for (i = 0; i < DUMP_NAME_LEN; i++)
322 efi_name_old[i] = name_old[i];
323
324 if (ucs2_strncmp(entry->var.VariableName, efi_name_old,
325 ucs2_strlen(efi_name_old)))
326 return 0;
327 }
328
329 if (entry->scanning) {
330
331
332
333
334 entry->deleting = true;
335 } else
336 list_del(&entry->list);
337
338
339 __efivar_entry_delete(entry);
340
341 return 1;
342}
343
344static int efi_pstore_erase(enum pstore_type_id type, u64 id, int count,
345 struct timespec time, struct pstore_info *psi)
346{
347 struct pstore_erase_data edata;
348 struct efivar_entry *entry = NULL;
349 char name[DUMP_NAME_LEN];
350 efi_char16_t efi_name[DUMP_NAME_LEN];
351 int found, i;
352 unsigned int part;
353
354 do_div(id, 1000);
355 part = do_div(id, 100);
356 sprintf(name, "dump-type%u-%u-%d-%lu", type, part, count, time.tv_sec);
357
358 for (i = 0; i < DUMP_NAME_LEN; i++)
359 efi_name[i] = name[i];
360
361 edata.id = part;
362 edata.type = type;
363 edata.count = count;
364 edata.time = time;
365 edata.name = efi_name;
366
367 if (efivar_entry_iter_begin())
368 return -EINTR;
369 found = __efivar_entry_iter(efi_pstore_erase_func, &efivar_sysfs_list, &edata, &entry);
370
371 if (found && !entry->scanning) {
372 efivar_entry_iter_end();
373 efivar_unregister(entry);
374 } else
375 efivar_entry_iter_end();
376
377 return 0;
378}
379
380static struct pstore_info efi_pstore_info = {
381 .owner = THIS_MODULE,
382 .name = "efi",
383 .flags = PSTORE_FLAGS_DMESG,
384 .open = efi_pstore_open,
385 .close = efi_pstore_close,
386 .read = efi_pstore_read,
387 .write = efi_pstore_write,
388 .erase = efi_pstore_erase,
389};
390
391static __init int efivars_pstore_init(void)
392{
393 if (!efi_enabled(EFI_RUNTIME_SERVICES))
394 return 0;
395
396 if (!efivars_kobject())
397 return 0;
398
399 if (efivars_pstore_disable)
400 return 0;
401
402 efi_pstore_info.buf = kmalloc(4096, GFP_KERNEL);
403 if (!efi_pstore_info.buf)
404 return -ENOMEM;
405
406 efi_pstore_info.bufsize = 1024;
407 spin_lock_init(&efi_pstore_info.buf_lock);
408
409 if (pstore_register(&efi_pstore_info)) {
410 kfree(efi_pstore_info.buf);
411 efi_pstore_info.buf = NULL;
412 efi_pstore_info.bufsize = 0;
413 }
414
415 return 0;
416}
417
418static __exit void efivars_pstore_exit(void)
419{
420 if (!efi_pstore_info.bufsize)
421 return;
422
423 pstore_unregister(&efi_pstore_info);
424 kfree(efi_pstore_info.buf);
425 efi_pstore_info.buf = NULL;
426 efi_pstore_info.bufsize = 0;
427}
428
429module_init(efivars_pstore_init);
430module_exit(efivars_pstore_exit);
431
432MODULE_DESCRIPTION("EFI variable backend for pstore");
433MODULE_LICENSE("GPL");
434MODULE_ALIAS("platform:efivars");
435