Loading...
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
32static DEFINE_SPINLOCK(allpstore_lock);
33static LIST_HEAD(allpstore);
34
35struct pstore_private {
36 struct list_head list;
37 struct pstore_record *record;
38 size_t total_size;
39};
40
41struct 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
49static 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
60static 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
80static void pstore_ftrace_seq_stop(struct seq_file *s, void *v)
81{
82 kfree(v);
83}
84
85static 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
98static 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
115static 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
122static 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
134static 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
154static 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
163static 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 */
174static 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
189static 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
203static const struct inode_operations pstore_dir_inode_operations = {
204 .lookup = simple_lookup,
205 .unlink = pstore_unlink,
206};
207
208static 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
218enum {
219 Opt_kmsg_bytes, Opt_err
220};
221
222static const match_table_t tokens = {
223 {Opt_kmsg_bytes, "kmsg_bytes=%u"},
224 {Opt_err, NULL}
225};
226
227static 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 */
255static 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
262static 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
270static 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
278static struct super_block *pstore_sb;
279
280bool 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 */
290int 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
349fail_private:
350 free_pstore_private(private);
351fail_inode:
352 iput(inode);
353
354fail:
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 */
364void 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
379static 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
410static 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
416static void pstore_kill_sb(struct super_block *sb)
417{
418 kill_litter_super(sb);
419 pstore_sb = NULL;
420}
421
422static 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
429int __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
442out:
443 return err;
444}
445
446void __exit pstore_exit_fs(void)
447{
448 unregister_filesystem(&pstore_fs_type);
449 sysfs_remove_mount_point(fs_kobj, "pstore");
450}
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/ramfs.h>
31#include <linux/parser.h>
32#include <linux/sched.h>
33#include <linux/magic.h>
34#include <linux/pstore.h>
35#include <linux/slab.h>
36#include <linux/spinlock.h>
37#include <linux/uaccess.h>
38
39#include "internal.h"
40
41#define PSTORE_NAMELEN 64
42
43static DEFINE_SPINLOCK(allpstore_lock);
44static LIST_HEAD(allpstore);
45
46struct pstore_private {
47 struct list_head list;
48 struct pstore_info *psi;
49 enum pstore_type_id type;
50 u64 id;
51 ssize_t size;
52 char data[];
53};
54
55static ssize_t pstore_file_read(struct file *file, char __user *userbuf,
56 size_t count, loff_t *ppos)
57{
58 struct pstore_private *ps = file->private_data;
59
60 return simple_read_from_buffer(userbuf, count, ppos, ps->data, ps->size);
61}
62
63static const struct file_operations pstore_file_operations = {
64 .open = simple_open,
65 .read = pstore_file_read,
66 .llseek = default_llseek,
67};
68
69/*
70 * When a file is unlinked from our file system we call the
71 * platform driver to erase the record from persistent store.
72 */
73static int pstore_unlink(struct inode *dir, struct dentry *dentry)
74{
75 struct pstore_private *p = dentry->d_inode->i_private;
76
77 if (p->psi->erase)
78 p->psi->erase(p->type, p->id, p->psi);
79
80 return simple_unlink(dir, dentry);
81}
82
83static void pstore_evict_inode(struct inode *inode)
84{
85 struct pstore_private *p = inode->i_private;
86 unsigned long flags;
87
88 clear_inode(inode);
89 if (p) {
90 spin_lock_irqsave(&allpstore_lock, flags);
91 list_del(&p->list);
92 spin_unlock_irqrestore(&allpstore_lock, flags);
93 kfree(p);
94 }
95}
96
97static const struct inode_operations pstore_dir_inode_operations = {
98 .lookup = simple_lookup,
99 .unlink = pstore_unlink,
100};
101
102static struct inode *pstore_get_inode(struct super_block *sb)
103{
104 struct inode *inode = new_inode(sb);
105 if (inode) {
106 inode->i_ino = get_next_ino();
107 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
108 }
109 return inode;
110}
111
112enum {
113 Opt_kmsg_bytes, Opt_err
114};
115
116static const match_table_t tokens = {
117 {Opt_kmsg_bytes, "kmsg_bytes=%u"},
118 {Opt_err, NULL}
119};
120
121static void parse_options(char *options)
122{
123 char *p;
124 substring_t args[MAX_OPT_ARGS];
125 int option;
126
127 if (!options)
128 return;
129
130 while ((p = strsep(&options, ",")) != NULL) {
131 int token;
132
133 if (!*p)
134 continue;
135
136 token = match_token(p, tokens, args);
137 switch (token) {
138 case Opt_kmsg_bytes:
139 if (!match_int(&args[0], &option))
140 pstore_set_kmsg_bytes(option);
141 break;
142 }
143 }
144}
145
146static int pstore_remount(struct super_block *sb, int *flags, char *data)
147{
148 parse_options(data);
149
150 return 0;
151}
152
153static const struct super_operations pstore_ops = {
154 .statfs = simple_statfs,
155 .drop_inode = generic_delete_inode,
156 .evict_inode = pstore_evict_inode,
157 .remount_fs = pstore_remount,
158 .show_options = generic_show_options,
159};
160
161static struct super_block *pstore_sb;
162
163int pstore_is_mounted(void)
164{
165 return pstore_sb != NULL;
166}
167
168/*
169 * Make a regular file in the root directory of our file system.
170 * Load it up with "size" bytes of data from "buf".
171 * Set the mtime & ctime to the date that this record was originally stored.
172 */
173int pstore_mkfile(enum pstore_type_id type, char *psname, u64 id,
174 char *data, size_t size, struct timespec time,
175 struct pstore_info *psi)
176{
177 struct dentry *root = pstore_sb->s_root;
178 struct dentry *dentry;
179 struct inode *inode;
180 int rc = 0;
181 char name[PSTORE_NAMELEN];
182 struct pstore_private *private, *pos;
183 unsigned long flags;
184
185 spin_lock_irqsave(&allpstore_lock, flags);
186 list_for_each_entry(pos, &allpstore, list) {
187 if (pos->type == type &&
188 pos->id == id &&
189 pos->psi == psi) {
190 rc = -EEXIST;
191 break;
192 }
193 }
194 spin_unlock_irqrestore(&allpstore_lock, flags);
195 if (rc)
196 return rc;
197
198 rc = -ENOMEM;
199 inode = pstore_get_inode(pstore_sb);
200 if (!inode)
201 goto fail;
202 inode->i_mode = S_IFREG | 0444;
203 inode->i_fop = &pstore_file_operations;
204 private = kmalloc(sizeof *private + size, GFP_KERNEL);
205 if (!private)
206 goto fail_alloc;
207 private->type = type;
208 private->id = id;
209 private->psi = psi;
210
211 switch (type) {
212 case PSTORE_TYPE_DMESG:
213 sprintf(name, "dmesg-%s-%lld", psname, id);
214 break;
215 case PSTORE_TYPE_MCE:
216 sprintf(name, "mce-%s-%lld", psname, id);
217 break;
218 case PSTORE_TYPE_UNKNOWN:
219 sprintf(name, "unknown-%s-%lld", psname, id);
220 break;
221 default:
222 sprintf(name, "type%d-%s-%lld", type, psname, id);
223 break;
224 }
225
226 mutex_lock(&root->d_inode->i_mutex);
227
228 rc = -ENOSPC;
229 dentry = d_alloc_name(root, name);
230 if (IS_ERR(dentry))
231 goto fail_lockedalloc;
232
233 memcpy(private->data, data, size);
234 inode->i_size = private->size = size;
235
236 inode->i_private = private;
237
238 if (time.tv_sec)
239 inode->i_mtime = inode->i_ctime = time;
240
241 d_add(dentry, inode);
242
243 spin_lock_irqsave(&allpstore_lock, flags);
244 list_add(&private->list, &allpstore);
245 spin_unlock_irqrestore(&allpstore_lock, flags);
246
247 mutex_unlock(&root->d_inode->i_mutex);
248
249 return 0;
250
251fail_lockedalloc:
252 mutex_unlock(&root->d_inode->i_mutex);
253 kfree(private);
254fail_alloc:
255 iput(inode);
256
257fail:
258 return rc;
259}
260
261static int pstore_fill_super(struct super_block *sb, void *data, int silent)
262{
263 struct inode *inode;
264
265 save_mount_options(sb, data);
266
267 pstore_sb = sb;
268
269 sb->s_maxbytes = MAX_LFS_FILESIZE;
270 sb->s_blocksize = PAGE_CACHE_SIZE;
271 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
272 sb->s_magic = PSTOREFS_MAGIC;
273 sb->s_op = &pstore_ops;
274 sb->s_time_gran = 1;
275
276 parse_options(data);
277
278 inode = pstore_get_inode(sb);
279 if (inode) {
280 inode->i_mode = S_IFDIR | 0755;
281 inode->i_op = &pstore_dir_inode_operations;
282 inode->i_fop = &simple_dir_operations;
283 inc_nlink(inode);
284 }
285 sb->s_root = d_make_root(inode);
286 if (!sb->s_root)
287 return -ENOMEM;
288
289 pstore_get_records(0);
290
291 return 0;
292}
293
294static struct dentry *pstore_mount(struct file_system_type *fs_type,
295 int flags, const char *dev_name, void *data)
296{
297 return mount_single(fs_type, flags, data, pstore_fill_super);
298}
299
300static void pstore_kill_sb(struct super_block *sb)
301{
302 kill_litter_super(sb);
303 pstore_sb = NULL;
304}
305
306static struct file_system_type pstore_fs_type = {
307 .name = "pstore",
308 .mount = pstore_mount,
309 .kill_sb = pstore_kill_sb,
310};
311
312static int __init init_pstore_fs(void)
313{
314 return register_filesystem(&pstore_fs_type);
315}
316module_init(init_pstore_fs)
317
318MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
319MODULE_LICENSE("GPL");