fs/pstore/inode.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Persistent Storage - ramfs parts.
   4  *
   5  * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/fs.h>
  10 #include <linux/fsnotify.h>
  11 #include <linux/pagemap.h>
  12 #include <linux/highmem.h>
  13 #include <linux/time.h>
  14 #include <linux/init.h>
  15 #include <linux/list.h>
  16 #include <linux/string.h>
  17 #include <linux/mount.h>
  18 #include <linux/seq_file.h>
  19 #include <linux/ramfs.h>
  20 #include <linux/parser.h>
  21 #include <linux/sched.h>
  22 #include <linux/magic.h>
  23 #include <linux/pstore.h>
  24 #include <linux/slab.h>
  25 #include <linux/uaccess.h>
  26
  27 #include "internal.h"
  28
  29 #define PSTORE_NAMELEN  64
  30
  31 static DEFINE_MUTEX(records_list_lock);
  32 static LIST_HEAD(records_list);
  33
  34 static DEFINE_MUTEX(pstore_sb_lock);
  35 static struct super_block *pstore_sb;
  36
  37 struct pstore_private {
  38         struct list_head list;
  39         struct dentry *dentry;
  40         struct pstore_record *record;
  41         size_t total_size;
  42 };
  43
  44 struct pstore_ftrace_seq_data {
  45         const void *ptr;
  46         size_t off;
  47         size_t size;
  48 };
  49
  50 #define REC_SIZE sizeof(struct pstore_ftrace_record)
  51
  52 static void free_pstore_private(struct pstore_private *private)
  53 {
  54         if (!private)
  55                 return;
  56         if (private->record) {
  57                 kfree(private->record->buf);
  58                 kfree(private->record->priv);
  59                 kfree(private->record);
  60         }
  61         kfree(private);
  62 }
  63
  64 static void *pstore_ftrace_seq_start(struct seq_file *s, loff_t *pos)
  65 {
  66         struct pstore_private *ps = s->private;
  67         struct pstore_ftrace_seq_data *data;
  68
  69         data = kzalloc(sizeof(*data), GFP_KERNEL);
  70         if (!data)
  71                 return NULL;
  72
  73         data->off = ps->total_size % REC_SIZE;
  74         data->off += *pos * REC_SIZE;
  75         if (data->off + REC_SIZE > ps->total_size) {
  76                 kfree(data);
  77                 return NULL;
  78         }
  79
  80         return data;
  81
  82 }
  83
  84 static void pstore_ftrace_seq_stop(struct seq_file *s, void *v)
  85 {
  86         kfree(v);
  87 }
  88
  89 static void *pstore_ftrace_seq_next(struct seq_file *s, void *v, loff_t *pos)
  90 {
  91         struct pstore_private *ps = s->private;
  92         struct pstore_ftrace_seq_data *data = v;
  93
  94         (*pos)++;
  95         data->off += REC_SIZE;
  96         if (data->off + REC_SIZE > ps->total_size)
  97                 return NULL;
  98
  99         return data;
 100 }
 101
 102 static int pstore_ftrace_seq_show(struct seq_file *s, void *v)
 103 {
 104         struct pstore_private *ps = s->private;
 105         struct pstore_ftrace_seq_data *data = v;
 106         struct pstore_ftrace_record *rec;
 107
 108         if (!data)
 109                 return 0;
 110
 111         rec = (struct pstore_ftrace_record *)(ps->record->buf + data->off);
 112
 113         seq_printf(s, "CPU:%d ts:%llu %08lx  %08lx  %ps <- %pS\n",
 114                    pstore_ftrace_decode_cpu(rec),
 115                    pstore_ftrace_read_timestamp(rec),
 116                    rec->ip, rec->parent_ip, (void *)rec->ip,
 117                    (void *)rec->parent_ip);
 118
 119         return 0;
 120 }
 121
 122 static const struct seq_operations pstore_ftrace_seq_ops = {
 123         .start  = pstore_ftrace_seq_start,
 124         .next   = pstore_ftrace_seq_next,
 125         .stop   = pstore_ftrace_seq_stop,
 126         .show   = pstore_ftrace_seq_show,
 127 };
 128
 129 static ssize_t pstore_file_read(struct file *file, char __user *userbuf,
 130                                                 size_t count, loff_t *ppos)
 131 {
 132         struct seq_file *sf = file->private_data;
 133         struct pstore_private *ps = sf->private;
 134
 135         if (ps->record->type == PSTORE_TYPE_FTRACE)
 136                 return seq_read(file, userbuf, count, ppos);
 137         return simple_read_from_buffer(userbuf, count, ppos,
 138                                        ps->record->buf, ps->total_size);
 139 }
 140
 141 static int pstore_file_open(struct inode *inode, struct file *file)
 142 {
 143         struct pstore_private *ps = inode->i_private;
 144         struct seq_file *sf;
 145         int err;
 146         const struct seq_operations *sops = NULL;
 147
 148         if (ps->record->type == PSTORE_TYPE_FTRACE)
 149                 sops = &pstore_ftrace_seq_ops;
 150
 151         err = seq_open(file, sops);
 152         if (err < 0)
 153                 return err;
 154
 155         sf = file->private_data;
 156         sf->private = ps;
 157
 158         return 0;
 159 }
 160
 161 static loff_t pstore_file_llseek(struct file *file, loff_t off, int whence)
 162 {
 163         struct seq_file *sf = file->private_data;
 164
 165         if (sf->op)
 166                 return seq_lseek(file, off, whence);
 167         return default_llseek(file, off, whence);
 168 }
 169
 170 static const struct file_operations pstore_file_operations = {
 171         .open           = pstore_file_open,
 172         .read           = pstore_file_read,
 173         .llseek         = pstore_file_llseek,
 174         .release        = seq_release,
 175 };
 176
 177 /*
 178  * When a file is unlinked from our file system we call the
 179  * platform driver to erase the record from persistent store.
 180  */
 181 static int pstore_unlink(struct inode *dir, struct dentry *dentry)
 182 {
 183         struct pstore_private *p = d_inode(dentry)->i_private;
 184         struct pstore_record *record = p->record;
 185
 186         if (!record->psi->erase)
 187                 return -EPERM;
 188
 189         /* Make sure we can't race while removing this file. */
 190         scoped_guard(mutex, &records_list_lock) {
 191                 if (!list_empty(&p->list))
 192                         list_del_init(&p->list);
 193                 else
 194                         return -ENOENT;
 195                 p->dentry = NULL;
 196         }
 197
 198         scoped_guard(mutex, &record->psi->read_mutex)
 199                 record->psi->erase(record);
 200
 201         return simple_unlink(dir, dentry);
 202 }
 203
 204 static void pstore_evict_inode(struct inode *inode)
 205 {
 206         struct pstore_private   *p = inode->i_private;
 207
 208         clear_inode(inode);
 209         free_pstore_private(p);
 210 }
 211
 212 static const struct inode_operations pstore_dir_inode_operations = {
 213         .lookup         = simple_lookup,
 214         .unlink         = pstore_unlink,
 215 };
 216
 217 static struct inode *pstore_get_inode(struct super_block *sb)
 218 {
 219         struct inode *inode = new_inode(sb);
 220         if (inode) {
 221                 inode->i_ino = get_next_ino();
 222                 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 223         }
 224         return inode;
 225 }
 226
 227 enum {
 228         Opt_kmsg_bytes, Opt_err
 229 };
 230
 231 static const match_table_t tokens = {
 232         {Opt_kmsg_bytes, "kmsg_bytes=%u"},
 233         {Opt_err, NULL}
 234 };
 235
 236 static void parse_options(char *options)
 237 {
 238         char            *p;
 239         substring_t     args[MAX_OPT_ARGS];
 240         int             option;
 241
 242         if (!options)
 243                 return;
 244
 245         while ((p = strsep(&options, ",")) != NULL) {
 246                 int token;
 247
 248                 if (!*p)
 249                         continue;
 250
 251                 token = match_token(p, tokens, args);
 252                 switch (token) {
 253                 case Opt_kmsg_bytes:
 254                         if (!match_int(&args[0], &option))
 255                                 pstore_set_kmsg_bytes(option);
 256                         break;
 257                 }
 258         }
 259 }
 260
 261 /*
 262  * Display the mount options in /proc/mounts.
 263  */
 264 static int pstore_show_options(struct seq_file *m, struct dentry *root)
 265 {
 266         if (kmsg_bytes != CONFIG_PSTORE_DEFAULT_KMSG_BYTES)
 267                 seq_printf(m, ",kmsg_bytes=%lu", kmsg_bytes);
 268         return 0;
 269 }
 270
 271 static int pstore_remount(struct super_block *sb, int *flags, char *data)
 272 {
 273         sync_filesystem(sb);
 274         parse_options(data);
 275
 276         return 0;
 277 }
 278
 279 static const struct super_operations pstore_ops = {
 280         .statfs         = simple_statfs,
 281         .drop_inode     = generic_delete_inode,
 282         .evict_inode    = pstore_evict_inode,
 283         .remount_fs     = pstore_remount,
 284         .show_options   = pstore_show_options,
 285 };
 286
 287 static struct dentry *psinfo_lock_root(void)
 288 {
 289         struct dentry *root;
 290
 291         guard(mutex)(&pstore_sb_lock);
 292         /*
 293          * Having no backend is fine -- no records appear.
 294          * Not being mounted is fine -- nothing to do.
 295          */
 296         if (!psinfo || !pstore_sb)
 297                 return NULL;
 298
 299         root = pstore_sb->s_root;
 300         inode_lock(d_inode(root));
 301
 302         return root;
 303 }
 304
 305 int pstore_put_backend_records(struct pstore_info *psi)
 306 {
 307         struct pstore_private *pos, *tmp;
 308         struct dentry *root;
 309
 310         root = psinfo_lock_root();
 311         if (!root)
 312                 return 0;
 313
 314         scoped_guard(mutex, &records_list_lock) {
 315                 list_for_each_entry_safe(pos, tmp, &records_list, list) {
 316                         if (pos->record->psi == psi) {
 317                                 list_del_init(&pos->list);
 318                                 d_invalidate(pos->dentry);
 319                                 simple_unlink(d_inode(root), pos->dentry);
 320                                 pos->dentry = NULL;
 321                         }
 322                 }
 323         }
 324
 325         inode_unlock(d_inode(root));
 326
 327         return 0;
 328 }
 329
 330 /*
 331  * Make a regular file in the root directory of our file system.
 332  * Load it up with "size" bytes of data from "buf".
 333  * Set the mtime & ctime to the date that this record was originally stored.
 334  */
 335 int pstore_mkfile(struct dentry *root, struct pstore_record *record)
 336 {
 337         struct dentry           *dentry;
 338         struct inode            *inode;
 339         int                     rc = 0;
 340         char                    name[PSTORE_NAMELEN];
 341         struct pstore_private   *private, *pos;
 342         size_t                  size = record->size + record->ecc_notice_size;
 343
 344         if (WARN_ON(!inode_is_locked(d_inode(root))))
 345                 return -EINVAL;
 346
 347         guard(mutex)(&records_list_lock);
 348
 349         /* Skip records that are already present in the filesystem. */
 350         list_for_each_entry(pos, &records_list, list) {
 351                 if (pos->record->type == record->type &&
 352                     pos->record->id == record->id &&
 353                     pos->record->psi == record->psi)
 354                         return -EEXIST;
 355         }
 356
 357         rc = -ENOMEM;
 358         inode = pstore_get_inode(root->d_sb);
 359         if (!inode)
 360                 return -ENOMEM;
 361         inode->i_mode = S_IFREG | 0444;
 362         inode->i_fop = &pstore_file_operations;
 363         scnprintf(name, sizeof(name), "%s-%s-%llu%s",
 364                         pstore_type_to_name(record->type),
 365                         record->psi->name, record->id,
 366                         record->compressed ? ".enc.z" : "");
 367
 368         private = kzalloc(sizeof(*private), GFP_KERNEL);
 369         if (!private)
 370                 goto fail_inode;
 371
 372         dentry = d_alloc_name(root, name);
 373         if (!dentry)
 374                 goto fail_private;
 375
 376         private->dentry = dentry;
 377         private->record = record;
 378         inode->i_size = private->total_size = size;
 379         inode->i_private = private;
 380
 381         if (record->time.tv_sec)
 382                 inode->i_mtime = inode->i_ctime = record->time;
 383
 384         d_add(dentry, inode);
 385
 386         list_add(&private->list, &records_list);
 387
 388         return 0;
 389
 390 fail_private:
 391         free_pstore_private(private);
 392 fail_inode:
 393         iput(inode);
 394         return rc;
 395 }
 396
 397 /*
 398  * Read all the records from the persistent store. Create
 399  * files in our filesystem.  Don't warn about -EEXIST errors
 400  * when we are re-scanning the backing store looking to add new
 401  * error records.
 402  */
 403 void pstore_get_records(int quiet)
 404 {
 405         struct dentry *root;
 406
 407         root = psinfo_lock_root();
 408         if (!root)
 409                 return;
 410
 411         pstore_get_backend_records(psinfo, root, quiet);
 412         inode_unlock(d_inode(root));
 413 }
 414
 415 static int pstore_fill_super(struct super_block *sb, void *data, int silent)
 416 {
 417         struct inode *inode;
 418
 419         sb->s_maxbytes          = MAX_LFS_FILESIZE;
 420         sb->s_blocksize         = PAGE_SIZE;
 421         sb->s_blocksize_bits    = PAGE_SHIFT;
 422         sb->s_magic             = PSTOREFS_MAGIC;
 423         sb->s_op                = &pstore_ops;
 424         sb->s_time_gran         = 1;
 425
 426         parse_options(data);
 427
 428         inode = pstore_get_inode(sb);
 429         if (inode) {
 430                 inode->i_mode = S_IFDIR | 0750;
 431                 inode->i_op = &pstore_dir_inode_operations;
 432                 inode->i_fop = &simple_dir_operations;
 433                 inc_nlink(inode);
 434         }
 435         sb->s_root = d_make_root(inode);
 436         if (!sb->s_root)
 437                 return -ENOMEM;
 438
 439         scoped_guard(mutex, &pstore_sb_lock)
 440                 pstore_sb = sb;
 441
 442         pstore_get_records(0);
 443
 444         return 0;
 445 }
 446
 447 static struct dentry *pstore_mount(struct file_system_type *fs_type,
 448         int flags, const char *dev_name, void *data)
 449 {
 450         return mount_single(fs_type, flags, data, pstore_fill_super);
 451 }
 452
 453 static void pstore_kill_sb(struct super_block *sb)
 454 {
 455         guard(mutex)(&pstore_sb_lock);
 456         WARN_ON(pstore_sb && pstore_sb != sb);
 457
 458         kill_litter_super(sb);
 459         pstore_sb = NULL;
 460
 461         guard(mutex)(&records_list_lock);
 462         INIT_LIST_HEAD(&records_list);
 463 }
 464
 465 static struct file_system_type pstore_fs_type = {
 466         .owner          = THIS_MODULE,
 467         .name           = "pstore",
 468         .mount          = pstore_mount,
 469         .kill_sb        = pstore_kill_sb,
 470 };
 471
 472 int __init pstore_init_fs(void)
 473 {
 474         int err;
 475
 476         /* Create a convenient mount point for people to access pstore */
 477         err = sysfs_create_mount_point(fs_kobj, "pstore");
 478         if (err)
 479                 goto out;
 480
 481         err = register_filesystem(&pstore_fs_type);
 482         if (err < 0)
 483                 sysfs_remove_mount_point(fs_kobj, "pstore");
 484
 485 out:
 486         return err;
 487 }
 488
 489 void __exit pstore_exit_fs(void)
 490 {
 491         unregister_filesystem(&pstore_fs_type);
 492         sysfs_remove_mount_point(fs_kobj, "pstore");
 493 }