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