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 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 { 21 psi->data = NULL; 22 return 0; 23 } 24 25 static int efi_pstore_close(struct pstore_info *psi) 26 { 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; 36 bool *compressed; 37 ssize_t *ecc_notice_size; 38 char **buf; 39 }; 40 41 static inline u64 generic_id(unsigned long timestamp, 42 unsigned int part, int count) 43 { 44 return ((u64) timestamp * 100 + part) * 1000 + count; 45 } 46 47 static 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 * Check if an old format, 86 * which doesn't support holding 87 * multiple logs, remains. 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 * 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 void __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 efivar_entry_iter_begin(); 136 } else if (turn_off_scanning) 137 entry->scanning = false; 138 } 139 140 /** 141 * efi_pstore_scan_sysfs_exit 142 * @pos: scanning entry 143 * @next: next entry 144 * @head: list head 145 * @stop: a flag checking if scanning will stop 146 */ 147 static void efi_pstore_scan_sysfs_exit(struct efivar_entry *pos, 148 struct efivar_entry *next, 149 struct list_head *head, bool stop) 150 { 151 __efi_pstore_scan_sysfs_exit(pos, true); 152 if (stop) 153 __efi_pstore_scan_sysfs_exit(next, &next->list != head); 154 } 155 156 /** 157 * efi_pstore_sysfs_entry_iter 158 * 159 * @data: function-specific data to pass to callback 160 * @pos: entry to begin iterating from 161 * 162 * You MUST call efivar_enter_iter_begin() before this function, and 163 * efivar_entry_iter_end() afterwards. 164 * 165 * It is possible to begin iteration from an arbitrary entry within 166 * the list by passing @pos. @pos is updated on return to point to 167 * the next entry of the last one passed to efi_pstore_read_func(). 168 * To begin iterating from the beginning of the list @pos must be %NULL. 169 */ 170 static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos) 171 { 172 struct efivar_entry *entry, *n; 173 struct list_head *head = &efivar_sysfs_list; 174 int size = 0; 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, data); 181 efi_pstore_scan_sysfs_exit(entry, n, head, size < 0); 182 if (size) 183 break; 184 } 185 *pos = n; 186 return size; 187 } 188 189 list_for_each_entry_safe_from((*pos), n, head, list) { 190 efi_pstore_scan_sysfs_enter((*pos), n, head); 191 192 size = efi_pstore_read_func((*pos), data); 193 efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0); 194 if (size) 195 break; 196 } 197 *pos = n; 198 return size; 199 } 200 201 /** 202 * efi_pstore_read 203 * 204 * This function returns a size of NVRAM entry logged via efi_pstore_write(). 205 * The meaning and behavior of efi_pstore/pstore are as below. 206 * 207 * size > 0: Got data of an entry logged via efi_pstore_write() successfully, 208 * and pstore filesystem will continue reading subsequent entries. 209 * size == 0: Entry was not logged via efi_pstore_write(), 210 * and efi_pstore driver will continue reading subsequent entries. 211 * size < 0: Failed to get data of entry logging via efi_pstore_write(), 212 * and pstore will stop reading entry. 213 */ 214 static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type, 215 int *count, struct timespec *timespec, 216 char **buf, bool *compressed, 217 ssize_t *ecc_notice_size, 218 struct pstore_info *psi) 219 { 220 struct pstore_read_data data; 221 ssize_t size; 222 223 data.id = id; 224 data.type = type; 225 data.count = count; 226 data.timespec = timespec; 227 data.compressed = compressed; 228 data.ecc_notice_size = ecc_notice_size; 229 data.buf = buf; 230 231 *data.buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL); 232 if (!*data.buf) 233 return -ENOMEM; 234 235 efivar_entry_iter_begin(); 236 size = efi_pstore_sysfs_entry_iter(&data, 237 (struct efivar_entry **)&psi->data); 238 efivar_entry_iter_end(); 239 if (size <= 0) 240 kfree(*data.buf); 241 return size; 242 } 243 244 static int efi_pstore_write(enum pstore_type_id type, 245 enum kmsg_dump_reason reason, u64 *id, 246 unsigned int part, int count, bool compressed, size_t size, 247 struct pstore_info *psi) 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 sprintf(name, "dump-type%u-%u-%d-%lu-%c", type, part, count, 255 get_seconds(), compressed ? 'C' : 'D'); 256 257 for (i = 0; i < DUMP_NAME_LEN; i++) 258 efi_name[i] = name[i]; 259 260 efivar_entry_set_safe(efi_name, vendor, PSTORE_EFI_ATTRIBUTES, 261 !pstore_cannot_block_path(reason), 262 size, psi->buf); 263 264 if (reason == KMSG_DUMP_OOPS) 265 efivar_run_worker(); 266 267 *id = part; 268 return ret; 269 }; 270 271 struct pstore_erase_data { 272 u64 id; 273 enum pstore_type_id type; 274 int count; 275 struct timespec time; 276 efi_char16_t *name; 277 }; 278 279 /* 280 * Clean up an entry with the same name 281 */ 282 static int efi_pstore_erase_func(struct efivar_entry *entry, void *data) 283 { 284 struct pstore_erase_data *ed = data; 285 efi_guid_t vendor = LINUX_EFI_CRASH_GUID; 286 efi_char16_t efi_name_old[DUMP_NAME_LEN]; 287 efi_char16_t *efi_name = ed->name; 288 unsigned long ucs2_len = ucs2_strlen(ed->name); 289 char name_old[DUMP_NAME_LEN]; 290 int i; 291 292 if (efi_guidcmp(entry->var.VendorGuid, vendor)) 293 return 0; 294 295 if (ucs2_strncmp(entry->var.VariableName, 296 efi_name, (size_t)ucs2_len)) { 297 /* 298 * Check if an old format, which doesn't support 299 * holding multiple logs, remains. 300 */ 301 sprintf(name_old, "dump-type%u-%u-%lu", ed->type, 302 (unsigned int)ed->id, ed->time.tv_sec); 303 304 for (i = 0; i < DUMP_NAME_LEN; i++) 305 efi_name_old[i] = name_old[i]; 306 307 if (ucs2_strncmp(entry->var.VariableName, efi_name_old, 308 ucs2_strlen(efi_name_old))) 309 return 0; 310 } 311 312 if (entry->scanning) { 313 /* 314 * Skip deletion because this entry will be deleted 315 * after scanning is completed. 316 */ 317 entry->deleting = true; 318 } else 319 list_del(&entry->list); 320 321 /* found */ 322 __efivar_entry_delete(entry); 323 324 return 1; 325 } 326 327 static int efi_pstore_erase(enum pstore_type_id type, u64 id, int count, 328 struct timespec time, struct pstore_info *psi) 329 { 330 struct pstore_erase_data edata; 331 struct efivar_entry *entry = NULL; 332 char name[DUMP_NAME_LEN]; 333 efi_char16_t efi_name[DUMP_NAME_LEN]; 334 int found, i; 335 unsigned int part; 336 337 do_div(id, 1000); 338 part = do_div(id, 100); 339 sprintf(name, "dump-type%u-%u-%d-%lu", type, part, count, time.tv_sec); 340 341 for (i = 0; i < DUMP_NAME_LEN; i++) 342 efi_name[i] = name[i]; 343 344 edata.id = part; 345 edata.type = type; 346 edata.count = count; 347 edata.time = time; 348 edata.name = efi_name; 349 350 efivar_entry_iter_begin(); 351 found = __efivar_entry_iter(efi_pstore_erase_func, &efivar_sysfs_list, &edata, &entry); 352 353 if (found && !entry->scanning) { 354 efivar_entry_iter_end(); 355 efivar_unregister(entry); 356 } else 357 efivar_entry_iter_end(); 358 359 return 0; 360 } 361 362 static struct pstore_info efi_pstore_info = { 363 .owner = THIS_MODULE, 364 .name = "efi", 365 .flags = PSTORE_FLAGS_FRAGILE, 366 .open = efi_pstore_open, 367 .close = efi_pstore_close, 368 .read = efi_pstore_read, 369 .write = efi_pstore_write, 370 .erase = efi_pstore_erase, 371 }; 372 373 static __init int efivars_pstore_init(void) 374 { 375 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 376 return 0; 377 378 if (!efivars_kobject()) 379 return 0; 380 381 if (efivars_pstore_disable) 382 return 0; 383 384 efi_pstore_info.buf = kmalloc(4096, GFP_KERNEL); 385 if (!efi_pstore_info.buf) 386 return -ENOMEM; 387 388 efi_pstore_info.bufsize = 1024; 389 spin_lock_init(&efi_pstore_info.buf_lock); 390 391 if (pstore_register(&efi_pstore_info)) { 392 kfree(efi_pstore_info.buf); 393 efi_pstore_info.buf = NULL; 394 efi_pstore_info.bufsize = 0; 395 } 396 397 return 0; 398 } 399 400 static __exit void efivars_pstore_exit(void) 401 { 402 if (!efi_pstore_info.bufsize) 403 return; 404 405 pstore_unregister(&efi_pstore_info); 406 kfree(efi_pstore_info.buf); 407 efi_pstore_info.buf = NULL; 408 efi_pstore_info.bufsize = 0; 409 } 410 411 module_init(efivars_pstore_init); 412 module_exit(efivars_pstore_exit); 413 414 MODULE_DESCRIPTION("EFI variable backend for pstore"); 415 MODULE_LICENSE("GPL"); 416 MODULE_ALIAS("platform:efivars"); 417