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