![Luck, Tony](/assets/img/avatar_default.png)
Life is simple for all the kernel terminating types of kmsg_dump call backs - pstore just saves the tail end of the console log. But for "oops" the situation is more complex - the kernel may carry on running (possibly for ever). So we'd like to make the logged copy of the oops appear in the pstore filesystem - so that the user has a handle to clear the entry from the persistent backing store (if we don't, the store may fill with "oops" entries (that are also safely stashed in /var/log/messages) leaving no space for real errors. Current code calls pstore_mkfile() immediately. But this may not be safe. The oops could have happened with arbitrary locks held, or in interrupt or NMI context. So allocating memory and calling into generic filesystem code seems unwise. This patch defers making the entry appear. At the time of the oops, we merely set a flag "pstore_new_entry" noting that a new entry has been added. A periodic timer checks once a minute to see if the flag is set - if so, it schedules a work queue to rescan the backing store and make all new entries appear in the pstore filesystem. Signed-off-by: Tony Luck <tony.luck@intel.com>
346 lines
7.6 KiB
C
346 lines
7.6 KiB
C
/*
|
|
* Persistent Storage - ramfs parts.
|
|
*
|
|
* Copyright (C) 2010 Intel Corporation <tony.luck@intel.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/fsnotify.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/highmem.h>
|
|
#include <linux/time.h>
|
|
#include <linux/init.h>
|
|
#include <linux/list.h>
|
|
#include <linux/string.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/ramfs.h>
|
|
#include <linux/parser.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/magic.h>
|
|
#include <linux/pstore.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
#include "internal.h"
|
|
|
|
#define PSTORE_NAMELEN 64
|
|
|
|
static DEFINE_SPINLOCK(allpstore_lock);
|
|
static LIST_HEAD(allpstore);
|
|
|
|
struct pstore_private {
|
|
struct list_head list;
|
|
struct pstore_info *psi;
|
|
enum pstore_type_id type;
|
|
u64 id;
|
|
ssize_t size;
|
|
char data[];
|
|
};
|
|
|
|
static int pstore_file_open(struct inode *inode, struct file *file)
|
|
{
|
|
file->private_data = inode->i_private;
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t pstore_file_read(struct file *file, char __user *userbuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct pstore_private *ps = file->private_data;
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, ps->data, ps->size);
|
|
}
|
|
|
|
static const struct file_operations pstore_file_operations = {
|
|
.open = pstore_file_open,
|
|
.read = pstore_file_read,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
/*
|
|
* When a file is unlinked from our file system we call the
|
|
* platform driver to erase the record from persistent store.
|
|
*/
|
|
static int pstore_unlink(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
struct pstore_private *p = dentry->d_inode->i_private;
|
|
|
|
p->psi->erase(p->type, p->id, p->psi);
|
|
|
|
return simple_unlink(dir, dentry);
|
|
}
|
|
|
|
static void pstore_evict_inode(struct inode *inode)
|
|
{
|
|
struct pstore_private *p = inode->i_private;
|
|
unsigned long flags;
|
|
|
|
end_writeback(inode);
|
|
if (p) {
|
|
spin_lock_irqsave(&allpstore_lock, flags);
|
|
list_del(&p->list);
|
|
spin_unlock_irqrestore(&allpstore_lock, flags);
|
|
kfree(p);
|
|
}
|
|
}
|
|
|
|
static const struct inode_operations pstore_dir_inode_operations = {
|
|
.lookup = simple_lookup,
|
|
.unlink = pstore_unlink,
|
|
};
|
|
|
|
static struct inode *pstore_get_inode(struct super_block *sb,
|
|
const struct inode *dir, int mode, dev_t dev)
|
|
{
|
|
struct inode *inode = new_inode(sb);
|
|
|
|
if (inode) {
|
|
inode->i_ino = get_next_ino();
|
|
inode->i_uid = inode->i_gid = 0;
|
|
inode->i_mode = mode;
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
|
switch (mode & S_IFMT) {
|
|
case S_IFREG:
|
|
inode->i_fop = &pstore_file_operations;
|
|
break;
|
|
case S_IFDIR:
|
|
inode->i_op = &pstore_dir_inode_operations;
|
|
inode->i_fop = &simple_dir_operations;
|
|
inc_nlink(inode);
|
|
break;
|
|
}
|
|
}
|
|
return inode;
|
|
}
|
|
|
|
enum {
|
|
Opt_kmsg_bytes, Opt_err
|
|
};
|
|
|
|
static const match_table_t tokens = {
|
|
{Opt_kmsg_bytes, "kmsg_bytes=%u"},
|
|
{Opt_err, NULL}
|
|
};
|
|
|
|
static void parse_options(char *options)
|
|
{
|
|
char *p;
|
|
substring_t args[MAX_OPT_ARGS];
|
|
int option;
|
|
|
|
if (!options)
|
|
return;
|
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
|
int token;
|
|
|
|
if (!*p)
|
|
continue;
|
|
|
|
token = match_token(p, tokens, args);
|
|
switch (token) {
|
|
case Opt_kmsg_bytes:
|
|
if (!match_int(&args[0], &option))
|
|
pstore_set_kmsg_bytes(option);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int pstore_remount(struct super_block *sb, int *flags, char *data)
|
|
{
|
|
parse_options(data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct super_operations pstore_ops = {
|
|
.statfs = simple_statfs,
|
|
.drop_inode = generic_delete_inode,
|
|
.evict_inode = pstore_evict_inode,
|
|
.remount_fs = pstore_remount,
|
|
.show_options = generic_show_options,
|
|
};
|
|
|
|
static struct super_block *pstore_sb;
|
|
|
|
int pstore_is_mounted(void)
|
|
{
|
|
return pstore_sb != NULL;
|
|
}
|
|
|
|
/*
|
|
* Make a regular file in the root directory of our file system.
|
|
* Load it up with "size" bytes of data from "buf".
|
|
* Set the mtime & ctime to the date that this record was originally stored.
|
|
*/
|
|
int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id,
|
|
char *data, size_t size, struct timespec time,
|
|
struct pstore_info *psi)
|
|
{
|
|
struct dentry *root = pstore_sb->s_root;
|
|
struct dentry *dentry;
|
|
struct inode *inode;
|
|
int rc = 0;
|
|
char name[PSTORE_NAMELEN];
|
|
struct pstore_private *private, *pos;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&allpstore_lock, flags);
|
|
list_for_each_entry(pos, &allpstore, list) {
|
|
if (pos->type == type &&
|
|
pos->id == id &&
|
|
pos->psi == psi) {
|
|
rc = -EEXIST;
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&allpstore_lock, flags);
|
|
if (rc)
|
|
return rc;
|
|
|
|
rc = -ENOMEM;
|
|
inode = pstore_get_inode(pstore_sb, root->d_inode, S_IFREG | 0444, 0);
|
|
if (!inode)
|
|
goto fail;
|
|
private = kmalloc(sizeof *private + size, GFP_KERNEL);
|
|
if (!private)
|
|
goto fail_alloc;
|
|
private->type = type;
|
|
private->id = id;
|
|
private->psi = psi;
|
|
|
|
switch (type) {
|
|
case PSTORE_TYPE_DMESG:
|
|
sprintf(name, "dmesg-%s-%lld", psname, id);
|
|
break;
|
|
case PSTORE_TYPE_MCE:
|
|
sprintf(name, "mce-%s-%lld", psname, id);
|
|
break;
|
|
case PSTORE_TYPE_UNKNOWN:
|
|
sprintf(name, "unknown-%s-%lld", psname, id);
|
|
break;
|
|
default:
|
|
sprintf(name, "type%d-%s-%lld", type, psname, id);
|
|
break;
|
|
}
|
|
|
|
mutex_lock(&root->d_inode->i_mutex);
|
|
|
|
rc = -ENOSPC;
|
|
dentry = d_alloc_name(root, name);
|
|
if (IS_ERR(dentry))
|
|
goto fail_lockedalloc;
|
|
|
|
memcpy(private->data, data, size);
|
|
inode->i_size = private->size = size;
|
|
|
|
inode->i_private = private;
|
|
|
|
if (time.tv_sec)
|
|
inode->i_mtime = inode->i_ctime = time;
|
|
|
|
d_add(dentry, inode);
|
|
|
|
spin_lock_irqsave(&allpstore_lock, flags);
|
|
list_add(&private->list, &allpstore);
|
|
spin_unlock_irqrestore(&allpstore_lock, flags);
|
|
|
|
mutex_unlock(&root->d_inode->i_mutex);
|
|
|
|
return 0;
|
|
|
|
fail_lockedalloc:
|
|
mutex_unlock(&root->d_inode->i_mutex);
|
|
kfree(private);
|
|
fail_alloc:
|
|
iput(inode);
|
|
|
|
fail:
|
|
return rc;
|
|
}
|
|
|
|
int pstore_fill_super(struct super_block *sb, void *data, int silent)
|
|
{
|
|
struct inode *inode = NULL;
|
|
struct dentry *root;
|
|
int err;
|
|
|
|
save_mount_options(sb, data);
|
|
|
|
pstore_sb = sb;
|
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
|
sb->s_blocksize = PAGE_CACHE_SIZE;
|
|
sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
|
|
sb->s_magic = PSTOREFS_MAGIC;
|
|
sb->s_op = &pstore_ops;
|
|
sb->s_time_gran = 1;
|
|
|
|
parse_options(data);
|
|
|
|
inode = pstore_get_inode(sb, NULL, S_IFDIR | 0755, 0);
|
|
if (!inode) {
|
|
err = -ENOMEM;
|
|
goto fail;
|
|
}
|
|
/* override ramfs "dir" options so we catch unlink(2) */
|
|
inode->i_op = &pstore_dir_inode_operations;
|
|
|
|
root = d_alloc_root(inode);
|
|
sb->s_root = root;
|
|
if (!root) {
|
|
err = -ENOMEM;
|
|
goto fail;
|
|
}
|
|
|
|
pstore_get_records(0);
|
|
|
|
return 0;
|
|
fail:
|
|
iput(inode);
|
|
return err;
|
|
}
|
|
|
|
static struct dentry *pstore_mount(struct file_system_type *fs_type,
|
|
int flags, const char *dev_name, void *data)
|
|
{
|
|
return mount_single(fs_type, flags, data, pstore_fill_super);
|
|
}
|
|
|
|
static void pstore_kill_sb(struct super_block *sb)
|
|
{
|
|
kill_litter_super(sb);
|
|
pstore_sb = NULL;
|
|
}
|
|
|
|
static struct file_system_type pstore_fs_type = {
|
|
.name = "pstore",
|
|
.mount = pstore_mount,
|
|
.kill_sb = pstore_kill_sb,
|
|
};
|
|
|
|
static int __init init_pstore_fs(void)
|
|
{
|
|
return register_filesystem(&pstore_fs_type);
|
|
}
|
|
module_init(init_pstore_fs)
|
|
|
|
MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
|
|
MODULE_LICENSE("GPL");
|