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