fs/pstore/inode.c

   1 /*
   2  * Persistent Storage - ramfs parts.
   3  *
   4  * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License version 2 as
   8  *  published by the Free Software Foundation.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/fs.h>
  22 #include <linux/fsnotify.h>
  23 #include <linux/pagemap.h>
  24 #include <linux/highmem.h>
  25 #include <linux/time.h>
  26 #include <linux/init.h>
  27 #include <linux/list.h>
  28 #include <linux/string.h>
  29 #include <linux/mount.h>
  30 #include <linux/seq_file.h>
  31 #include <linux/ramfs.h>
  32 #include <linux/parser.h>
  33 #include <linux/sched.h>
  34 #include <linux/magic.h>
  35 #include <linux/pstore.h>
  36 #include <linux/slab.h>
  37 #include <linux/spinlock.h>
  38 #include <linux/uaccess.h>
  39
  40 #include "internal.h"
  41
  42 #define PSTORE_NAMELEN  64
  43
  44 static DEFINE_SPINLOCK(allpstore_lock);
  45 static LIST_HEAD(allpstore);
  46
  47 struct pstore_private {
  48         struct list_head list;
  49         struct pstore_info *psi;
  50         enum pstore_type_id type;
  51         u64     id;
  52         int     count;
  53         ssize_t size;
  54         char    data[];
  55 };
  56
  57 struct pstore_ftrace_seq_data {
  58         const void *ptr;
  59         size_t off;
  60         size_t size;
  61 };
  62
  63 #define REC_SIZE sizeof(struct pstore_ftrace_record)
  64
  65 static void *pstore_ftrace_seq_start(struct seq_file *s, loff_t *pos)
  66 {
  67         struct pstore_private *ps = s->private;
  68         struct pstore_ftrace_seq_data *data;
  69
  70         data = kzalloc(sizeof(*data), GFP_KERNEL);
  71         if (!data)
  72                 return NULL;
  73
  74         data->off = ps->size % REC_SIZE;
  75         data->off += *pos * REC_SIZE;
  76         if (data->off + REC_SIZE > ps->size) {
  77                 kfree(data);
  78                 return NULL;
  79         }
  80
  81         return data;
  82
  83 }
  84
  85 static void pstore_ftrace_seq_stop(struct seq_file *s, void *v)
  86 {
  87         kfree(v);
  88 }
  89
  90 static void *pstore_ftrace_seq_next(struct seq_file *s, void *v, loff_t *pos)
  91 {
  92         struct pstore_private *ps = s->private;
  93         struct pstore_ftrace_seq_data *data = v;
  94
  95         data->off += REC_SIZE;
  96         if (data->off + REC_SIZE > ps->size)
  97                 return NULL;
  98
  99         (*pos)++;
 100         return data;
 101 }
 102
 103 static int pstore_ftrace_seq_show(struct seq_file *s, void *v)
 104 {
 105         struct pstore_private *ps = s->private;
 106         struct pstore_ftrace_seq_data *data = v;
 107         struct pstore_ftrace_record *rec = (void *)(ps->data + data->off);
 108
 109         seq_printf(s, "%d %08lx  %08lx  %pf <- %pF\n",
 110                 pstore_ftrace_decode_cpu(rec), rec->ip, rec->parent_ip,
 111                 (void *)rec->ip, (void *)rec->parent_ip);
 112
 113         return 0;
 114 }
 115
 116 static const struct seq_operations pstore_ftrace_seq_ops = {
 117         .start  = pstore_ftrace_seq_start,
 118         .next   = pstore_ftrace_seq_next,
 119         .stop   = pstore_ftrace_seq_stop,
 120         .show   = pstore_ftrace_seq_show,
 121 };
 122
 123 static ssize_t pstore_file_read(struct file *file, char __user *userbuf,
 124                                                 size_t count, loff_t *ppos)
 125 {
 126         struct seq_file *sf = file->private_data;
 127         struct pstore_private *ps = sf->private;
 128
 129         if (ps->type == PSTORE_TYPE_FTRACE)
 130                 return seq_read(file, userbuf, count, ppos);
 131         return simple_read_from_buffer(userbuf, count, ppos, ps->data, ps->size);
 132 }
 133
 134 static int pstore_file_open(struct inode *inode, struct file *file)
 135 {
 136         struct pstore_private *ps = inode->i_private;
 137         struct seq_file *sf;
 138         int err;
 139         const struct seq_operations *sops = NULL;
 140
 141         if (ps->type == PSTORE_TYPE_FTRACE)
 142                 sops = &pstore_ftrace_seq_ops;
 143
 144         err = seq_open(file, sops);
 145         if (err < 0)
 146                 return err;
 147
 148         sf = file->private_data;
 149         sf->private = ps;
 150
 151         return 0;
 152 }
 153
 154 static loff_t pstore_file_llseek(struct file *file, loff_t off, int whence)
 155 {
 156         struct seq_file *sf = file->private_data;
 157
 158         if (sf->op)
 159                 return seq_lseek(file, off, whence);
 160         return default_llseek(file, off, whence);
 161 }
 162
 163 static const struct file_operations pstore_file_operations = {
 164         .open           = pstore_file_open,
 165         .read           = pstore_file_read,
 166         .llseek         = pstore_file_llseek,
 167         .release        = seq_release,
 168 };
 169
 170 /*
 171  * When a file is unlinked from our file system we call the
 172  * platform driver to erase the record from persistent store.
 173  */
 174 static int pstore_unlink(struct inode *dir, struct dentry *dentry)
 175 {
 176         struct pstore_private *p = dentry->d_inode->i_private;
 177
 178         if (p->psi->erase)
 179                 p->psi->erase(p->type, p->id, p->count,
 180                               dentry->d_inode->i_ctime, p->psi);
 181         else
 182                 return -EPERM;
 183
 184         return simple_unlink(dir, dentry);
 185 }
 186
 187 static void pstore_evict_inode(struct inode *inode)
 188 {
 189         struct pstore_private   *p = inode->i_private;
 190         unsigned long           flags;
 191
 192         clear_inode(inode);
 193         if (p) {
 194                 spin_lock_irqsave(&allpstore_lock, flags);
 195                 list_del(&p->list);
 196                 spin_unlock_irqrestore(&allpstore_lock, flags);
 197                 kfree(p);
 198         }
 199 }
 200
 201 static const struct inode_operations pstore_dir_inode_operations = {
 202         .lookup         = simple_lookup,
 203         .unlink         = pstore_unlink,
 204 };
 205
 206 static struct inode *pstore_get_inode(struct super_block *sb)
 207 {
 208         struct inode *inode = new_inode(sb);
 209         if (inode) {
 210                 inode->i_ino = get_next_ino();
 211                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 212         }
 213         return inode;
 214 }
 215
 216 enum {
 217         Opt_kmsg_bytes, Opt_err
 218 };
 219
 220 static const match_table_t tokens = {
 221         {Opt_kmsg_bytes, "kmsg_bytes=%u"},
 222         {Opt_err, NULL}
 223 };
 224
 225 static void parse_options(char *options)
 226 {
 227         char            *p;
 228         substring_t     args[MAX_OPT_ARGS];
 229         int             option;
 230
 231         if (!options)
 232                 return;
 233
 234         while ((p = strsep(&options, ",")) != NULL) {
 235                 int token;
 236
 237                 if (!*p)
 238                         continue;
 239
 240                 token = match_token(p, tokens, args);
 241                 switch (token) {
 242                 case Opt_kmsg_bytes:
 243                         if (!match_int(&args[0], &option))
 244                                 pstore_set_kmsg_bytes(option);
 245                         break;
 246                 }
 247         }
 248 }
 249
 250 static int pstore_remount(struct super_block *sb, int *flags, char *data)
 251 {
 252         sync_filesystem(sb);
 253         parse_options(data);
 254
 255         return 0;
 256 }
 257
 258 static const struct super_operations pstore_ops = {
 259         .statfs         = simple_statfs,
 260         .drop_inode     = generic_delete_inode,
 261         .evict_inode    = pstore_evict_inode,
 262         .remount_fs     = pstore_remount,
 263         .show_options   = generic_show_options,
 264 };
 265
 266 static struct super_block *pstore_sb;
 267
 268 int pstore_is_mounted(void)
 269 {
 270         return pstore_sb != NULL;
 271 }
 272
 273 /*
 274  * Make a regular file in the root directory of our file system.
 275  * Load it up with "size" bytes of data from "buf".
 276  * Set the mtime & ctime to the date that this record was originally stored.
 277  */
 278 int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
 279                   char *data, bool compressed, size_t size,
 280                   struct timespec time, struct pstore_info *psi)
 281 {
 282         struct dentry           *root = pstore_sb->s_root;
 283         struct dentry           *dentry;
 284         struct inode            *inode;
 285         int                     rc = 0;
 286         char                    name[PSTORE_NAMELEN];
 287         struct pstore_private   *private, *pos;
 288         unsigned long           flags;
 289
 290         spin_lock_irqsave(&allpstore_lock, flags);
 291         list_for_each_entry(pos, &allpstore, list) {
 292                 if (pos->type == type &&
 293                     pos->id == id &&
 294                     pos->psi == psi) {
 295                         rc = -EEXIST;
 296                         break;
 297                 }
 298         }
 299         spin_unlock_irqrestore(&allpstore_lock, flags);
 300         if (rc)
 301                 return rc;
 302
 303         rc = -ENOMEM;
 304         inode = pstore_get_inode(pstore_sb);
 305         if (!inode)
 306                 goto fail;
 307         inode->i_mode = S_IFREG | 0444;
 308         inode->i_fop = &pstore_file_operations;
 309         private = kmalloc(sizeof *private + size, GFP_KERNEL);
 310         if (!private)
 311                 goto fail_alloc;
 312         private->type = type;
 313         private->id = id;
 314         private->count = count;
 315         private->psi = psi;
 316
 317         switch (type) {
 318         case PSTORE_TYPE_DMESG:
 319                 sprintf(name, "dmesg-%s-%lld%s", psname, id,
 320                                                 compressed ? ".enc.z" : "");
 321                 break;
 322         case PSTORE_TYPE_CONSOLE:
 323                 sprintf(name, "console-%s", psname);
 324                 break;
 325         case PSTORE_TYPE_FTRACE:
 326                 sprintf(name, "ftrace-%s", psname);
 327                 break;
 328         case PSTORE_TYPE_MCE:
 329                 sprintf(name, "mce-%s-%lld", psname, id);
 330                 break;
 331         case PSTORE_TYPE_PPC_RTAS:
 332                 sprintf(name, "rtas-%s-%lld", psname, id);
 333                 break;
 334         case PSTORE_TYPE_PPC_OF:
 335                 sprintf(name, "powerpc-ofw-%s-%lld", psname, id);
 336                 break;
 337         case PSTORE_TYPE_PPC_COMMON:
 338                 sprintf(name, "powerpc-common-%s-%lld", psname, id);
 339                 break;
 340         case PSTORE_TYPE_UNKNOWN:
 341                 sprintf(name, "unknown-%s-%lld", psname, id);
 342                 break;
 343         default:
 344                 sprintf(name, "type%d-%s-%lld", type, psname, id);
 345                 break;
 346         }
 347
 348         mutex_lock(&root->d_inode->i_mutex);
 349
 350         dentry = d_alloc_name(root, name);
 351         if (!dentry)
 352                 goto fail_lockedalloc;
 353
 354         memcpy(private->data, data, size);
 355         inode->i_size = private->size = size;
 356
 357         inode->i_private = private;
 358
 359         if (time.tv_sec)
 360                 inode->i_mtime = inode->i_ctime = time;
 361
 362         d_add(dentry, inode);
 363
 364         spin_lock_irqsave(&allpstore_lock, flags);
 365         list_add(&private->list, &allpstore);
 366         spin_unlock_irqrestore(&allpstore_lock, flags);
 367
 368         mutex_unlock(&root->d_inode->i_mutex);
 369
 370         return 0;
 371
 372 fail_lockedalloc:
 373         mutex_unlock(&root->d_inode->i_mutex);
 374         kfree(private);
 375 fail_alloc:
 376         iput(inode);
 377
 378 fail:
 379         return rc;
 380 }
 381
 382 static int pstore_fill_super(struct super_block *sb, void *data, int silent)
 383 {
 384         struct inode *inode;
 385
 386         save_mount_options(sb, data);
 387
 388         pstore_sb = sb;
 389
 390         sb->s_maxbytes          = MAX_LFS_FILESIZE;
 391         sb->s_blocksize         = PAGE_CACHE_SIZE;
 392         sb->s_blocksize_bits    = PAGE_CACHE_SHIFT;
 393         sb->s_magic             = PSTOREFS_MAGIC;
 394         sb->s_op                = &pstore_ops;
 395         sb->s_time_gran         = 1;
 396
 397         parse_options(data);
 398
 399         inode = pstore_get_inode(sb);
 400         if (inode) {
 401                 inode->i_mode = S_IFDIR | 0755;
 402                 inode->i_op = &pstore_dir_inode_operations;
 403                 inode->i_fop = &simple_dir_operations;
 404                 inc_nlink(inode);
 405         }
 406         sb->s_root = d_make_root(inode);
 407         if (!sb->s_root)
 408                 return -ENOMEM;
 409
 410         pstore_get_records(0);
 411
 412         return 0;
 413 }
 414
 415 static struct dentry *pstore_mount(struct file_system_type *fs_type,
 416         int flags, const char *dev_name, void *data)
 417 {
 418         return mount_single(fs_type, flags, data, pstore_fill_super);
 419 }
 420
 421 static void pstore_kill_sb(struct super_block *sb)
 422 {
 423         kill_litter_super(sb);
 424         pstore_sb = NULL;
 425 }
 426
 427 static struct file_system_type pstore_fs_type = {
 428         .name           = "pstore",
 429         .mount          = pstore_mount,
 430         .kill_sb        = pstore_kill_sb,
 431 };
 432
 433 static struct kobject *pstore_kobj;
 434
 435 static int __init init_pstore_fs(void)
 436 {
 437         int err = 0;
 438
 439         /* Create a convenient mount point for people to access pstore */
 440         pstore_kobj = kobject_create_and_add("pstore", fs_kobj);
 441         if (!pstore_kobj) {
 442                 err = -ENOMEM;
 443                 goto out;
 444         }
 445
 446         err = register_filesystem(&pstore_fs_type);
 447         if (err < 0)
 448                 kobject_put(pstore_kobj);
 449
 450 out:
 451         return err;
 452 }
 453 module_init(init_pstore_fs)
 454
 455 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
 456 MODULE_LICENSE("GPL");