drivers/firmware/efi/efi-pstore.c

   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         char **buf;
  38 };
  39
  40 static inline u64 generic_id(unsigned long timestamp,
  41                              unsigned int part, int count)
  42 {
  43         return (timestamp * 100 + part) * 1000 + count;
  44 }
  45
  46 static int efi_pstore_read_func(struct efivar_entry *entry, void *data)
  47 {
  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;
  51         int i;
  52         int cnt;
  53         unsigned int part;
  54         unsigned long time, size;
  55
  56         if (efi_guidcmp(entry->var.VendorGuid, vendor))
  57                 return 0;
  58
  59         for (i = 0; i < DUMP_NAME_LEN; i++)
  60                 name[i] = entry->var.VariableName[i];
  61
  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;
  68                 if (data_type == 'C')
  69                         *cb_data->compressed = true;
  70                 else
  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) {
  81                 /*
  82                  * Check if an old format,
  83                  * which doesn't support holding
  84                  * multiple logs, remains.
  85                  */
  86                 *cb_data->id = generic_id(time, part, 0);
  87                 *cb_data->count = 0;
  88                 cb_data->timespec->tv_sec = time;
  89                 cb_data->timespec->tv_nsec = 0;
  90                 *cb_data->compressed = false;
  91         } else
  92                 return 0;
  93
  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));
 100
 101         return size;
 102 }
 103
 104 /**
 105  * efi_pstore_scan_sysfs_enter
 106  * @entry: scanning entry
 107  * @next: next entry
 108  * @head: list head
 109  */
 110 static void efi_pstore_scan_sysfs_enter(struct efivar_entry *pos,
 111                                         struct efivar_entry *next,
 112                                         struct list_head *head)
 113 {
 114         pos->scanning = true;
 115         if (&next->list != head)
 116                 next->scanning = true;
 117 }
 118
 119 /**
 120  * __efi_pstore_scan_sysfs_exit
 121  * @entry: deleting entry
 122  * @turn_off_scanning: Check if a scanning flag should be turned off
 123  */
 124 static inline void __efi_pstore_scan_sysfs_exit(struct efivar_entry *entry,
 125                                                 bool turn_off_scanning)
 126 {
 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;
 134 }
 135
 136 /**
 137  * efi_pstore_scan_sysfs_exit
 138  * @pos: scanning entry
 139  * @next: next entry
 140  * @head: list head
 141  * @stop: a flag checking if scanning will stop
 142  */
 143 static void efi_pstore_scan_sysfs_exit(struct efivar_entry *pos,
 144                                        struct efivar_entry *next,
 145                                        struct list_head *head, bool stop)
 146 {
 147         __efi_pstore_scan_sysfs_exit(pos, true);
 148         if (stop)
 149                 __efi_pstore_scan_sysfs_exit(next, &next->list != head);
 150 }
 151
 152 /**
 153  * efi_pstore_sysfs_entry_iter
 154  *
 155  * @data: function-specific data to pass to callback
 156  * @pos: entry to begin iterating from
 157  *
 158  * You MUST call efivar_enter_iter_begin() before this function, and
 159  * efivar_entry_iter_end() afterwards.
 160  *
 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.
 165  */
 166 static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos)
 167 {
 168         struct efivar_entry *entry, *n;
 169         struct list_head *head = &efivar_sysfs_list;
 170         int size = 0;
 171
 172         if (!*pos) {
 173                 list_for_each_entry_safe(entry, n, head, list) {
 174                         efi_pstore_scan_sysfs_enter(entry, n, head);
 175
 176                         size = efi_pstore_read_func(entry, data);
 177                         efi_pstore_scan_sysfs_exit(entry, n, head, size < 0);
 178                         if (size)
 179                                 break;
 180                 }
 181                 *pos = n;
 182                 return size;
 183         }
 184
 185         list_for_each_entry_safe_from((*pos), n, head, list) {
 186                 efi_pstore_scan_sysfs_enter((*pos), n, head);
 187
 188                 size = efi_pstore_read_func((*pos), data);
 189                 efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0);
 190                 if (size)
 191                         break;
 192         }
 193         *pos = n;
 194         return size;
 195 }
 196
 197 /**
 198  * efi_pstore_read
 199  *
 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.
 202  *
 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.
 209  */
 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)
 214 {
 215         struct pstore_read_data data;
 216         ssize_t size;
 217
 218         data.id = id;
 219         data.type = type;
 220         data.count = count;
 221         data.timespec = timespec;
 222         data.compressed = compressed;
 223         data.buf = buf;
 224
 225         *data.buf = kzalloc(EFIVARS_DATA_SIZE_MAX, GFP_KERNEL);
 226         if (!*data.buf)
 227                 return -ENOMEM;
 228
 229         efivar_entry_iter_begin();
 230         size = efi_pstore_sysfs_entry_iter(&data,
 231                                            (struct efivar_entry **)&psi->data);
 232         efivar_entry_iter_end();
 233         if (size <= 0)
 234                 kfree(*data.buf);
 235         return size;
 236 }
 237
 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)
 242 {
 243         char name[DUMP_NAME_LEN];
 244         efi_char16_t efi_name[DUMP_NAME_LEN];
 245         efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
 246         int i, ret = 0;
 247
 248         sprintf(name, "dump-type%u-%u-%d-%lu-%c", type, part, count,
 249                 get_seconds(), compressed ? 'C' : 'D');
 250
 251         for (i = 0; i < DUMP_NAME_LEN; i++)
 252                 efi_name[i] = name[i];
 253
 254         efivar_entry_set_safe(efi_name, vendor, PSTORE_EFI_ATTRIBUTES,
 255                               !pstore_cannot_block_path(reason),
 256                               size, psi->buf);
 257
 258         if (reason == KMSG_DUMP_OOPS)
 259                 efivar_run_worker();
 260
 261         *id = part;
 262         return ret;
 263 };
 264
 265 struct pstore_erase_data {
 266         u64 id;
 267         enum pstore_type_id type;
 268         int count;
 269         struct timespec time;
 270         efi_char16_t *name;
 271 };
 272
 273 /*
 274  * Clean up an entry with the same name
 275  */
 276 static int efi_pstore_erase_func(struct efivar_entry *entry, void *data)
 277 {
 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];
 284         int i;
 285
 286         if (efi_guidcmp(entry->var.VendorGuid, vendor))
 287                 return 0;
 288
 289         if (ucs2_strncmp(entry->var.VariableName,
 290                           efi_name, (size_t)ucs2_len)) {
 291                 /*
 292                  * Check if an old format, which doesn't support
 293                  * holding multiple logs, remains.
 294                  */
 295                 sprintf(name_old, "dump-type%u-%u-%lu", ed->type,
 296                         (unsigned int)ed->id, ed->time.tv_sec);
 297
 298                 for (i = 0; i < DUMP_NAME_LEN; i++)
 299                         efi_name_old[i] = name_old[i];
 300
 301                 if (ucs2_strncmp(entry->var.VariableName, efi_name_old,
 302                                   ucs2_strlen(efi_name_old)))
 303                         return 0;
 304         }
 305
 306         if (entry->scanning) {
 307                 /*
 308                  * Skip deletion because this entry will be deleted
 309                  * after scanning is completed.
 310                  */
 311                 entry->deleting = true;
 312         } else
 313                 list_del(&entry->list);
 314
 315         /* found */
 316         __efivar_entry_delete(entry);
 317
 318         return 1;
 319 }
 320
 321 static int efi_pstore_erase(enum pstore_type_id type, u64 id, int count,
 322                             struct timespec time, struct pstore_info *psi)
 323 {
 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];
 328         int found, i;
 329         unsigned int part;
 330
 331         do_div(id, 1000);
 332         part = do_div(id, 100);
 333         sprintf(name, "dump-type%u-%u-%d-%lu", type, part, count, time.tv_sec);
 334
 335         for (i = 0; i < DUMP_NAME_LEN; i++)
 336                 efi_name[i] = name[i];
 337
 338         edata.id = part;
 339         edata.type = type;
 340         edata.count = count;
 341         edata.time = time;
 342         edata.name = efi_name;
 343
 344         efivar_entry_iter_begin();
 345         found = __efivar_entry_iter(efi_pstore_erase_func, &efivar_sysfs_list, &edata, &entry);
 346
 347         if (found && !entry->scanning) {
 348                 efivar_entry_iter_end();
 349                 efivar_unregister(entry);
 350         } else
 351                 efivar_entry_iter_end();
 352
 353         return 0;
 354 }
 355
 356 static struct pstore_info efi_pstore_info = {
 357         .owner          = THIS_MODULE,
 358         .name           = "efi",
 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,
 365 };
 366
 367 static __init int efivars_pstore_init(void)
 368 {
 369         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 370                 return 0;
 371
 372         if (!efivars_kobject())
 373                 return 0;
 374
 375         if (efivars_pstore_disable)
 376                 return 0;
 377
 378         efi_pstore_info.buf = kmalloc(4096, GFP_KERNEL);
 379         if (!efi_pstore_info.buf)
 380                 return -ENOMEM;
 381
 382         efi_pstore_info.bufsize = 1024;
 383         spin_lock_init(&efi_pstore_info.buf_lock);
 384
 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;
 389         }
 390
 391         return 0;
 392 }
 393
 394 static __exit void efivars_pstore_exit(void)
 395 {
 396 }
 397
 398 module_init(efivars_pstore_init);
 399 module_exit(efivars_pstore_exit);
 400
 401 MODULE_DESCRIPTION("EFI variable backend for pstore");
 402 MODULE_LICENSE("GPL");