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 | ||
26 | #include <linux/module.h> | |
27 | #include <linux/fs.h> | |
28 | #include <linux/pagemap.h> | |
29 | #include <linux/highmem.h> | |
8dde0509 | 30 | #include <linux/time.h> |
1da177e4 LT |
31 | #include <linux/init.h> |
32 | #include <linux/string.h> | |
1da177e4 LT |
33 | #include <linux/backing-dev.h> |
34 | #include <linux/ramfs.h> | |
e8edc6e0 | 35 | #include <linux/sched.h> |
c3b1b1cb | 36 | #include <linux/parser.h> |
a7e3108c | 37 | #include <linux/magic.h> |
5a0e3ad6 | 38 | #include <linux/slab.h> |
1da177e4 | 39 | #include <asm/uaccess.h> |
642fb4d1 | 40 | #include "internal.h" |
1da177e4 | 41 | |
c3b1b1cb WF |
42 | #define RAMFS_DEFAULT_MODE 0755 |
43 | ||
ee9b6d61 | 44 | static const struct super_operations ramfs_ops; |
c5ef1c42 | 45 | static const struct inode_operations ramfs_dir_inode_operations; |
1da177e4 LT |
46 | |
47 | static struct backing_dev_info ramfs_backing_dev_info = { | |
d993831f | 48 | .name = "ramfs", |
1da177e4 | 49 | .ra_pages = 0, /* No readahead */ |
e4ad08fe | 50 | .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK | |
1da177e4 LT |
51 | BDI_CAP_MAP_DIRECT | BDI_CAP_MAP_COPY | |
52 | BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP, | |
53 | }; | |
54 | ||
55 | struct inode *ramfs_get_inode(struct super_block *sb, int mode, dev_t dev) | |
56 | { | |
57 | struct inode * inode = new_inode(sb); | |
58 | ||
59 | if (inode) { | |
60 | inode->i_mode = mode; | |
0785f4da DH |
61 | inode->i_uid = current_fsuid(); |
62 | inode->i_gid = current_fsgid(); | |
1da177e4 LT |
63 | inode->i_mapping->a_ops = &ramfs_aops; |
64 | inode->i_mapping->backing_dev_info = &ramfs_backing_dev_info; | |
769848c0 | 65 | mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); |
ba9ddf49 | 66 | mapping_set_unevictable(inode->i_mapping); |
1da177e4 LT |
67 | inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; |
68 | switch (mode & S_IFMT) { | |
69 | default: | |
70 | init_special_inode(inode, mode, dev); | |
71 | break; | |
72 | case S_IFREG: | |
73 | inode->i_op = &ramfs_file_inode_operations; | |
74 | inode->i_fop = &ramfs_file_operations; | |
75 | break; | |
76 | case S_IFDIR: | |
77 | inode->i_op = &ramfs_dir_inode_operations; | |
78 | inode->i_fop = &simple_dir_operations; | |
79 | ||
80 | /* directory inodes start off with i_nlink == 2 (for "." entry) */ | |
d8c76e6f | 81 | inc_nlink(inode); |
1da177e4 LT |
82 | break; |
83 | case S_IFLNK: | |
84 | inode->i_op = &page_symlink_inode_operations; | |
85 | break; | |
86 | } | |
87 | } | |
88 | return inode; | |
89 | } | |
90 | ||
91 | /* | |
92 | * File creation. Allocate an inode, and we're done.. | |
93 | */ | |
94 | /* SMP-safe */ | |
95 | static int | |
96 | ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) | |
97 | { | |
98 | struct inode * inode = ramfs_get_inode(dir->i_sb, mode, dev); | |
99 | int error = -ENOSPC; | |
100 | ||
101 | if (inode) { | |
102 | if (dir->i_mode & S_ISGID) { | |
103 | inode->i_gid = dir->i_gid; | |
104 | if (S_ISDIR(mode)) | |
105 | inode->i_mode |= S_ISGID; | |
106 | } | |
107 | d_instantiate(dentry, inode); | |
108 | dget(dentry); /* Extra count - pin the dentry in core */ | |
109 | error = 0; | |
8dde0509 | 110 | dir->i_mtime = dir->i_ctime = CURRENT_TIME; |
1da177e4 LT |
111 | } |
112 | return error; | |
113 | } | |
114 | ||
115 | static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode) | |
116 | { | |
117 | int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0); | |
118 | if (!retval) | |
d8c76e6f | 119 | inc_nlink(dir); |
1da177e4 LT |
120 | return retval; |
121 | } | |
122 | ||
123 | static int ramfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd) | |
124 | { | |
125 | return ramfs_mknod(dir, dentry, mode | S_IFREG, 0); | |
126 | } | |
127 | ||
128 | static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname) | |
129 | { | |
130 | struct inode *inode; | |
131 | int error = -ENOSPC; | |
132 | ||
133 | inode = ramfs_get_inode(dir->i_sb, S_IFLNK|S_IRWXUGO, 0); | |
134 | if (inode) { | |
135 | int l = strlen(symname)+1; | |
136 | error = page_symlink(inode, symname, l); | |
137 | if (!error) { | |
138 | if (dir->i_mode & S_ISGID) | |
139 | inode->i_gid = dir->i_gid; | |
140 | d_instantiate(dentry, inode); | |
141 | dget(dentry); | |
ecbd3a63 | 142 | dir->i_mtime = dir->i_ctime = CURRENT_TIME; |
1da177e4 LT |
143 | } else |
144 | iput(inode); | |
145 | } | |
146 | return error; | |
147 | } | |
148 | ||
c5ef1c42 | 149 | static const struct inode_operations ramfs_dir_inode_operations = { |
1da177e4 LT |
150 | .create = ramfs_create, |
151 | .lookup = simple_lookup, | |
152 | .link = simple_link, | |
153 | .unlink = simple_unlink, | |
154 | .symlink = ramfs_symlink, | |
155 | .mkdir = ramfs_mkdir, | |
156 | .rmdir = simple_rmdir, | |
157 | .mknod = ramfs_mknod, | |
158 | .rename = simple_rename, | |
159 | }; | |
160 | ||
ee9b6d61 | 161 | static const struct super_operations ramfs_ops = { |
1da177e4 LT |
162 | .statfs = simple_statfs, |
163 | .drop_inode = generic_delete_inode, | |
c3b1b1cb WF |
164 | .show_options = generic_show_options, |
165 | }; | |
166 | ||
167 | struct ramfs_mount_opts { | |
168 | umode_t mode; | |
169 | }; | |
170 | ||
171 | enum { | |
172 | Opt_mode, | |
173 | Opt_err | |
174 | }; | |
175 | ||
176 | static const match_table_t tokens = { | |
177 | {Opt_mode, "mode=%o"}, | |
178 | {Opt_err, NULL} | |
179 | }; | |
180 | ||
181 | struct ramfs_fs_info { | |
182 | struct ramfs_mount_opts mount_opts; | |
1da177e4 LT |
183 | }; |
184 | ||
c3b1b1cb WF |
185 | static int ramfs_parse_options(char *data, struct ramfs_mount_opts *opts) |
186 | { | |
187 | substring_t args[MAX_OPT_ARGS]; | |
188 | int option; | |
189 | int token; | |
190 | char *p; | |
191 | ||
192 | opts->mode = RAMFS_DEFAULT_MODE; | |
193 | ||
194 | while ((p = strsep(&data, ",")) != NULL) { | |
195 | if (!*p) | |
196 | continue; | |
197 | ||
198 | token = match_token(p, tokens, args); | |
199 | switch (token) { | |
200 | case Opt_mode: | |
201 | if (match_octal(&args[0], &option)) | |
202 | return -EINVAL; | |
203 | opts->mode = option & S_IALLUGO; | |
204 | break; | |
0a8eba9b MF |
205 | /* |
206 | * We might like to report bad mount options here; | |
207 | * but traditionally ramfs has ignored all mount options, | |
208 | * and as it is used as a !CONFIG_SHMEM simple substitute | |
209 | * for tmpfs, better continue to ignore other mount options. | |
210 | */ | |
c3b1b1cb WF |
211 | } |
212 | } | |
213 | ||
214 | return 0; | |
215 | } | |
216 | ||
1da177e4 LT |
217 | static int ramfs_fill_super(struct super_block * sb, void * data, int silent) |
218 | { | |
c3b1b1cb WF |
219 | struct ramfs_fs_info *fsi; |
220 | struct inode *inode = NULL; | |
221 | struct dentry *root; | |
222 | int err; | |
223 | ||
224 | save_mount_options(sb, data); | |
225 | ||
226 | fsi = kzalloc(sizeof(struct ramfs_fs_info), GFP_KERNEL); | |
f8201abc | 227 | sb->s_fs_info = fsi; |
c3b1b1cb WF |
228 | if (!fsi) { |
229 | err = -ENOMEM; | |
230 | goto fail; | |
231 | } | |
c3b1b1cb WF |
232 | |
233 | err = ramfs_parse_options(data, &fsi->mount_opts); | |
234 | if (err) | |
235 | goto fail; | |
1da177e4 | 236 | |
f8201abc IM |
237 | sb->s_maxbytes = MAX_LFS_FILESIZE; |
238 | sb->s_blocksize = PAGE_CACHE_SIZE; | |
239 | sb->s_blocksize_bits = PAGE_CACHE_SHIFT; | |
240 | sb->s_magic = RAMFS_MAGIC; | |
241 | sb->s_op = &ramfs_ops; | |
242 | sb->s_time_gran = 1; | |
243 | ||
c3b1b1cb WF |
244 | inode = ramfs_get_inode(sb, S_IFDIR | fsi->mount_opts.mode, 0); |
245 | if (!inode) { | |
246 | err = -ENOMEM; | |
247 | goto fail; | |
248 | } | |
1da177e4 LT |
249 | |
250 | root = d_alloc_root(inode); | |
f8201abc | 251 | sb->s_root = root; |
1da177e4 | 252 | if (!root) { |
c3b1b1cb WF |
253 | err = -ENOMEM; |
254 | goto fail; | |
1da177e4 | 255 | } |
f8201abc | 256 | |
1da177e4 | 257 | return 0; |
c3b1b1cb WF |
258 | fail: |
259 | kfree(fsi); | |
f8201abc | 260 | sb->s_fs_info = NULL; |
c3b1b1cb WF |
261 | iput(inode); |
262 | return err; | |
1da177e4 LT |
263 | } |
264 | ||
454e2398 DH |
265 | int ramfs_get_sb(struct file_system_type *fs_type, |
266 | int flags, const char *dev_name, void *data, struct vfsmount *mnt) | |
1da177e4 | 267 | { |
454e2398 | 268 | return get_sb_nodev(fs_type, flags, data, ramfs_fill_super, mnt); |
1da177e4 LT |
269 | } |
270 | ||
454e2398 DH |
271 | static int rootfs_get_sb(struct file_system_type *fs_type, |
272 | int flags, const char *dev_name, void *data, struct vfsmount *mnt) | |
1da177e4 | 273 | { |
454e2398 DH |
274 | return get_sb_nodev(fs_type, flags|MS_NOUSER, data, ramfs_fill_super, |
275 | mnt); | |
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", | |
286 | .get_sb = ramfs_get_sb, | |
c3b1b1cb | 287 | .kill_sb = ramfs_kill_sb, |
1da177e4 LT |
288 | }; |
289 | static struct file_system_type rootfs_fs_type = { | |
290 | .name = "rootfs", | |
291 | .get_sb = rootfs_get_sb, | |
292 | .kill_sb = kill_litter_super, | |
293 | }; | |
294 | ||
295 | static int __init init_ramfs_fs(void) | |
296 | { | |
297 | return register_filesystem(&ramfs_fs_type); | |
298 | } | |
299 | ||
300 | static void __exit exit_ramfs_fs(void) | |
301 | { | |
302 | unregister_filesystem(&ramfs_fs_type); | |
303 | } | |
304 | ||
305 | module_init(init_ramfs_fs) | |
306 | module_exit(exit_ramfs_fs) | |
307 | ||
308 | int __init init_rootfs(void) | |
309 | { | |
e0bf68dd PZ |
310 | int err; |
311 | ||
312 | err = bdi_init(&ramfs_backing_dev_info); | |
313 | if (err) | |
314 | return err; | |
315 | ||
316 | err = register_filesystem(&rootfs_fs_type); | |
317 | if (err) | |
318 | bdi_destroy(&ramfs_backing_dev_info); | |
319 | ||
320 | return err; | |
1da177e4 LT |
321 | } |
322 | ||
323 | MODULE_LICENSE("GPL"); |