linux/fs/pstore/inode.c
<<
>>
Prefs
   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
  44static DEFINE_SPINLOCK(allpstore_lock);
  45static LIST_HEAD(allpstore);
  46
  47struct 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
  57struct 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
  65static 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
  85static void pstore_ftrace_seq_stop(struct seq_file *s, void *v)
  86{
  87        kfree(v);
  88}
  89
  90static 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
 103static 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
 116static 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
 123static 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
 134static 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
 154static 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
 163static 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 */
 174static 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
 182        return simple_unlink(dir, dentry);
 183}
 184
 185static void pstore_evict_inode(struct inode *inode)
 186{
 187        struct pstore_private   *p = inode->i_private;
 188        unsigned long           flags;
 189
 190        clear_inode(inode);
 191        if (p) {
 192                spin_lock_irqsave(&allpstore_lock, flags);
 193                list_del(&p->list);
 194                spin_unlock_irqrestore(&allpstore_lock, flags);
 195                kfree(p);
 196        }
 197}
 198
 199static const struct inode_operations pstore_dir_inode_operations = {
 200        .lookup         = simple_lookup,
 201        .unlink         = pstore_unlink,
 202};
 203
 204static struct inode *pstore_get_inode(struct super_block *sb)
 205{
 206        struct inode *inode = new_inode(sb);
 207        if (inode) {
 208                inode->i_ino = get_next_ino();
 209                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 210        }
 211        return inode;
 212}
 213
 214enum {
 215        Opt_kmsg_bytes, Opt_err
 216};
 217
 218static const match_table_t tokens = {
 219        {Opt_kmsg_bytes, "kmsg_bytes=%u"},
 220        {Opt_err, NULL}
 221};
 222
 223static void parse_options(char *options)
 224{
 225        char            *p;
 226        substring_t     args[MAX_OPT_ARGS];
 227        int             option;
 228
 229        if (!options)
 230                return;
 231
 232        while ((p = strsep(&options, ",")) != NULL) {
 233                int token;
 234
 235                if (!*p)
 236                        continue;
 237
 238                token = match_token(p, tokens, args);
 239                switch (token) {
 240                case Opt_kmsg_bytes:
 241                        if (!match_int(&args[0], &option))
 242                                pstore_set_kmsg_bytes(option);
 243                        break;
 244                }
 245        }
 246}
 247
 248static int pstore_remount(struct super_block *sb, int *flags, char *data)
 249{
 250        parse_options(data);
 251
 252        return 0;
 253}
 254
 255static const struct super_operations pstore_ops = {
 256        .statfs         = simple_statfs,
 257        .drop_inode     = generic_delete_inode,
 258        .evict_inode    = pstore_evict_inode,
 259        .remount_fs     = pstore_remount,
 260        .show_options   = generic_show_options,
 261};
 262
 263static struct super_block *pstore_sb;
 264
 265int pstore_is_mounted(void)
 266{
 267        return pstore_sb != NULL;
 268}
 269
 270/*
 271 * Make a regular file in the root directory of our file system.
 272 * Load it up with "size" bytes of data from "buf".
 273 * Set the mtime & ctime to the date that this record was originally stored.
 274 */
 275int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count,
 276                  char *data, size_t size, struct timespec time,
 277                  struct pstore_info *psi)
 278{
 279        struct dentry           *root = pstore_sb->s_root;
 280        struct dentry           *dentry;
 281        struct inode            *inode;
 282        int                     rc = 0;
 283        char                    name[PSTORE_NAMELEN];
 284        struct pstore_private   *private, *pos;
 285        unsigned long           flags;
 286
 287        spin_lock_irqsave(&allpstore_lock, flags);
 288        list_for_each_entry(pos, &allpstore, list) {
 289                if (pos->type == type &&
 290                    pos->id == id &&
 291                    pos->psi == psi) {
 292                        rc = -EEXIST;
 293                        break;
 294                }
 295        }
 296        spin_unlock_irqrestore(&allpstore_lock, flags);
 297        if (rc)
 298                return rc;
 299
 300        rc = -ENOMEM;
 301        inode = pstore_get_inode(pstore_sb);
 302        if (!inode)
 303                goto fail;
 304        inode->i_mode = S_IFREG | 0444;
 305        inode->i_fop = &pstore_file_operations;
 306        private = kmalloc(sizeof *private + size, GFP_KERNEL);
 307        if (!private)
 308                goto fail_alloc;
 309        private->type = type;
 310        private->id = id;
 311        private->count = count;
 312        private->psi = psi;
 313
 314        switch (type) {
 315        case PSTORE_TYPE_DMESG:
 316                sprintf(name, "dmesg-%s-%lld", psname, id);
 317                break;
 318        case PSTORE_TYPE_CONSOLE:
 319                sprintf(name, "console-%s", psname);
 320                break;
 321        case PSTORE_TYPE_FTRACE:
 322                sprintf(name, "ftrace-%s", psname);
 323                break;
 324        case PSTORE_TYPE_MCE:
 325                sprintf(name, "mce-%s-%lld", psname, id);
 326                break;
 327        case PSTORE_TYPE_UNKNOWN:
 328                sprintf(name, "unknown-%s-%lld", psname, id);
 329                break;
 330        default:
 331                sprintf(name, "type%d-%s-%lld", type, psname, id);
 332                break;
 333        }
 334
 335        mutex_lock(&root->d_inode->i_mutex);
 336
 337        rc = -ENOSPC;
 338        dentry = d_alloc_name(root, name);
 339        if (IS_ERR(dentry))
 340                goto fail_lockedalloc;
 341
 342        memcpy(private->data, data, size);
 343        inode->i_size = private->size = size;
 344
 345        inode->i_private = private;
 346
 347        if (time.tv_sec)
 348                inode->i_mtime = inode->i_ctime = time;
 349
 350        d_add(dentry, inode);
 351
 352        spin_lock_irqsave(&allpstore_lock, flags);
 353        list_add(&private->list, &allpstore);
 354        spin_unlock_irqrestore(&allpstore_lock, flags);
 355
 356        mutex_unlock(&root->d_inode->i_mutex);
 357
 358        return 0;
 359
 360fail_lockedalloc:
 361        mutex_unlock(&root->d_inode->i_mutex);
 362        kfree(private);
 363fail_alloc:
 364        iput(inode);
 365
 366fail:
 367        return rc;
 368}
 369
 370static int pstore_fill_super(struct super_block *sb, void *data, int silent)
 371{
 372        struct inode *inode;
 373
 374        save_mount_options(sb, data);
 375
 376        pstore_sb = sb;
 377
 378        sb->s_maxbytes          = MAX_LFS_FILESIZE;
 379        sb->s_blocksize         = PAGE_CACHE_SIZE;
 380        sb->s_blocksize_bits    = PAGE_CACHE_SHIFT;
 381        sb->s_magic             = PSTOREFS_MAGIC;
 382        sb->s_op                = &pstore_ops;
 383        sb->s_time_gran         = 1;
 384
 385        parse_options(data);
 386
 387        inode = pstore_get_inode(sb);
 388        if (inode) {
 389                inode->i_mode = S_IFDIR | 0755;
 390                inode->i_op = &pstore_dir_inode_operations;
 391                inode->i_fop = &simple_dir_operations;
 392                inc_nlink(inode);
 393        }
 394        sb->s_root = d_make_root(inode);
 395        if (!sb->s_root)
 396                return -ENOMEM;
 397
 398        pstore_get_records(0);
 399
 400        return 0;
 401}
 402
 403static struct dentry *pstore_mount(struct file_system_type *fs_type,
 404        int flags, const char *dev_name, void *data)
 405{
 406        return mount_single(fs_type, flags, data, pstore_fill_super);
 407}
 408
 409static void pstore_kill_sb(struct super_block *sb)
 410{
 411        kill_litter_super(sb);
 412        pstore_sb = NULL;
 413}
 414
 415static struct file_system_type pstore_fs_type = {
 416        .name           = "pstore",
 417        .mount          = pstore_mount,
 418        .kill_sb        = pstore_kill_sb,
 419};
 420
 421static struct kobject *pstore_kobj;
 422
 423static int __init init_pstore_fs(void)
 424{
 425        int err = 0;
 426
 427        /* Create a convenient mount point for people to access pstore */
 428        pstore_kobj = kobject_create_and_add("pstore", fs_kobj);
 429        if (!pstore_kobj) {
 430                err = -ENOMEM;
 431                goto out;
 432        }
 433
 434        err = register_filesystem(&pstore_fs_type);
 435        if (err < 0)
 436                kobject_put(pstore_kobj);
 437
 438out:
 439        return err;
 440}
 441module_init(init_pstore_fs)
 442
 443MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
 444MODULE_LICENSE("GPL");
 445
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.