Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 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> |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 27 | #include <linux/list.h> |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 28 | #include <linux/string.h> |
| 29 | #include <linux/mount.h> |
| 30 | #include <linux/ramfs.h> |
Luck, Tony | 366f7e7 | 2011-03-18 15:33:43 -0700 | [diff] [blame] | 31 | #include <linux/parser.h> |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 32 | #include <linux/sched.h> |
| 33 | #include <linux/magic.h> |
| 34 | #include <linux/pstore.h> |
| 35 | #include <linux/slab.h> |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 36 | #include <linux/spinlock.h> |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 37 | #include <linux/uaccess.h> |
| 38 | |
| 39 | #include "internal.h" |
| 40 | |
| 41 | #define PSTORE_NAMELEN 64 |
| 42 | |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 43 | static DEFINE_SPINLOCK(allpstore_lock); |
| 44 | static LIST_HEAD(allpstore); |
| 45 | |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 46 | struct pstore_private { |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 47 | struct list_head list; |
Matthew Garrett | 638c1fd | 2011-07-21 16:57:52 -0400 | [diff] [blame] | 48 | struct pstore_info *psi; |
Matthew Garrett | 5628068 | 2011-07-21 16:57:53 -0400 | [diff] [blame] | 49 | enum pstore_type_id type; |
| 50 | u64 id; |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 51 | ssize_t size; |
| 52 | char data[]; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 53 | }; |
| 54 | |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 55 | static int pstore_file_open(struct inode *inode, struct file *file) |
| 56 | { |
| 57 | file->private_data = inode->i_private; |
| 58 | return 0; |
| 59 | } |
| 60 | |
| 61 | static ssize_t pstore_file_read(struct file *file, char __user *userbuf, |
| 62 | size_t count, loff_t *ppos) |
| 63 | { |
| 64 | struct pstore_private *ps = file->private_data; |
| 65 | |
| 66 | return simple_read_from_buffer(userbuf, count, ppos, ps->data, ps->size); |
| 67 | } |
| 68 | |
| 69 | static const struct file_operations pstore_file_operations = { |
| 70 | .open = pstore_file_open, |
| 71 | .read = pstore_file_read, |
| 72 | .llseek = default_llseek, |
| 73 | }; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 74 | |
| 75 | /* |
| 76 | * When a file is unlinked from our file system we call the |
| 77 | * platform driver to erase the record from persistent store. |
| 78 | */ |
| 79 | static int pstore_unlink(struct inode *dir, struct dentry *dentry) |
| 80 | { |
| 81 | struct pstore_private *p = dentry->d_inode->i_private; |
| 82 | |
Kees Cook | 2174f6d | 2011-11-18 13:49:00 -0800 | [diff] [blame] | 83 | if (p->psi->erase) |
| 84 | p->psi->erase(p->type, p->id, p->psi); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 85 | |
| 86 | return simple_unlink(dir, dentry); |
| 87 | } |
| 88 | |
Tony Luck | a872d51 | 2011-03-18 11:44:48 -0700 | [diff] [blame] | 89 | static void pstore_evict_inode(struct inode *inode) |
| 90 | { |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 91 | struct pstore_private *p = inode->i_private; |
| 92 | unsigned long flags; |
| 93 | |
Tony Luck | a872d51 | 2011-03-18 11:44:48 -0700 | [diff] [blame] | 94 | end_writeback(inode); |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 95 | if (p) { |
| 96 | spin_lock_irqsave(&allpstore_lock, flags); |
| 97 | list_del(&p->list); |
| 98 | spin_unlock_irqrestore(&allpstore_lock, flags); |
| 99 | kfree(p); |
| 100 | } |
Tony Luck | a872d51 | 2011-03-18 11:44:48 -0700 | [diff] [blame] | 101 | } |
| 102 | |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 103 | static const struct inode_operations pstore_dir_inode_operations = { |
| 104 | .lookup = simple_lookup, |
| 105 | .unlink = pstore_unlink, |
| 106 | }; |
| 107 | |
Al Viro | 22a71c3 | 2012-03-22 12:26:35 -0400 | [diff] [blame^] | 108 | static struct inode *pstore_get_inode(struct super_block *sb) |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 109 | { |
| 110 | struct inode *inode = new_inode(sb); |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 111 | if (inode) { |
| 112 | inode->i_ino = get_next_ino(); |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 113 | inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 114 | } |
| 115 | return inode; |
| 116 | } |
| 117 | |
Luck, Tony | 366f7e7 | 2011-03-18 15:33:43 -0700 | [diff] [blame] | 118 | enum { |
| 119 | Opt_kmsg_bytes, Opt_err |
| 120 | }; |
| 121 | |
| 122 | static const match_table_t tokens = { |
| 123 | {Opt_kmsg_bytes, "kmsg_bytes=%u"}, |
| 124 | {Opt_err, NULL} |
| 125 | }; |
| 126 | |
| 127 | static void parse_options(char *options) |
| 128 | { |
| 129 | char *p; |
| 130 | substring_t args[MAX_OPT_ARGS]; |
| 131 | int option; |
| 132 | |
| 133 | if (!options) |
| 134 | return; |
| 135 | |
| 136 | while ((p = strsep(&options, ",")) != NULL) { |
| 137 | int token; |
| 138 | |
| 139 | if (!*p) |
| 140 | continue; |
| 141 | |
| 142 | token = match_token(p, tokens, args); |
| 143 | switch (token) { |
| 144 | case Opt_kmsg_bytes: |
| 145 | if (!match_int(&args[0], &option)) |
| 146 | pstore_set_kmsg_bytes(option); |
| 147 | break; |
| 148 | } |
| 149 | } |
| 150 | } |
| 151 | |
| 152 | static int pstore_remount(struct super_block *sb, int *flags, char *data) |
| 153 | { |
| 154 | parse_options(data); |
| 155 | |
| 156 | return 0; |
| 157 | } |
| 158 | |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 159 | static const struct super_operations pstore_ops = { |
| 160 | .statfs = simple_statfs, |
| 161 | .drop_inode = generic_delete_inode, |
Tony Luck | a872d51 | 2011-03-18 11:44:48 -0700 | [diff] [blame] | 162 | .evict_inode = pstore_evict_inode, |
Luck, Tony | 366f7e7 | 2011-03-18 15:33:43 -0700 | [diff] [blame] | 163 | .remount_fs = pstore_remount, |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 164 | .show_options = generic_show_options, |
| 165 | }; |
| 166 | |
| 167 | static struct super_block *pstore_sb; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 168 | |
| 169 | int pstore_is_mounted(void) |
| 170 | { |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 171 | return pstore_sb != NULL; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | /* |
| 175 | * Make a regular file in the root directory of our file system. |
| 176 | * Load it up with "size" bytes of data from "buf". |
| 177 | * Set the mtime & ctime to the date that this record was originally stored. |
| 178 | */ |
| 179 | int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, |
Matthew Garrett | 638c1fd | 2011-07-21 16:57:52 -0400 | [diff] [blame] | 180 | char *data, size_t size, struct timespec time, |
| 181 | struct pstore_info *psi) |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 182 | { |
| 183 | struct dentry *root = pstore_sb->s_root; |
| 184 | struct dentry *dentry; |
| 185 | struct inode *inode; |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 186 | int rc = 0; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 187 | char name[PSTORE_NAMELEN]; |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 188 | struct pstore_private *private, *pos; |
| 189 | unsigned long flags; |
| 190 | |
| 191 | spin_lock_irqsave(&allpstore_lock, flags); |
| 192 | list_for_each_entry(pos, &allpstore, list) { |
| 193 | if (pos->type == type && |
| 194 | pos->id == id && |
| 195 | pos->psi == psi) { |
| 196 | rc = -EEXIST; |
| 197 | break; |
| 198 | } |
| 199 | } |
| 200 | spin_unlock_irqrestore(&allpstore_lock, flags); |
| 201 | if (rc) |
| 202 | return rc; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 203 | |
| 204 | rc = -ENOMEM; |
Al Viro | 22a71c3 | 2012-03-22 12:26:35 -0400 | [diff] [blame^] | 205 | inode = pstore_get_inode(pstore_sb); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 206 | if (!inode) |
| 207 | goto fail; |
Al Viro | 22a71c3 | 2012-03-22 12:26:35 -0400 | [diff] [blame^] | 208 | inode->i_mode = S_IFREG | 0444; |
| 209 | inode->i_fop = &pstore_file_operations; |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 210 | private = kmalloc(sizeof *private + size, GFP_KERNEL); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 211 | if (!private) |
| 212 | goto fail_alloc; |
Matthew Garrett | 5628068 | 2011-07-21 16:57:53 -0400 | [diff] [blame] | 213 | private->type = type; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 214 | private->id = id; |
Matthew Garrett | 638c1fd | 2011-07-21 16:57:52 -0400 | [diff] [blame] | 215 | private->psi = psi; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 216 | |
| 217 | switch (type) { |
| 218 | case PSTORE_TYPE_DMESG: |
| 219 | sprintf(name, "dmesg-%s-%lld", psname, id); |
| 220 | break; |
| 221 | case PSTORE_TYPE_MCE: |
| 222 | sprintf(name, "mce-%s-%lld", psname, id); |
| 223 | break; |
| 224 | case PSTORE_TYPE_UNKNOWN: |
| 225 | sprintf(name, "unknown-%s-%lld", psname, id); |
| 226 | break; |
| 227 | default: |
| 228 | sprintf(name, "type%d-%s-%lld", type, psname, id); |
| 229 | break; |
| 230 | } |
| 231 | |
| 232 | mutex_lock(&root->d_inode->i_mutex); |
| 233 | |
| 234 | rc = -ENOSPC; |
| 235 | dentry = d_alloc_name(root, name); |
| 236 | if (IS_ERR(dentry)) |
| 237 | goto fail_lockedalloc; |
| 238 | |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 239 | memcpy(private->data, data, size); |
| 240 | inode->i_size = private->size = size; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 241 | |
| 242 | inode->i_private = private; |
| 243 | |
| 244 | if (time.tv_sec) |
| 245 | inode->i_mtime = inode->i_ctime = time; |
| 246 | |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 247 | d_add(dentry, inode); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 248 | |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 249 | spin_lock_irqsave(&allpstore_lock, flags); |
| 250 | list_add(&private->list, &allpstore); |
| 251 | spin_unlock_irqrestore(&allpstore_lock, flags); |
| 252 | |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 253 | mutex_unlock(&root->d_inode->i_mutex); |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 254 | |
| 255 | return 0; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 256 | |
| 257 | fail_lockedalloc: |
| 258 | mutex_unlock(&root->d_inode->i_mutex); |
| 259 | kfree(private); |
| 260 | fail_alloc: |
| 261 | iput(inode); |
| 262 | |
| 263 | fail: |
| 264 | return rc; |
| 265 | } |
| 266 | |
| 267 | int pstore_fill_super(struct super_block *sb, void *data, int silent) |
| 268 | { |
Al Viro | 318ceed | 2012-02-12 22:08:01 -0500 | [diff] [blame] | 269 | struct inode *inode; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 270 | |
| 271 | save_mount_options(sb, data); |
| 272 | |
| 273 | pstore_sb = sb; |
| 274 | |
| 275 | sb->s_maxbytes = MAX_LFS_FILESIZE; |
| 276 | sb->s_blocksize = PAGE_CACHE_SIZE; |
| 277 | sb->s_blocksize_bits = PAGE_CACHE_SHIFT; |
| 278 | sb->s_magic = PSTOREFS_MAGIC; |
| 279 | sb->s_op = &pstore_ops; |
| 280 | sb->s_time_gran = 1; |
| 281 | |
Luck, Tony | 366f7e7 | 2011-03-18 15:33:43 -0700 | [diff] [blame] | 282 | parse_options(data); |
| 283 | |
Al Viro | 22a71c3 | 2012-03-22 12:26:35 -0400 | [diff] [blame^] | 284 | inode = pstore_get_inode(sb); |
Al Viro | 318ceed | 2012-02-12 22:08:01 -0500 | [diff] [blame] | 285 | if (inode) { |
Al Viro | 22a71c3 | 2012-03-22 12:26:35 -0400 | [diff] [blame^] | 286 | inode->i_mode = S_IFDIR | 0755; |
Al Viro | 318ceed | 2012-02-12 22:08:01 -0500 | [diff] [blame] | 287 | inode->i_op = &pstore_dir_inode_operations; |
Al Viro | 22a71c3 | 2012-03-22 12:26:35 -0400 | [diff] [blame^] | 288 | inode->i_fop = &simple_dir_operations; |
| 289 | inc_nlink(inode); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 290 | } |
Al Viro | 318ceed | 2012-02-12 22:08:01 -0500 | [diff] [blame] | 291 | sb->s_root = d_make_root(inode); |
| 292 | if (!sb->s_root) |
| 293 | return -ENOMEM; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 294 | |
Luck, Tony | 6dda926 | 2011-08-11 15:14:39 -0700 | [diff] [blame] | 295 | pstore_get_records(0); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 296 | |
| 297 | return 0; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 298 | } |
| 299 | |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 300 | static struct dentry *pstore_mount(struct file_system_type *fs_type, |
| 301 | int flags, const char *dev_name, void *data) |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 302 | { |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 303 | return mount_single(fs_type, flags, data, pstore_fill_super); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | static void pstore_kill_sb(struct super_block *sb) |
| 307 | { |
| 308 | kill_litter_super(sb); |
| 309 | pstore_sb = NULL; |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 310 | } |
| 311 | |
| 312 | static struct file_system_type pstore_fs_type = { |
| 313 | .name = "pstore", |
Tony Luck | fbe0aa1 | 2011-03-17 16:29:15 -0700 | [diff] [blame] | 314 | .mount = pstore_mount, |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 315 | .kill_sb = pstore_kill_sb, |
| 316 | }; |
| 317 | |
| 318 | static int __init init_pstore_fs(void) |
| 319 | { |
Luck, Tony | 366f7e7 | 2011-03-18 15:33:43 -0700 | [diff] [blame] | 320 | return register_filesystem(&pstore_fs_type); |
Tony Luck | ca01d6d | 2010-12-28 14:25:21 -0800 | [diff] [blame] | 321 | } |
| 322 | module_init(init_pstore_fs) |
| 323 | |
| 324 | MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>"); |
| 325 | MODULE_LICENSE("GPL"); |