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