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