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