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
free_pstore_private(struct pstore_private * private)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
pstore_ftrace_seq_start(struct seq_file * s,loff_t * pos)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
pstore_ftrace_seq_stop(struct seq_file * s,void * v)83 static void pstore_ftrace_seq_stop(struct seq_file *s, void *v)
84 {
85 kfree(v);
86 }
87
pstore_ftrace_seq_next(struct seq_file * s,void * v,loff_t * pos)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
pstore_ftrace_seq_show(struct seq_file * s,void * v)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
pstore_file_read(struct file * file,char __user * userbuf,size_t count,loff_t * ppos)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
pstore_file_open(struct inode * inode,struct file * file)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
pstore_file_llseek(struct file * file,loff_t off,int whence)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 */
pstore_unlink(struct inode * dir,struct dentry * dentry)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
pstore_evict_inode(struct inode * inode)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
pstore_get_inode(struct super_block * sb)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
parse_options(char * options)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 */
pstore_show_options(struct seq_file * m,struct dentry * root)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
pstore_remount(struct super_block * sb,int * flags,char * data)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
psinfo_lock_root(void)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
pstore_put_backend_records(struct pstore_info * psi)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 */
pstore_mkfile(struct dentry * root,struct pstore_record * record)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 */
pstore_get_records(int quiet)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
pstore_fill_super(struct super_block * sb,void * data,int silent)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
pstore_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)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
pstore_kill_sb(struct super_block * sb)467 static void pstore_kill_sb(struct super_block *sb)
468 {
469 mutex_lock(&pstore_sb_lock);
470 WARN_ON(pstore_sb && 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
pstore_init_fs(void)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
pstore_exit_fs(void)506 void __exit pstore_exit_fs(void)
507 {
508 unregister_filesystem(&pstore_fs_type);
509 sysfs_remove_mount_point(fs_kobj, "pstore");
510 }
511