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/string.h>
28 #include <linux/mount.h>
29 #include <linux/ramfs.h>
30 #include <linux/sched.h>
31 #include <linux/magic.h>
32 #include <linux/pstore.h>
33 #include <linux/slab.h>
34 #include <linux/uaccess.h>
38 #define PSTORE_NAMELEN 64
40 struct pstore_private
{
47 static int pstore_file_open(struct inode
*inode
, struct file
*file
)
49 file
->private_data
= inode
->i_private
;
53 static ssize_t
pstore_file_read(struct file
*file
, char __user
*userbuf
,
54 size_t count
, loff_t
*ppos
)
56 struct pstore_private
*ps
= file
->private_data
;
58 return simple_read_from_buffer(userbuf
, count
, ppos
, ps
->data
, ps
->size
);
61 static const struct file_operations pstore_file_operations
= {
62 .open
= pstore_file_open
,
63 .read
= pstore_file_read
,
64 .llseek
= default_llseek
,
68 * When a file is unlinked from our file system we call the
69 * platform driver to erase the record from persistent store.
71 static int pstore_unlink(struct inode
*dir
, struct dentry
*dentry
)
73 struct pstore_private
*p
= dentry
->d_inode
->i_private
;
77 return simple_unlink(dir
, dentry
);
80 static void pstore_evict_inode(struct inode
*inode
)
83 kfree(inode
->i_private
);
86 static const struct inode_operations pstore_dir_inode_operations
= {
87 .lookup
= simple_lookup
,
88 .unlink
= pstore_unlink
,
91 static struct inode
*pstore_get_inode(struct super_block
*sb
,
92 const struct inode
*dir
, int mode
, dev_t dev
)
94 struct inode
*inode
= new_inode(sb
);
97 inode
->i_ino
= get_next_ino();
98 inode
->i_uid
= inode
->i_gid
= 0;
100 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
101 switch (mode
& S_IFMT
) {
103 inode
->i_fop
= &pstore_file_operations
;
106 inode
->i_op
= &pstore_dir_inode_operations
;
107 inode
->i_fop
= &simple_dir_operations
;
115 static const struct super_operations pstore_ops
= {
116 .statfs
= simple_statfs
,
117 .drop_inode
= generic_delete_inode
,
118 .evict_inode
= pstore_evict_inode
,
119 .show_options
= generic_show_options
,
122 static struct super_block
*pstore_sb
;
124 int pstore_is_mounted(void)
126 return pstore_sb
!= NULL
;
130 * Make a regular file in the root directory of our file system.
131 * Load it up with "size" bytes of data from "buf".
132 * Set the mtime & ctime to the date that this record was originally stored.
134 int pstore_mkfile(enum pstore_type_id type
, char *psname
, u64 id
,
135 char *data
, size_t size
,
136 struct timespec time
, int (*erase
)(u64
))
138 struct dentry
*root
= pstore_sb
->s_root
;
139 struct dentry
*dentry
;
142 char name
[PSTORE_NAMELEN
];
143 struct pstore_private
*private;
146 inode
= pstore_get_inode(pstore_sb
, root
->d_inode
, S_IFREG
| 0444, 0);
149 private = kmalloc(sizeof *private + size
, GFP_KERNEL
);
153 private->erase
= erase
;
156 case PSTORE_TYPE_DMESG
:
157 sprintf(name
, "dmesg-%s-%lld", psname
, id
);
159 case PSTORE_TYPE_MCE
:
160 sprintf(name
, "mce-%s-%lld", psname
, id
);
162 case PSTORE_TYPE_UNKNOWN
:
163 sprintf(name
, "unknown-%s-%lld", psname
, id
);
166 sprintf(name
, "type%d-%s-%lld", type
, psname
, id
);
170 mutex_lock(&root
->d_inode
->i_mutex
);
173 dentry
= d_alloc_name(root
, name
);
175 goto fail_lockedalloc
;
177 memcpy(private->data
, data
, size
);
178 inode
->i_size
= private->size
= size
;
180 inode
->i_private
= private;
183 inode
->i_mtime
= inode
->i_ctime
= time
;
185 d_add(dentry
, inode
);
187 mutex_unlock(&root
->d_inode
->i_mutex
);
192 mutex_unlock(&root
->d_inode
->i_mutex
);
201 int pstore_fill_super(struct super_block
*sb
, void *data
, int silent
)
203 struct inode
*inode
= NULL
;
207 save_mount_options(sb
, data
);
211 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
212 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
213 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
214 sb
->s_magic
= PSTOREFS_MAGIC
;
215 sb
->s_op
= &pstore_ops
;
218 inode
= pstore_get_inode(sb
, NULL
, S_IFDIR
| 0755, 0);
223 /* override ramfs "dir" options so we catch unlink(2) */
224 inode
->i_op
= &pstore_dir_inode_operations
;
226 root
= d_alloc_root(inode
);
233 pstore_get_records();
241 static struct dentry
*pstore_mount(struct file_system_type
*fs_type
,
242 int flags
, const char *dev_name
, void *data
)
244 return mount_single(fs_type
, flags
, data
, pstore_fill_super
);
247 static void pstore_kill_sb(struct super_block
*sb
)
249 kill_litter_super(sb
);
253 static struct file_system_type pstore_fs_type
= {
255 .mount
= pstore_mount
,
256 .kill_sb
= pstore_kill_sb
,
259 static int __init
init_pstore_fs(void)
262 struct kobject
*pstorefs_kobj
;
264 pstorefs_kobj
= kobject_create_and_add("pstore", fs_kobj
);
265 if (!pstorefs_kobj
) {
270 rc
= sysfs_create_file(pstorefs_kobj
, &pstore_kmsg_bytes_attr
.attr
);
274 rc
= register_filesystem(&pstore_fs_type
);
278 sysfs_remove_file(pstorefs_kobj
, &pstore_kmsg_bytes_attr
.attr
);
280 kobject_put(pstorefs_kobj
);
284 module_init(init_pstore_fs
)
286 MODULE_AUTHOR("Tony Luck <tony.luck@intel.com>");
287 MODULE_LICENSE("GPL");