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