2 #include <linux/module.h>
3 #include <linux/pstore.h>
4 #include <linux/slab.h>
5 #include <linux/ucs2_string.h>
7 #define DUMP_NAME_LEN 52
9 static bool efivars_pstore_disable
=
10 IS_ENABLED(CONFIG_EFI_VARS_PSTORE_DEFAULT_DISABLE
);
12 module_param_named(pstore_disable
, efivars_pstore_disable
, bool, 0644);
14 #define PSTORE_EFI_ATTRIBUTES \
15 (EFI_VARIABLE_NON_VOLATILE | \
16 EFI_VARIABLE_BOOTSERVICE_ACCESS | \
17 EFI_VARIABLE_RUNTIME_ACCESS)
19 static int efi_pstore_open(struct pstore_info
*psi
)
25 static int efi_pstore_close(struct pstore_info
*psi
)
31 struct pstore_read_data
{
33 enum pstore_type_id
*type
;
35 struct timespec
*timespec
;
40 static inline u64
generic_id(unsigned long timestamp
,
41 unsigned int part
, int count
)
43 return ((u64
) timestamp
* 100 + part
) * 1000 + count
;
46 static int efi_pstore_read_func(struct efivar_entry
*entry
, void *data
)
48 efi_guid_t vendor
= LINUX_EFI_CRASH_GUID
;
49 struct pstore_read_data
*cb_data
= data
;
50 char name
[DUMP_NAME_LEN
], data_type
;
54 unsigned long time
, size
;
56 if (efi_guidcmp(entry
->var
.VendorGuid
, vendor
))
59 for (i
= 0; i
< DUMP_NAME_LEN
; i
++)
60 name
[i
] = entry
->var
.VariableName
[i
];
62 if (sscanf(name
, "dump-type%u-%u-%d-%lu-%c",
63 cb_data
->type
, &part
, &cnt
, &time
, &data_type
) == 5) {
64 *cb_data
->id
= generic_id(time
, part
, cnt
);
65 *cb_data
->count
= cnt
;
66 cb_data
->timespec
->tv_sec
= time
;
67 cb_data
->timespec
->tv_nsec
= 0;
69 *cb_data
->compressed
= true;
71 *cb_data
->compressed
= false;
72 } else if (sscanf(name
, "dump-type%u-%u-%d-%lu",
73 cb_data
->type
, &part
, &cnt
, &time
) == 4) {
74 *cb_data
->id
= generic_id(time
, part
, cnt
);
75 *cb_data
->count
= cnt
;
76 cb_data
->timespec
->tv_sec
= time
;
77 cb_data
->timespec
->tv_nsec
= 0;
78 *cb_data
->compressed
= false;
79 } else if (sscanf(name
, "dump-type%u-%u-%lu",
80 cb_data
->type
, &part
, &time
) == 3) {
82 * Check if an old format,
83 * which doesn't support holding
84 * multiple logs, remains.
86 *cb_data
->id
= generic_id(time
, part
, 0);
88 cb_data
->timespec
->tv_sec
= time
;
89 cb_data
->timespec
->tv_nsec
= 0;
90 *cb_data
->compressed
= false;
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
;
98 memcpy(*cb_data
->buf
, entry
->var
.Data
,
99 (size_t)min_t(unsigned long, EFIVARS_DATA_SIZE_MAX
, size
));
105 * efi_pstore_scan_sysfs_enter
106 * @entry: scanning entry
110 static void efi_pstore_scan_sysfs_enter(struct efivar_entry
*pos
,
111 struct efivar_entry
*next
,
112 struct list_head
*head
)
114 pos
->scanning
= true;
115 if (&next
->list
!= head
)
116 next
->scanning
= true;
120 * __efi_pstore_scan_sysfs_exit
121 * @entry: deleting entry
122 * @turn_off_scanning: Check if a scanning flag should be turned off
124 static inline void __efi_pstore_scan_sysfs_exit(struct efivar_entry
*entry
,
125 bool turn_off_scanning
)
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;
137 * efi_pstore_scan_sysfs_exit
138 * @pos: scanning entry
141 * @stop: a flag checking if scanning will stop
143 static void efi_pstore_scan_sysfs_exit(struct efivar_entry
*pos
,
144 struct efivar_entry
*next
,
145 struct list_head
*head
, bool stop
)
147 __efi_pstore_scan_sysfs_exit(pos
, true);
149 __efi_pstore_scan_sysfs_exit(next
, &next
->list
!= head
);
153 * efi_pstore_sysfs_entry_iter
155 * @data: function-specific data to pass to callback
156 * @pos: entry to begin iterating from
158 * You MUST call efivar_enter_iter_begin() before this function, and
159 * efivar_entry_iter_end() afterwards.
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.
166 static int efi_pstore_sysfs_entry_iter(void *data
, struct efivar_entry
**pos
)
168 struct efivar_entry
*entry
, *n
;
169 struct list_head
*head
= &efivar_sysfs_list
;
173 list_for_each_entry_safe(entry
, n
, head
, list
) {
174 efi_pstore_scan_sysfs_enter(entry
, n
, head
);
176 size
= efi_pstore_read_func(entry
, data
);
177 efi_pstore_scan_sysfs_exit(entry
, n
, head
, size
< 0);
185 list_for_each_entry_safe_from((*pos
), n
, head
, list
) {
186 efi_pstore_scan_sysfs_enter((*pos
), n
, head
);
188 size
= efi_pstore_read_func((*pos
), data
);
189 efi_pstore_scan_sysfs_exit((*pos
), n
, head
, size
< 0);
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.
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.
210 static ssize_t
efi_pstore_read(u64
*id
, enum pstore_type_id
*type
,
211 int *count
, struct timespec
*timespec
,
212 char **buf
, bool *compressed
,
213 struct pstore_info
*psi
)
215 struct pstore_read_data data
;
221 data
.timespec
= timespec
;
222 data
.compressed
= compressed
;
225 *data
.buf
= kzalloc(EFIVARS_DATA_SIZE_MAX
, GFP_KERNEL
);
229 efivar_entry_iter_begin();
230 size
= efi_pstore_sysfs_entry_iter(&data
,
231 (struct efivar_entry
**)&psi
->data
);
232 efivar_entry_iter_end();
238 static int efi_pstore_write(enum pstore_type_id type
,
239 enum kmsg_dump_reason reason
, u64
*id
,
240 unsigned int part
, int count
, bool compressed
, size_t size
,
241 struct pstore_info
*psi
)
243 char name
[DUMP_NAME_LEN
];
244 efi_char16_t efi_name
[DUMP_NAME_LEN
];
245 efi_guid_t vendor
= LINUX_EFI_CRASH_GUID
;
248 sprintf(name
, "dump-type%u-%u-%d-%lu-%c", type
, part
, count
,
249 get_seconds(), compressed
? 'C' : 'D');
251 for (i
= 0; i
< DUMP_NAME_LEN
; i
++)
252 efi_name
[i
] = name
[i
];
254 efivar_entry_set_safe(efi_name
, vendor
, PSTORE_EFI_ATTRIBUTES
,
255 !pstore_cannot_block_path(reason
),
258 if (reason
== KMSG_DUMP_OOPS
)
265 struct pstore_erase_data
{
267 enum pstore_type_id type
;
269 struct timespec time
;
274 * Clean up an entry with the same name
276 static int efi_pstore_erase_func(struct efivar_entry
*entry
, void *data
)
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
;
282 unsigned long ucs2_len
= ucs2_strlen(ed
->name
);
283 char name_old
[DUMP_NAME_LEN
];
286 if (efi_guidcmp(entry
->var
.VendorGuid
, vendor
))
289 if (ucs2_strncmp(entry
->var
.VariableName
,
290 efi_name
, (size_t)ucs2_len
)) {
292 * Check if an old format, which doesn't support
293 * holding multiple logs, remains.
295 sprintf(name_old
, "dump-type%u-%u-%lu", ed
->type
,
296 (unsigned int)ed
->id
, ed
->time
.tv_sec
);
298 for (i
= 0; i
< DUMP_NAME_LEN
; i
++)
299 efi_name_old
[i
] = name_old
[i
];
301 if (ucs2_strncmp(entry
->var
.VariableName
, efi_name_old
,
302 ucs2_strlen(efi_name_old
)))
306 if (entry
->scanning
) {
308 * Skip deletion because this entry will be deleted
309 * after scanning is completed.
311 entry
->deleting
= true;
313 list_del(&entry
->list
);
316 __efivar_entry_delete(entry
);
321 static int efi_pstore_erase(enum pstore_type_id type
, u64 id
, int count
,
322 struct timespec time
, struct pstore_info
*psi
)
324 struct pstore_erase_data edata
;
325 struct efivar_entry
*entry
= NULL
;
326 char name
[DUMP_NAME_LEN
];
327 efi_char16_t efi_name
[DUMP_NAME_LEN
];
332 part
= do_div(id
, 100);
333 sprintf(name
, "dump-type%u-%u-%d-%lu", type
, part
, count
, time
.tv_sec
);
335 for (i
= 0; i
< DUMP_NAME_LEN
; i
++)
336 efi_name
[i
] = name
[i
];
342 edata
.name
= efi_name
;
344 efivar_entry_iter_begin();
345 found
= __efivar_entry_iter(efi_pstore_erase_func
, &efivar_sysfs_list
, &edata
, &entry
);
347 if (found
&& !entry
->scanning
) {
348 efivar_entry_iter_end();
349 efivar_unregister(entry
);
351 efivar_entry_iter_end();
356 static struct pstore_info efi_pstore_info
= {
357 .owner
= THIS_MODULE
,
359 .flags
= PSTORE_FLAGS_FRAGILE
,
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
,
367 static __init
int efivars_pstore_init(void)
369 if (!efi_enabled(EFI_RUNTIME_SERVICES
))
372 if (!efivars_kobject())
375 if (efivars_pstore_disable
)
378 efi_pstore_info
.buf
= kmalloc(4096, GFP_KERNEL
);
379 if (!efi_pstore_info
.buf
)
382 efi_pstore_info
.bufsize
= 1024;
383 spin_lock_init(&efi_pstore_info
.buf_lock
);
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;
394 static __exit
void efivars_pstore_exit(void)
398 module_init(efivars_pstore_init
);
399 module_exit(efivars_pstore_exit
);
401 MODULE_DESCRIPTION("EFI variable backend for pstore");
402 MODULE_LICENSE("GPL");