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/ramfs.h> 31 #include <linux/parser.h> 32 #include <linux/sched.h> 33 #include <linux/magic.h> 34 #include <linux/pstore.h> 35 #include <linux/slab.h> 36 #include <linux/spinlock.h> 37 #include <linux/uaccess.h> 38 39 #include "internal.h" 40 41 #define PSTORE_NAMELEN 64 42 43 static DEFINE_SPINLOCK(allpstore_lock); 44 static LIST_HEAD(allpstore); 45 46 struct pstore_private { 47 struct list_head list; 48 struct pstore_info *psi; 49 enum pstore_type_id type; 50 u64 id; 51 ssize_t size; 52 char data[]; 53 }; 54 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 }; 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 83 p->psi->erase(p->type, p->id, p->psi); 84 85 return simple_unlink(dir, dentry); 86 } 87 88 static void pstore_evict_inode(struct inode *inode) 89 { 90 struct pstore_private *p = inode->i_private; 91 unsigned long flags; 92 93 end_writeback(inode); 94 if (p) { 95 spin_lock_irqsave(&allpstore_lock, flags); 96 list_del(&p->list); 97 spin_unlock_irqrestore(&allpstore_lock, flags); 98 kfree(p); 99 } 100 } 101 102 static const struct inode_operations pstore_dir_inode_operations = { 103 .lookup = simple_lookup, 104 .unlink = pstore_unlink, 105 }; 106 107 static struct inode *pstore_get_inode(struct super_block *sb, 108 const struct inode *dir, int mode, dev_t dev) 109 { 110 struct inode *inode = new_inode(sb); 111 112 if (inode) { 113 inode->i_ino = get_next_ino(); 114 inode->i_uid = inode->i_gid = 0; 115 inode->i_mode = mode; 116 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 117 switch (mode & S_IFMT) { 118 case S_IFREG: 119 inode->i_fop = &pstore_file_operations; 120 break; 121 case S_IFDIR: 122 inode->i_op = &pstore_dir_inode_operations; 123 inode->i_fop = &simple_dir_operations; 124 inc_nlink(inode); 125 break; 126 } 127 } 128 return inode; 129 } 130 131 enum { 132 Opt_kmsg_bytes, Opt_err 133 }; 134 135 static const match_table_t tokens = { 136 {Opt_kmsg_bytes, "kmsg_bytes=%u"}, 137 {Opt_err, NULL} 138 }; 139 140 static void parse_options(char *options) 141 { 142 char *p; 143 substring_t args[MAX_OPT_ARGS]; 144 int option; 145 146 if (!options) 147 return; 148 149 while ((p = strsep(&options, ",")) != NULL) { 150 int token; 151 152 if (!*p) 153 continue; 154 155 token = match_token(p, tokens, args); 156 switch (token) { 157 case Opt_kmsg_bytes: 158 if (!match_int(&args[0], &option)) 159 pstore_set_kmsg_bytes(option); 160 break; 161 } 162 } 163 } 164 165 static int pstore_remount(struct super_block *sb, int *flags, char *data) 166 { 167 parse_options(data); 168 169 return 0; 170 } 171 172 static const struct super_operations pstore_ops = { 173 .statfs = simple_statfs, 174 .drop_inode = generic_delete_inode, 175 .evict_inode = pstore_evict_inode, 176 .remount_fs = pstore_remount, 177 .show_options = generic_show_options, 178 }; 179 180 static struct super_block *pstore_sb; 181 182 int pstore_is_mounted(void) 183 { 184 return pstore_sb != NULL; 185 } 186 187 /* 188 * Make a regular file in the root directory of our file system. 189 * Load it up with "size" bytes of data from "buf". 190 * Set the mtime & ctime to the date that this record was originally stored. 191 */ 192 int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, 193 char *data, size_t size, struct timespec time, 194 struct pstore_info *psi) 195 { 196 struct dentry *root = pstore_sb->s_root; 197 struct dentry *dentry; 198 struct inode *inode; 199 int rc = 0; 200 char name[PSTORE_NAMELEN]; 201 struct pstore_private *private, *pos; 202 unsigned long flags; 203 204 spin_lock_irqsave(&allpstore_lock, flags); 205 list_for_each_entry(pos, &allpstore, list) { 206 if (pos->type == type && 207 pos->id == id && 208 pos->psi == psi) { 209 rc = -EEXIST; 210 break; 211 } 212 } 213 spin_unlock_irqrestore(&allpstore_lock, flags); 214 if (rc) 215 return rc; 216 217 rc = -ENOMEM; 218 inode = pstore_get_inode(pstore_sb, root->d_inode, S_IFREG | 0444, 0); 219 if (!inode) 220 goto fail; 221 private = kmalloc(sizeof *private + size, GFP_KERNEL); 222 if (!private) 223 goto fail_alloc; 224 private->type = type; 225 private->id = id; 226 private->psi = psi; 227 228 switch (type) { 229 case PSTORE_TYPE_DMESG: 230 sprintf(name, "dmesg-%s-%lld", psname, id); 231 break; 232 case PSTORE_TYPE_MCE: 233 sprintf(name, "mce-%s-%lld", psname, id); 234 break; 235 case PSTORE_TYPE_UNKNOWN: 236 sprintf(name, "unknown-%s-%lld", psname, id); 237 break; 238 default: 239 sprintf(name, "type%d-%s-%lld", type, psname, id); 240 break; 241 } 242 243 mutex_lock(&root->d_inode->i_mutex); 244 245 rc = -ENOSPC; 246 dentry = d_alloc_name(root, name); 247 if (IS_ERR(dentry)) 248 goto fail_lockedalloc; 249 250 memcpy(private->data, data, size); 251 inode->i_size = private->size = size; 252 253 inode->i_private = private; 254 255 if (time.tv_sec) 256 inode->i_mtime = inode->i_ctime = time; 257 258 d_add(dentry, inode); 259 260 spin_lock_irqsave(&allpstore_lock, flags); 261 list_add(&private->list, &allpstore); 262 spin_unlock_irqrestore(&allpstore_lock, flags); 263 264 mutex_unlock(&root->d_inode->i_mutex); 265 266 return 0; 267 268 fail_lockedalloc: 269 mutex_unlock(&root->d_inode->i_mutex); 270 kfree(private); 271 fail_alloc: 272 iput(inode); 273 274 fail: 275 return rc; 276 } 277 278 int pstore_fill_super(struct super_block *sb, void *data, int silent) 279 { 280 struct inode *inode = NULL; 281 struct dentry *root; 282 int err; 283 284 save_mount_options(sb, data); 285 286 pstore_sb = sb; 287 288 sb->s_maxbytes = MAX_LFS_FILESIZE; 289 sb->s_blocksize = PAGE_CACHE_SIZE; 290 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 291 sb->s_magic = PSTOREFS_MAGIC; 292 sb->s_op = &pstore_ops; 293 sb->s_time_gran = 1; 294 295 parse_options(data); 296 297 inode = pstore_get_inode(sb, NULL, S_IFDIR | 0755, 0); 298 if (!inode) { 299 err = -ENOMEM; 300 goto fail; 301 } 302 /* override ramfs "dir" options so we catch unlink(2) */ 303 inode->i_op = &pstore_dir_inode_operations; 304 305 root = d_alloc_root(inode); 306 sb->s_root = root; 307 if (!root) { 308 err = -ENOMEM; 309 goto fail; 310 } 311 312 pstore_get_records(0); 313 314 return 0; 315 fail: 316 iput(inode); 317 return err; 318 } 319 320 static struct dentry *pstore_mount(struct file_system_type *fs_type, 321 int flags, const char *dev_name, void *data) 322 { 323 return mount_single(fs_type, flags, data, pstore_fill_super); 324 } 325 326 static void pstore_kill_sb(struct super_block *sb) 327 { 328 kill_litter_super(sb); 329 pstore_sb = NULL; 330 } 331 332 static struct file_system_type pstore_fs_type = { 333 .name = "pstore", 334 .mount = pstore_mount, 335 .kill_sb = pstore_kill_sb, 336 }; 337 338 static int __init init_pstore_fs(void) 339 { 340 return register_filesystem(&pstore_fs_type); 341 } 342 module_init(init_pstore_fs) 343 344 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>"); 345 MODULE_LICENSE("GPL"); 346