Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Resizable simple ram filesystem for Linux. | |
3 | * | |
4 | * Copyright (C) 2000 Linus Torvalds. | |
5 | * 2000 Transmeta Corp. | |
6 | * | |
7 | * Usage limits added by David Gibson, Linuxcare Australia. | |
8 | * This file is released under the GPL. | |
9 | */ | |
10 | ||
11 | /* | |
12 | * NOTE! This filesystem is probably most useful | |
13 | * not as a real filesystem, but as an example of | |
14 | * how virtual filesystems can be written. | |
15 | * | |
16 | * It doesn't get much simpler than this. Consider | |
17 | * that this file implements the full semantics of | |
18 | * a POSIX-compliant read-write filesystem. | |
19 | * | |
20 | * Note in particular how the filesystem does not | |
21 | * need to implement any data structures of its own | |
22 | * to keep track of the virtual data: using the VFS | |
23 | * caches is sufficient. | |
24 | */ | |
25 | ||
1da177e4 LT |
26 | #include <linux/fs.h> |
27 | #include <linux/pagemap.h> | |
28 | #include <linux/highmem.h> | |
8dde0509 | 29 | #include <linux/time.h> |
1da177e4 LT |
30 | #include <linux/init.h> |
31 | #include <linux/string.h> | |
1da177e4 LT |
32 | #include <linux/backing-dev.h> |
33 | #include <linux/ramfs.h> | |
e8edc6e0 | 34 | #include <linux/sched.h> |
c3b1b1cb | 35 | #include <linux/parser.h> |
a7e3108c | 36 | #include <linux/magic.h> |
5a0e3ad6 | 37 | #include <linux/slab.h> |
7c0f6ba6 | 38 | #include <linux/uaccess.h> |
f3235626 DH |
39 | #include <linux/fs_context.h> |
40 | #include <linux/fs_parser.h> | |
e41d12f5 | 41 | #include <linux/seq_file.h> |
642fb4d1 | 42 | #include "internal.h" |
1da177e4 | 43 | |
604ecf42 DH |
44 | struct ramfs_mount_opts { |
45 | umode_t mode; | |
46 | }; | |
47 | ||
48 | struct ramfs_fs_info { | |
49 | struct ramfs_mount_opts mount_opts; | |
50 | }; | |
51 | ||
c3b1b1cb WF |
52 | #define RAMFS_DEFAULT_MODE 0755 |
53 | ||
ee9b6d61 | 54 | static const struct super_operations ramfs_ops; |
c5ef1c42 | 55 | static const struct inode_operations ramfs_dir_inode_operations; |
1da177e4 | 56 | |
454abafe | 57 | struct inode *ramfs_get_inode(struct super_block *sb, |
632861f0 | 58 | const struct inode *dir, umode_t mode, dev_t dev) |
1da177e4 LT |
59 | { |
60 | struct inode * inode = new_inode(sb); | |
61 | ||
62 | if (inode) { | |
85fe4025 | 63 | inode->i_ino = get_next_ino(); |
21cb47be | 64 | inode_init_owner(&init_user_ns, inode, dir, mode); |
c1e3dbe9 | 65 | inode->i_mapping->a_ops = &ram_aops; |
769848c0 | 66 | mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); |
ba9ddf49 | 67 | mapping_set_unevictable(inode->i_mapping); |
078cd827 | 68 | inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode); |
1da177e4 LT |
69 | switch (mode & S_IFMT) { |
70 | default: | |
71 | init_special_inode(inode, mode, dev); | |
72 | break; | |
73 | case S_IFREG: | |
74 | inode->i_op = &ramfs_file_inode_operations; | |
75 | inode->i_fop = &ramfs_file_operations; | |
76 | break; | |
77 | case S_IFDIR: | |
78 | inode->i_op = &ramfs_dir_inode_operations; | |
79 | inode->i_fop = &simple_dir_operations; | |
80 | ||
81 | /* directory inodes start off with i_nlink == 2 (for "." entry) */ | |
d8c76e6f | 82 | inc_nlink(inode); |
1da177e4 LT |
83 | break; |
84 | case S_IFLNK: | |
85 | inode->i_op = &page_symlink_inode_operations; | |
21fc61c7 | 86 | inode_nohighmem(inode); |
1da177e4 LT |
87 | break; |
88 | } | |
89 | } | |
90 | return inode; | |
91 | } | |
92 | ||
93 | /* | |
94 | * File creation. Allocate an inode, and we're done.. | |
95 | */ | |
96 | /* SMP-safe */ | |
97 | static int | |
549c7297 CB |
98 | ramfs_mknod(struct user_namespace *mnt_userns, struct inode *dir, |
99 | struct dentry *dentry, umode_t mode, dev_t dev) | |
1da177e4 | 100 | { |
454abafe | 101 | struct inode * inode = ramfs_get_inode(dir->i_sb, dir, mode, dev); |
1da177e4 LT |
102 | int error = -ENOSPC; |
103 | ||
104 | if (inode) { | |
1da177e4 LT |
105 | d_instantiate(dentry, inode); |
106 | dget(dentry); /* Extra count - pin the dentry in core */ | |
107 | error = 0; | |
078cd827 | 108 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 LT |
109 | } |
110 | return error; | |
111 | } | |
112 | ||
549c7297 CB |
113 | static int ramfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir, |
114 | struct dentry *dentry, umode_t mode) | |
1da177e4 | 115 | { |
549c7297 | 116 | int retval = ramfs_mknod(&init_user_ns, dir, dentry, mode | S_IFDIR, 0); |
1da177e4 | 117 | if (!retval) |
d8c76e6f | 118 | inc_nlink(dir); |
1da177e4 LT |
119 | return retval; |
120 | } | |
121 | ||
549c7297 CB |
122 | static int ramfs_create(struct user_namespace *mnt_userns, struct inode *dir, |
123 | struct dentry *dentry, umode_t mode, bool excl) | |
1da177e4 | 124 | { |
549c7297 | 125 | return ramfs_mknod(&init_user_ns, dir, dentry, mode | S_IFREG, 0); |
1da177e4 LT |
126 | } |
127 | ||
549c7297 CB |
128 | static int ramfs_symlink(struct user_namespace *mnt_userns, struct inode *dir, |
129 | struct dentry *dentry, const char *symname) | |
1da177e4 LT |
130 | { |
131 | struct inode *inode; | |
132 | int error = -ENOSPC; | |
133 | ||
454abafe | 134 | inode = ramfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0); |
1da177e4 LT |
135 | if (inode) { |
136 | int l = strlen(symname)+1; | |
137 | error = page_symlink(inode, symname, l); | |
138 | if (!error) { | |
1da177e4 LT |
139 | d_instantiate(dentry, inode); |
140 | dget(dentry); | |
078cd827 | 141 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 LT |
142 | } else |
143 | iput(inode); | |
144 | } | |
145 | return error; | |
146 | } | |
147 | ||
93da4003 AD |
148 | static int ramfs_tmpfile(struct user_namespace *mnt_userns, |
149 | struct inode *dir, struct dentry *dentry, umode_t mode) | |
150 | { | |
151 | struct inode *inode; | |
152 | ||
153 | inode = ramfs_get_inode(dir->i_sb, dir, mode, 0); | |
154 | if (!inode) | |
155 | return -ENOSPC; | |
156 | d_tmpfile(dentry, inode); | |
157 | return 0; | |
158 | } | |
159 | ||
c5ef1c42 | 160 | static const struct inode_operations ramfs_dir_inode_operations = { |
1da177e4 LT |
161 | .create = ramfs_create, |
162 | .lookup = simple_lookup, | |
163 | .link = simple_link, | |
164 | .unlink = simple_unlink, | |
165 | .symlink = ramfs_symlink, | |
166 | .mkdir = ramfs_mkdir, | |
167 | .rmdir = simple_rmdir, | |
168 | .mknod = ramfs_mknod, | |
169 | .rename = simple_rename, | |
93da4003 | 170 | .tmpfile = ramfs_tmpfile, |
1da177e4 LT |
171 | }; |
172 | ||
604ecf42 DH |
173 | /* |
174 | * Display the mount options in /proc/mounts. | |
175 | */ | |
176 | static int ramfs_show_options(struct seq_file *m, struct dentry *root) | |
177 | { | |
178 | struct ramfs_fs_info *fsi = root->d_sb->s_fs_info; | |
179 | ||
180 | if (fsi->mount_opts.mode != RAMFS_DEFAULT_MODE) | |
181 | seq_printf(m, ",mode=%o", fsi->mount_opts.mode); | |
182 | return 0; | |
183 | } | |
184 | ||
ee9b6d61 | 185 | static const struct super_operations ramfs_ops = { |
1da177e4 LT |
186 | .statfs = simple_statfs, |
187 | .drop_inode = generic_delete_inode, | |
604ecf42 | 188 | .show_options = ramfs_show_options, |
c3b1b1cb WF |
189 | }; |
190 | ||
f3235626 | 191 | enum ramfs_param { |
c3b1b1cb | 192 | Opt_mode, |
c3b1b1cb WF |
193 | }; |
194 | ||
d7167b14 | 195 | const struct fs_parameter_spec ramfs_fs_parameters[] = { |
f3235626 DH |
196 | fsparam_u32oct("mode", Opt_mode), |
197 | {} | |
c3b1b1cb WF |
198 | }; |
199 | ||
f3235626 | 200 | static int ramfs_parse_param(struct fs_context *fc, struct fs_parameter *param) |
c3b1b1cb | 201 | { |
f3235626 DH |
202 | struct fs_parse_result result; |
203 | struct ramfs_fs_info *fsi = fc->s_fs_info; | |
204 | int opt; | |
205 | ||
d7167b14 | 206 | opt = fs_parse(fc, ramfs_fs_parameters, param, &result); |
f3235626 | 207 | if (opt < 0) { |
0a8eba9b MF |
208 | /* |
209 | * We might like to report bad mount options here; | |
210 | * but traditionally ramfs has ignored all mount options, | |
211 | * and as it is used as a !CONFIG_SHMEM simple substitute | |
212 | * for tmpfs, better continue to ignore other mount options. | |
213 | */ | |
f3235626 DH |
214 | if (opt == -ENOPARAM) |
215 | opt = 0; | |
216 | return opt; | |
217 | } | |
218 | ||
219 | switch (opt) { | |
220 | case Opt_mode: | |
221 | fsi->mount_opts.mode = result.uint_32 & S_IALLUGO; | |
222 | break; | |
c3b1b1cb WF |
223 | } |
224 | ||
225 | return 0; | |
226 | } | |
227 | ||
f3235626 | 228 | static int ramfs_fill_super(struct super_block *sb, struct fs_context *fc) |
1da177e4 | 229 | { |
f3235626 | 230 | struct ramfs_fs_info *fsi = sb->s_fs_info; |
318ceed0 | 231 | struct inode *inode; |
1da177e4 | 232 | |
f8201abc | 233 | sb->s_maxbytes = MAX_LFS_FILESIZE; |
09cbfeaf KS |
234 | sb->s_blocksize = PAGE_SIZE; |
235 | sb->s_blocksize_bits = PAGE_SHIFT; | |
f8201abc IM |
236 | sb->s_magic = RAMFS_MAGIC; |
237 | sb->s_op = &ramfs_ops; | |
238 | sb->s_time_gran = 1; | |
239 | ||
454abafe | 240 | inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0); |
48fde701 | 241 | sb->s_root = d_make_root(inode); |
318ceed0 AV |
242 | if (!sb->s_root) |
243 | return -ENOMEM; | |
f8201abc | 244 | |
1da177e4 LT |
245 | return 0; |
246 | } | |
247 | ||
f3235626 | 248 | static int ramfs_get_tree(struct fs_context *fc) |
1da177e4 | 249 | { |
f3235626 DH |
250 | return get_tree_nodev(fc, ramfs_fill_super); |
251 | } | |
252 | ||
253 | static void ramfs_free_fc(struct fs_context *fc) | |
254 | { | |
255 | kfree(fc->s_fs_info); | |
256 | } | |
257 | ||
258 | static const struct fs_context_operations ramfs_context_ops = { | |
259 | .free = ramfs_free_fc, | |
260 | .parse_param = ramfs_parse_param, | |
261 | .get_tree = ramfs_get_tree, | |
262 | }; | |
263 | ||
264 | int ramfs_init_fs_context(struct fs_context *fc) | |
265 | { | |
266 | struct ramfs_fs_info *fsi; | |
267 | ||
268 | fsi = kzalloc(sizeof(*fsi), GFP_KERNEL); | |
269 | if (!fsi) | |
270 | return -ENOMEM; | |
271 | ||
272 | fsi->mount_opts.mode = RAMFS_DEFAULT_MODE; | |
273 | fc->s_fs_info = fsi; | |
274 | fc->ops = &ramfs_context_ops; | |
275 | return 0; | |
1da177e4 LT |
276 | } |
277 | ||
c3b1b1cb WF |
278 | static void ramfs_kill_sb(struct super_block *sb) |
279 | { | |
280 | kfree(sb->s_fs_info); | |
281 | kill_litter_super(sb); | |
282 | } | |
283 | ||
1da177e4 LT |
284 | static struct file_system_type ramfs_fs_type = { |
285 | .name = "ramfs", | |
f3235626 | 286 | .init_fs_context = ramfs_init_fs_context, |
d7167b14 | 287 | .parameters = ramfs_fs_parameters, |
c3b1b1cb | 288 | .kill_sb = ramfs_kill_sb, |
b3c6761d | 289 | .fs_flags = FS_USERNS_MOUNT, |
1da177e4 | 290 | }; |
1da177e4 | 291 | |
14a253ce | 292 | static int __init init_ramfs_fs(void) |
1da177e4 | 293 | { |
b4caecd4 | 294 | return register_filesystem(&ramfs_fs_type); |
1da177e4 | 295 | } |
af52b040 | 296 | fs_initcall(init_ramfs_fs); |