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/seq_file.h> 31 #include <linux/ramfs.h> 32 #include <linux/parser.h> 33 #include <linux/sched.h> 34 #include <linux/magic.h> 35 #include <linux/pstore.h> 36 #include <linux/slab.h> 37 #include <linux/spinlock.h> 38 #include <linux/uaccess.h> 39 #include <linux/syslog.h> 40 41 #include "internal.h" 42 43 #define PSTORE_NAMELEN 64 44 45 static DEFINE_SPINLOCK(allpstore_lock); 46 static LIST_HEAD(allpstore); 47 48 struct pstore_private { 49 struct list_head list; 50 struct pstore_info *psi; 51 enum pstore_type_id type; 52 u64 id; 53 int count; 54 ssize_t size; 55 char data[]; 56 }; 57 58 struct pstore_ftrace_seq_data { 59 const void *ptr; 60 size_t off; 61 size_t size; 62 }; 63 64 #define REC_SIZE sizeof(struct pstore_ftrace_record) 65 66 static void *pstore_ftrace_seq_start(struct seq_file *s, loff_t *pos) 67 { 68 struct pstore_private *ps = s->private; 69 struct pstore_ftrace_seq_data *data; 70 71 data = kzalloc(sizeof(*data), GFP_KERNEL); 72 if (!data) 73 return NULL; 74 75 data->off = ps->size % REC_SIZE; 76 data->off += *pos * REC_SIZE; 77 if (data->off + REC_SIZE > ps->size) { 78 kfree(data); 79 return NULL; 80 } 81 82 return data; 83 84 } 85 86 static void pstore_ftrace_seq_stop(struct seq_file *s, void *v) 87 { 88 kfree(v); 89 } 90 91 static void *pstore_ftrace_seq_next(struct seq_file *s, void *v, loff_t *pos) 92 { 93 struct pstore_private *ps = s->private; 94 struct pstore_ftrace_seq_data *data = v; 95 96 data->off += REC_SIZE; 97 if (data->off + REC_SIZE > ps->size) 98 return NULL; 99 100 (*pos)++; 101 return data; 102 } 103 104 static int pstore_ftrace_seq_show(struct seq_file *s, void *v) 105 { 106 struct pstore_private *ps = s->private; 107 struct pstore_ftrace_seq_data *data = v; 108 struct pstore_ftrace_record *rec = (void *)(ps->data + data->off); 109 110 seq_printf(s, "%d %08lx %08lx %pf <- %pF\n", 111 pstore_ftrace_decode_cpu(rec), rec->ip, rec->parent_ip, 112 (void *)rec->ip, (void *)rec->parent_ip); 113 114 return 0; 115 } 116 117 static const struct seq_operations pstore_ftrace_seq_ops = { 118 .start = pstore_ftrace_seq_start, 119 .next = pstore_ftrace_seq_next, 120 .stop = pstore_ftrace_seq_stop, 121 .show = pstore_ftrace_seq_show, 122 }; 123 124 static int pstore_check_syslog_permissions(struct pstore_private *ps) 125 { 126 switch (ps->type) { 127 case PSTORE_TYPE_DMESG: 128 case PSTORE_TYPE_CONSOLE: 129 return check_syslog_permissions(SYSLOG_ACTION_READ_ALL, 130 SYSLOG_FROM_READER); 131 default: 132 return 0; 133 } 134 } 135 136 static ssize_t pstore_file_read(struct file *file, char __user *userbuf, 137 size_t count, loff_t *ppos) 138 { 139 struct seq_file *sf = file->private_data; 140 struct pstore_private *ps = sf->private; 141 142 if (ps->type == PSTORE_TYPE_FTRACE) 143 return seq_read(file, userbuf, count, ppos); 144 return simple_read_from_buffer(userbuf, count, ppos, ps->data, ps->size); 145 } 146 147 static int pstore_file_open(struct inode *inode, struct file *file) 148 { 149 struct pstore_private *ps = inode->i_private; 150 struct seq_file *sf; 151 int err; 152 const struct seq_operations *sops = NULL; 153 154 err = pstore_check_syslog_permissions(ps); 155 if (err) 156 return err; 157 158 if (ps->type == PSTORE_TYPE_FTRACE) 159 sops = &pstore_ftrace_seq_ops; 160 161 err = seq_open(file, sops); 162 if (err < 0) 163 return err; 164 165 sf = file->private_data; 166 sf->private = ps; 167 168 return 0; 169 } 170 171 static loff_t pstore_file_llseek(struct file *file, loff_t off, int whence) 172 { 173 struct seq_file *sf = file->private_data; 174 175 if (sf->op) 176 return seq_lseek(file, off, whence); 177 return default_llseek(file, off, whence); 178 } 179 180 static const struct file_operations pstore_file_operations = { 181 .open = pstore_file_open, 182 .read = pstore_file_read, 183 .llseek = pstore_file_llseek, 184 .release = seq_release, 185 }; 186 187 /* 188 * When a file is unlinked from our file system we call the 189 * platform driver to erase the record from persistent store. 190 */ 191 static int pstore_unlink(struct inode *dir, struct dentry *dentry) 192 { 193 struct pstore_private *p = dentry->d_inode->i_private; 194 int err; 195 196 err = pstore_check_syslog_permissions(p); 197 if (err) 198 return err; 199 200 if (p->psi->erase) 201 p->psi->erase(p->type, p->id, p->count, 202 dentry->d_inode->i_ctime, p->psi); 203 else 204 return -EPERM; 205 206 return simple_unlink(dir, dentry); 207 } 208 209 static void pstore_evict_inode(struct inode *inode) 210 { 211 struct pstore_private *p = inode->i_private; 212 unsigned long flags; 213 214 clear_inode(inode); 215 if (p) { 216 spin_lock_irqsave(&allpstore_lock, flags); 217 list_del(&p->list); 218 spin_unlock_irqrestore(&allpstore_lock, flags); 219 kfree(p); 220 } 221 } 222 223 static const struct inode_operations pstore_dir_inode_operations = { 224 .lookup = simple_lookup, 225 .unlink = pstore_unlink, 226 }; 227 228 static struct inode *pstore_get_inode(struct super_block *sb) 229 { 230 struct inode *inode = new_inode(sb); 231 if (inode) { 232 inode->i_ino = get_next_ino(); 233 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 234 } 235 return inode; 236 } 237 238 enum { 239 Opt_kmsg_bytes, Opt_err 240 }; 241 242 static const match_table_t tokens = { 243 {Opt_kmsg_bytes, "kmsg_bytes=%u"}, 244 {Opt_err, NULL} 245 }; 246 247 static void parse_options(char *options) 248 { 249 char *p; 250 substring_t args[MAX_OPT_ARGS]; 251 int option; 252 253 if (!options) 254 return; 255 256 while ((p = strsep(&options, ",")) != NULL) { 257 int token; 258 259 if (!*p) 260 continue; 261 262 token = match_token(p, tokens, args); 263 switch (token) { 264 case Opt_kmsg_bytes: 265 if (!match_int(&args[0], &option)) 266 pstore_set_kmsg_bytes(option); 267 break; 268 } 269 } 270 } 271 272 static int pstore_remount(struct super_block *sb, int *flags, char *data) 273 { 274 sync_filesystem(sb); 275 parse_options(data); 276 277 return 0; 278 } 279 280 static const struct super_operations pstore_ops = { 281 .statfs = simple_statfs, 282 .drop_inode = generic_delete_inode, 283 .evict_inode = pstore_evict_inode, 284 .remount_fs = pstore_remount, 285 .show_options = generic_show_options, 286 }; 287 288 static struct super_block *pstore_sb; 289 290 int pstore_is_mounted(void) 291 { 292 return pstore_sb != NULL; 293 } 294 295 /* 296 * Make a regular file in the root directory of our file system. 297 * Load it up with "size" bytes of data from "buf". 298 * Set the mtime & ctime to the date that this record was originally stored. 299 */ 300 int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id, int count, 301 char *data, bool compressed, size_t size, 302 struct timespec time, struct pstore_info *psi) 303 { 304 struct dentry *root = pstore_sb->s_root; 305 struct dentry *dentry; 306 struct inode *inode; 307 int rc = 0; 308 char name[PSTORE_NAMELEN]; 309 struct pstore_private *private, *pos; 310 unsigned long flags; 311 312 spin_lock_irqsave(&allpstore_lock, flags); 313 list_for_each_entry(pos, &allpstore, list) { 314 if (pos->type == type && 315 pos->id == id && 316 pos->psi == psi) { 317 rc = -EEXIST; 318 break; 319 } 320 } 321 spin_unlock_irqrestore(&allpstore_lock, flags); 322 if (rc) 323 return rc; 324 325 rc = -ENOMEM; 326 inode = pstore_get_inode(pstore_sb); 327 if (!inode) 328 goto fail; 329 inode->i_mode = S_IFREG | 0444; 330 inode->i_fop = &pstore_file_operations; 331 private = kmalloc(sizeof *private + size, GFP_KERNEL); 332 if (!private) 333 goto fail_alloc; 334 private->type = type; 335 private->id = id; 336 private->count = count; 337 private->psi = psi; 338 339 switch (type) { 340 case PSTORE_TYPE_DMESG: 341 scnprintf(name, sizeof(name), "dmesg-%s-%lld%s", 342 psname, id, compressed ? ".enc.z" : ""); 343 break; 344 case PSTORE_TYPE_CONSOLE: 345 scnprintf(name, sizeof(name), "console-%s-%lld", psname, id); 346 break; 347 case PSTORE_TYPE_FTRACE: 348 scnprintf(name, sizeof(name), "ftrace-%s-%lld", psname, id); 349 break; 350 case PSTORE_TYPE_MCE: 351 scnprintf(name, sizeof(name), "mce-%s-%lld", psname, id); 352 break; 353 case PSTORE_TYPE_PPC_RTAS: 354 scnprintf(name, sizeof(name), "rtas-%s-%lld", psname, id); 355 break; 356 case PSTORE_TYPE_PPC_OF: 357 scnprintf(name, sizeof(name), "powerpc-ofw-%s-%lld", 358 psname, id); 359 break; 360 case PSTORE_TYPE_PPC_COMMON: 361 scnprintf(name, sizeof(name), "powerpc-common-%s-%lld", 362 psname, id); 363 break; 364 case PSTORE_TYPE_PMSG: 365 scnprintf(name, sizeof(name), "pmsg-%s-%lld", psname, id); 366 break; 367 case PSTORE_TYPE_UNKNOWN: 368 scnprintf(name, sizeof(name), "unknown-%s-%lld", psname, id); 369 break; 370 default: 371 scnprintf(name, sizeof(name), "type%d-%s-%lld", 372 type, psname, id); 373 break; 374 } 375 376 mutex_lock(&root->d_inode->i_mutex); 377 378 dentry = d_alloc_name(root, name); 379 if (!dentry) 380 goto fail_lockedalloc; 381 382 memcpy(private->data, data, size); 383 inode->i_size = private->size = size; 384 385 inode->i_private = private; 386 387 if (time.tv_sec) 388 inode->i_mtime = inode->i_ctime = time; 389 390 d_add(dentry, inode); 391 392 spin_lock_irqsave(&allpstore_lock, flags); 393 list_add(&private->list, &allpstore); 394 spin_unlock_irqrestore(&allpstore_lock, flags); 395 396 mutex_unlock(&root->d_inode->i_mutex); 397 398 return 0; 399 400 fail_lockedalloc: 401 mutex_unlock(&root->d_inode->i_mutex); 402 kfree(private); 403 fail_alloc: 404 iput(inode); 405 406 fail: 407 return rc; 408 } 409 410 static int pstore_fill_super(struct super_block *sb, void *data, int silent) 411 { 412 struct inode *inode; 413 414 save_mount_options(sb, data); 415 416 pstore_sb = sb; 417 418 sb->s_maxbytes = MAX_LFS_FILESIZE; 419 sb->s_blocksize = PAGE_CACHE_SIZE; 420 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 421 sb->s_magic = PSTOREFS_MAGIC; 422 sb->s_op = &pstore_ops; 423 sb->s_time_gran = 1; 424 425 parse_options(data); 426 427 inode = pstore_get_inode(sb); 428 if (inode) { 429 inode->i_mode = S_IFDIR | 0755; 430 inode->i_op = &pstore_dir_inode_operations; 431 inode->i_fop = &simple_dir_operations; 432 inc_nlink(inode); 433 } 434 sb->s_root = d_make_root(inode); 435 if (!sb->s_root) 436 return -ENOMEM; 437 438 pstore_get_records(0); 439 440 return 0; 441 } 442 443 static struct dentry *pstore_mount(struct file_system_type *fs_type, 444 int flags, const char *dev_name, void *data) 445 { 446 return mount_single(fs_type, flags, data, pstore_fill_super); 447 } 448 449 static void pstore_kill_sb(struct super_block *sb) 450 { 451 kill_litter_super(sb); 452 pstore_sb = NULL; 453 } 454 455 static struct file_system_type pstore_fs_type = { 456 .name = "pstore", 457 .mount = pstore_mount, 458 .kill_sb = pstore_kill_sb, 459 }; 460 461 static struct kobject *pstore_kobj; 462 463 static int __init init_pstore_fs(void) 464 { 465 int err = 0; 466 467 /* Create a convenient mount point for people to access pstore */ 468 pstore_kobj = kobject_create_and_add("pstore", fs_kobj); 469 if (!pstore_kobj) { 470 err = -ENOMEM; 471 goto out; 472 } 473 474 err = register_filesystem(&pstore_fs_type); 475 if (err < 0) 476 kobject_put(pstore_kobj); 477 478 out: 479 return err; 480 } 481 module_init(init_pstore_fs) 482 483 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>"); 484 MODULE_LICENSE("GPL"); 485