This source file includes following definitions.
- pstore_ftrace_seq_start
- pstore_ftrace_seq_stop
- pstore_ftrace_seq_next
- pstore_ftrace_seq_show
- pstore_file_read
- pstore_file_open
- pstore_file_llseek
- pstore_unlink
- pstore_evict_inode
- pstore_get_inode
- parse_options
- pstore_show_options
- pstore_remount
- pstore_is_mounted
- pstore_mkfile
- pstore_get_records
- pstore_fill_super
- pstore_mount
- pstore_kill_sb
- pstore_init_fs
- pstore_exit_fs
1
2
3
4
5
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 (*pos)++;
91 data->off += REC_SIZE;
92 if (data->off + REC_SIZE > ps->total_size)
93 return NULL;
94
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 if (!data)
105 return 0;
106
107 rec = (struct pstore_ftrace_record *)(ps->record->buf + data->off);
108
109 seq_printf(s, "CPU:%d ts:%llu %08lx %08lx %ps <- %pS\n",
110 pstore_ftrace_decode_cpu(rec),
111 pstore_ftrace_read_timestamp(rec),
112 rec->ip, rec->parent_ip, (void *)rec->ip,
113 (void *)rec->parent_ip);
114
115 return 0;
116 }
117
118 static const struct seq_operations pstore_ftrace_seq_ops = {
119 .start = pstore_ftrace_seq_start,
120 .next = pstore_ftrace_seq_next,
121 .stop = pstore_ftrace_seq_stop,
122 .show = pstore_ftrace_seq_show,
123 };
124
125 static ssize_t pstore_file_read(struct file *file, char __user *userbuf,
126 size_t count, loff_t *ppos)
127 {
128 struct seq_file *sf = file->private_data;
129 struct pstore_private *ps = sf->private;
130
131 if (ps->record->type == PSTORE_TYPE_FTRACE)
132 return seq_read(file, userbuf, count, ppos);
133 return simple_read_from_buffer(userbuf, count, ppos,
134 ps->record->buf, ps->total_size);
135 }
136
137 static int pstore_file_open(struct inode *inode, struct file *file)
138 {
139 struct pstore_private *ps = inode->i_private;
140 struct seq_file *sf;
141 int err;
142 const struct seq_operations *sops = NULL;
143
144 if (ps->record->type == PSTORE_TYPE_FTRACE)
145 sops = &pstore_ftrace_seq_ops;
146
147 err = seq_open(file, sops);
148 if (err < 0)
149 return err;
150
151 sf = file->private_data;
152 sf->private = ps;
153
154 return 0;
155 }
156
157 static loff_t pstore_file_llseek(struct file *file, loff_t off, int whence)
158 {
159 struct seq_file *sf = file->private_data;
160
161 if (sf->op)
162 return seq_lseek(file, off, whence);
163 return default_llseek(file, off, whence);
164 }
165
166 static const struct file_operations pstore_file_operations = {
167 .open = pstore_file_open,
168 .read = pstore_file_read,
169 .llseek = pstore_file_llseek,
170 .release = seq_release,
171 };
172
173
174
175
176
177 static int pstore_unlink(struct inode *dir, struct dentry *dentry)
178 {
179 struct pstore_private *p = d_inode(dentry)->i_private;
180 struct pstore_record *record = p->record;
181
182 if (!record->psi->erase)
183 return -EPERM;
184
185 mutex_lock(&record->psi->read_mutex);
186 record->psi->erase(record);
187 mutex_unlock(&record->psi->read_mutex);
188
189 return simple_unlink(dir, dentry);
190 }
191
192 static void pstore_evict_inode(struct inode *inode)
193 {
194 struct pstore_private *p = inode->i_private;
195 unsigned long flags;
196
197 clear_inode(inode);
198 if (p) {
199 spin_lock_irqsave(&allpstore_lock, flags);
200 list_del(&p->list);
201 spin_unlock_irqrestore(&allpstore_lock, flags);
202 free_pstore_private(p);
203 }
204 }
205
206 static const struct inode_operations pstore_dir_inode_operations = {
207 .lookup = simple_lookup,
208 .unlink = pstore_unlink,
209 };
210
211 static struct inode *pstore_get_inode(struct super_block *sb)
212 {
213 struct inode *inode = new_inode(sb);
214 if (inode) {
215 inode->i_ino = get_next_ino();
216 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
217 }
218 return inode;
219 }
220
221 enum {
222 Opt_kmsg_bytes, Opt_err
223 };
224
225 static const match_table_t tokens = {
226 {Opt_kmsg_bytes, "kmsg_bytes=%u"},
227 {Opt_err, NULL}
228 };
229
230 static void parse_options(char *options)
231 {
232 char *p;
233 substring_t args[MAX_OPT_ARGS];
234 int option;
235
236 if (!options)
237 return;
238
239 while ((p = strsep(&options, ",")) != NULL) {
240 int token;
241
242 if (!*p)
243 continue;
244
245 token = match_token(p, tokens, args);
246 switch (token) {
247 case Opt_kmsg_bytes:
248 if (!match_int(&args[0], &option))
249 pstore_set_kmsg_bytes(option);
250 break;
251 }
252 }
253 }
254
255
256
257
258 static int pstore_show_options(struct seq_file *m, struct dentry *root)
259 {
260 if (kmsg_bytes != PSTORE_DEFAULT_KMSG_BYTES)
261 seq_printf(m, ",kmsg_bytes=%lu", kmsg_bytes);
262 return 0;
263 }
264
265 static int pstore_remount(struct super_block *sb, int *flags, char *data)
266 {
267 sync_filesystem(sb);
268 parse_options(data);
269
270 return 0;
271 }
272
273 static const struct super_operations pstore_ops = {
274 .statfs = simple_statfs,
275 .drop_inode = generic_delete_inode,
276 .evict_inode = pstore_evict_inode,
277 .remount_fs = pstore_remount,
278 .show_options = pstore_show_options,
279 };
280
281 static struct super_block *pstore_sb;
282
283 bool pstore_is_mounted(void)
284 {
285 return pstore_sb != NULL;
286 }
287
288
289
290
291
292
293 int pstore_mkfile(struct dentry *root, struct pstore_record *record)
294 {
295 struct dentry *dentry;
296 struct inode *inode;
297 int rc = 0;
298 char name[PSTORE_NAMELEN];
299 struct pstore_private *private, *pos;
300 unsigned long flags;
301 size_t size = record->size + record->ecc_notice_size;
302
303 WARN_ON(!inode_is_locked(d_inode(root)));
304
305 spin_lock_irqsave(&allpstore_lock, flags);
306 list_for_each_entry(pos, &allpstore, list) {
307 if (pos->record->type == record->type &&
308 pos->record->id == record->id &&
309 pos->record->psi == record->psi) {
310 rc = -EEXIST;
311 break;
312 }
313 }
314 spin_unlock_irqrestore(&allpstore_lock, flags);
315 if (rc)
316 return rc;
317
318 rc = -ENOMEM;
319 inode = pstore_get_inode(root->d_sb);
320 if (!inode)
321 goto fail;
322 inode->i_mode = S_IFREG | 0444;
323 inode->i_fop = &pstore_file_operations;
324 scnprintf(name, sizeof(name), "%s-%s-%llu%s",
325 pstore_type_to_name(record->type),
326 record->psi->name, record->id,
327 record->compressed ? ".enc.z" : "");
328
329 private = kzalloc(sizeof(*private), GFP_KERNEL);
330 if (!private)
331 goto fail_inode;
332
333 dentry = d_alloc_name(root, name);
334 if (!dentry)
335 goto fail_private;
336
337 private->record = record;
338 inode->i_size = private->total_size = size;
339 inode->i_private = private;
340
341 if (record->time.tv_sec)
342 inode->i_mtime = inode->i_ctime = record->time;
343
344 d_add(dentry, inode);
345
346 spin_lock_irqsave(&allpstore_lock, flags);
347 list_add(&private->list, &allpstore);
348 spin_unlock_irqrestore(&allpstore_lock, flags);
349
350 return 0;
351
352 fail_private:
353 free_pstore_private(private);
354 fail_inode:
355 iput(inode);
356
357 fail:
358 return rc;
359 }
360
361
362
363
364
365
366
367 void pstore_get_records(int quiet)
368 {
369 struct pstore_info *psi = psinfo;
370 struct dentry *root;
371
372 if (!psi || !pstore_sb)
373 return;
374
375 root = pstore_sb->s_root;
376
377 inode_lock(d_inode(root));
378 pstore_get_backend_records(psi, root, quiet);
379 inode_unlock(d_inode(root));
380 }
381
382 static int pstore_fill_super(struct super_block *sb, void *data, int silent)
383 {
384 struct inode *inode;
385
386 pstore_sb = sb;
387
388 sb->s_maxbytes = MAX_LFS_FILESIZE;
389 sb->s_blocksize = PAGE_SIZE;
390 sb->s_blocksize_bits = PAGE_SHIFT;
391 sb->s_magic = PSTOREFS_MAGIC;
392 sb->s_op = &pstore_ops;
393 sb->s_time_gran = 1;
394
395 parse_options(data);
396
397 inode = pstore_get_inode(sb);
398 if (inode) {
399 inode->i_mode = S_IFDIR | 0750;
400 inode->i_op = &pstore_dir_inode_operations;
401 inode->i_fop = &simple_dir_operations;
402 inc_nlink(inode);
403 }
404 sb->s_root = d_make_root(inode);
405 if (!sb->s_root)
406 return -ENOMEM;
407
408 pstore_get_records(0);
409
410 return 0;
411 }
412
413 static struct dentry *pstore_mount(struct file_system_type *fs_type,
414 int flags, const char *dev_name, void *data)
415 {
416 return mount_single(fs_type, flags, data, pstore_fill_super);
417 }
418
419 static void pstore_kill_sb(struct super_block *sb)
420 {
421 kill_litter_super(sb);
422 pstore_sb = NULL;
423 }
424
425 static struct file_system_type pstore_fs_type = {
426 .owner = THIS_MODULE,
427 .name = "pstore",
428 .mount = pstore_mount,
429 .kill_sb = pstore_kill_sb,
430 };
431
432 int __init pstore_init_fs(void)
433 {
434 int err;
435
436
437 err = sysfs_create_mount_point(fs_kobj, "pstore");
438 if (err)
439 goto out;
440
441 err = register_filesystem(&pstore_fs_type);
442 if (err < 0)
443 sysfs_remove_mount_point(fs_kobj, "pstore");
444
445 out:
446 return err;
447 }
448
449 void __exit pstore_exit_fs(void)
450 {
451 unregister_filesystem(&pstore_fs_type);
452 sysfs_remove_mount_point(fs_kobj, "pstore");
453 }