2 * Persistent Storage - ramfs parts.
4 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com>
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.
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.
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
20 #include <linux/module.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>
41 #define PSTORE_NAMELEN 64
43 static DEFINE_SPINLOCK(allpstore_lock
);
44 static LIST_HEAD(allpstore
);
46 struct pstore_private
{
47 struct list_head list
;
48 struct pstore_info
*psi
;
49 enum pstore_type_id type
;
55 static int pstore_file_open(struct inode
*inode
, struct file
*file
)
57 file
->private_data
= inode
->i_private
;
61 static ssize_t
pstore_file_read(struct file
*file
, char __user
*userbuf
,
62 size_t count
, loff_t
*ppos
)
64 struct pstore_private
*ps
= file
->private_data
;
66 return simple_read_from_buffer(userbuf
, count
, ppos
, ps
->data
, ps
->size
);
69 static const struct file_operations pstore_file_operations
= {
70 .open
= pstore_file_open
,
71 .read
= pstore_file_read
,
72 .llseek
= default_llseek
,
76 * When a file is unlinked from our file system we call the
77 * platform driver to erase the record from persistent store.
79 static int pstore_unlink(struct inode
*dir
, struct dentry
*dentry
)
81 struct pstore_private
*p
= dentry
->d_inode
->i_private
;
84 p
->psi
->erase(p
->type
, p
->id
, p
->psi
);
86 return simple_unlink(dir
, dentry
);
89 static void pstore_evict_inode(struct inode
*inode
)
91 struct pstore_private
*p
= inode
->i_private
;
96 spin_lock_irqsave(&allpstore_lock
, flags
);
98 spin_unlock_irqrestore(&allpstore_lock
, flags
);
103 static const struct inode_operations pstore_dir_inode_operations
= {
104 .lookup
= simple_lookup
,
105 .unlink
= pstore_unlink
,
108 static struct inode
*pstore_get_inode(struct super_block
*sb
)
110 struct inode
*inode
= new_inode(sb
);
112 inode
->i_ino
= get_next_ino();
113 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
119 Opt_kmsg_bytes
, Opt_err
122 static const match_table_t tokens
= {
123 {Opt_kmsg_bytes
, "kmsg_bytes=%u"},
127 static void parse_options(char *options
)
130 substring_t args
[MAX_OPT_ARGS
];
136 while ((p
= strsep(&options
, ",")) != NULL
) {
142 token
= match_token(p
, tokens
, args
);
145 if (!match_int(&args
[0], &option
))
146 pstore_set_kmsg_bytes(option
);
152 static int pstore_remount(struct super_block
*sb
, int *flags
, char *data
)
159 static const struct super_operations pstore_ops
= {
160 .statfs
= simple_statfs
,
161 .drop_inode
= generic_delete_inode
,
162 .evict_inode
= pstore_evict_inode
,
163 .remount_fs
= pstore_remount
,
164 .show_options
= generic_show_options
,
167 static struct super_block
*pstore_sb
;
169 int pstore_is_mounted(void)
171 return pstore_sb
!= NULL
;
175 * Make a regular file in the root directory of our file system.
176 * Load it up with "size" bytes of data from "buf".
177 * Set the mtime & ctime to the date that this record was originally stored.
179 int pstore_mkfile(enum pstore_type_id type
, char *psname
, u64 id
,
180 char *data
, size_t size
, struct timespec time
,
181 struct pstore_info
*psi
)
183 struct dentry
*root
= pstore_sb
->s_root
;
184 struct dentry
*dentry
;
187 char name
[PSTORE_NAMELEN
];
188 struct pstore_private
*private, *pos
;
191 spin_lock_irqsave(&allpstore_lock
, flags
);
192 list_for_each_entry(pos
, &allpstore
, list
) {
193 if (pos
->type
== type
&&
200 spin_unlock_irqrestore(&allpstore_lock
, flags
);
205 inode
= pstore_get_inode(pstore_sb
);
208 inode
->i_mode
= S_IFREG
| 0444;
209 inode
->i_fop
= &pstore_file_operations
;
210 private = kmalloc(sizeof *private + size
, GFP_KERNEL
);
213 private->type
= type
;
218 case PSTORE_TYPE_DMESG
:
219 sprintf(name
, "dmesg-%s-%lld", psname
, id
);
221 case PSTORE_TYPE_MCE
:
222 sprintf(name
, "mce-%s-%lld", psname
, id
);
224 case PSTORE_TYPE_UNKNOWN
:
225 sprintf(name
, "unknown-%s-%lld", psname
, id
);
228 sprintf(name
, "type%d-%s-%lld", type
, psname
, id
);
232 mutex_lock(&root
->d_inode
->i_mutex
);
235 dentry
= d_alloc_name(root
, name
);
237 goto fail_lockedalloc
;
239 memcpy(private->data
, data
, size
);
240 inode
->i_size
= private->size
= size
;
242 inode
->i_private
= private;
245 inode
->i_mtime
= inode
->i_ctime
= time
;
247 d_add(dentry
, inode
);
249 spin_lock_irqsave(&allpstore_lock
, flags
);
250 list_add(&private->list
, &allpstore
);
251 spin_unlock_irqrestore(&allpstore_lock
, flags
);
253 mutex_unlock(&root
->d_inode
->i_mutex
);
258 mutex_unlock(&root
->d_inode
->i_mutex
);
267 int pstore_fill_super(struct super_block
*sb
, void *data
, int silent
)
271 save_mount_options(sb
, data
);
275 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
276 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
277 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
278 sb
->s_magic
= PSTOREFS_MAGIC
;
279 sb
->s_op
= &pstore_ops
;
284 inode
= pstore_get_inode(sb
);
286 inode
->i_mode
= S_IFDIR
| 0755;
287 inode
->i_op
= &pstore_dir_inode_operations
;
288 inode
->i_fop
= &simple_dir_operations
;
291 sb
->s_root
= d_make_root(inode
);
295 pstore_get_records(0);
300 static struct dentry
*pstore_mount(struct file_system_type
*fs_type
,
301 int flags
, const char *dev_name
, void *data
)
303 return mount_single(fs_type
, flags
, data
, pstore_fill_super
);
306 static void pstore_kill_sb(struct super_block
*sb
)
308 kill_litter_super(sb
);
312 static struct file_system_type pstore_fs_type
= {
314 .mount
= pstore_mount
,
315 .kill_sb
= pstore_kill_sb
,
318 static int __init
init_pstore_fs(void)
320 return register_filesystem(&pstore_fs_type
);
322 module_init(init_pstore_fs
)
324 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
325 MODULE_LICENSE("GPL");