Root/
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> |
30 | #include <linux/time.h> |
31 | #include <linux/init.h> |
32 | #include <linux/string.h> |
33 | #include <linux/backing-dev.h> |
34 | #include <linux/ramfs.h> |
35 | #include <linux/sched.h> |
36 | #include <linux/parser.h> |
37 | #include <linux/magic.h> |
38 | #include <linux/slab.h> |
39 | #include <asm/uaccess.h> |
40 | #include "internal.h" |
41 | |
42 | #define RAMFS_DEFAULT_MODE 0755 |
43 | |
44 | static const struct super_operations ramfs_ops; |
45 | static const struct inode_operations ramfs_dir_inode_operations; |
46 | |
47 | static struct backing_dev_info ramfs_backing_dev_info = { |
48 | .name = "ramfs", |
49 | .ra_pages = 0, /* No readahead */ |
50 | .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK | |
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, |
56 | const struct inode *dir, int mode, dev_t dev) |
57 | { |
58 | struct inode * inode = new_inode(sb); |
59 | |
60 | if (inode) { |
61 | inode->i_ino = get_next_ino(); |
62 | inode_init_owner(inode, dir, mode); |
63 | inode->i_mapping->a_ops = &ramfs_aops; |
64 | inode->i_mapping->backing_dev_info = &ramfs_backing_dev_info; |
65 | mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); |
66 | mapping_set_unevictable(inode->i_mapping); |
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) */ |
81 | inc_nlink(inode); |
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, dir, mode, dev); |
99 | int error = -ENOSPC; |
100 | |
101 | if (inode) { |
102 | d_instantiate(dentry, inode); |
103 | dget(dentry); /* Extra count - pin the dentry in core */ |
104 | error = 0; |
105 | dir->i_mtime = dir->i_ctime = CURRENT_TIME; |
106 | } |
107 | return error; |
108 | } |
109 | |
110 | static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode) |
111 | { |
112 | int retval = ramfs_mknod(dir, dentry, mode | S_IFDIR, 0); |
113 | if (!retval) |
114 | inc_nlink(dir); |
115 | return retval; |
116 | } |
117 | |
118 | static int ramfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd) |
119 | { |
120 | return ramfs_mknod(dir, dentry, mode | S_IFREG, 0); |
121 | } |
122 | |
123 | static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname) |
124 | { |
125 | struct inode *inode; |
126 | int error = -ENOSPC; |
127 | |
128 | inode = ramfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0); |
129 | if (inode) { |
130 | int l = strlen(symname)+1; |
131 | error = page_symlink(inode, symname, l); |
132 | if (!error) { |
133 | d_instantiate(dentry, inode); |
134 | dget(dentry); |
135 | dir->i_mtime = dir->i_ctime = CURRENT_TIME; |
136 | } else |
137 | iput(inode); |
138 | } |
139 | return error; |
140 | } |
141 | |
142 | static const struct inode_operations ramfs_dir_inode_operations = { |
143 | .create = ramfs_create, |
144 | .lookup = simple_lookup, |
145 | .link = simple_link, |
146 | .unlink = simple_unlink, |
147 | .symlink = ramfs_symlink, |
148 | .mkdir = ramfs_mkdir, |
149 | .rmdir = simple_rmdir, |
150 | .mknod = ramfs_mknod, |
151 | .rename = simple_rename, |
152 | }; |
153 | |
154 | static const struct super_operations ramfs_ops = { |
155 | .statfs = simple_statfs, |
156 | .drop_inode = generic_delete_inode, |
157 | .show_options = generic_show_options, |
158 | }; |
159 | |
160 | struct ramfs_mount_opts { |
161 | umode_t mode; |
162 | }; |
163 | |
164 | enum { |
165 | Opt_mode, |
166 | Opt_err |
167 | }; |
168 | |
169 | static const match_table_t tokens = { |
170 | {Opt_mode, "mode=%o"}, |
171 | {Opt_err, NULL} |
172 | }; |
173 | |
174 | struct ramfs_fs_info { |
175 | struct ramfs_mount_opts mount_opts; |
176 | }; |
177 | |
178 | static int ramfs_parse_options(char *data, struct ramfs_mount_opts *opts) |
179 | { |
180 | substring_t args[MAX_OPT_ARGS]; |
181 | int option; |
182 | int token; |
183 | char *p; |
184 | |
185 | opts->mode = RAMFS_DEFAULT_MODE; |
186 | |
187 | while ((p = strsep(&data, ",")) != NULL) { |
188 | if (!*p) |
189 | continue; |
190 | |
191 | token = match_token(p, tokens, args); |
192 | switch (token) { |
193 | case Opt_mode: |
194 | if (match_octal(&args[0], &option)) |
195 | return -EINVAL; |
196 | opts->mode = option & S_IALLUGO; |
197 | break; |
198 | /* |
199 | * We might like to report bad mount options here; |
200 | * but traditionally ramfs has ignored all mount options, |
201 | * and as it is used as a !CONFIG_SHMEM simple substitute |
202 | * for tmpfs, better continue to ignore other mount options. |
203 | */ |
204 | } |
205 | } |
206 | |
207 | return 0; |
208 | } |
209 | |
210 | int ramfs_fill_super(struct super_block *sb, void *data, int silent) |
211 | { |
212 | struct ramfs_fs_info *fsi; |
213 | struct inode *inode = NULL; |
214 | struct dentry *root; |
215 | int err; |
216 | |
217 | save_mount_options(sb, data); |
218 | |
219 | fsi = kzalloc(sizeof(struct ramfs_fs_info), GFP_KERNEL); |
220 | sb->s_fs_info = fsi; |
221 | if (!fsi) { |
222 | err = -ENOMEM; |
223 | goto fail; |
224 | } |
225 | |
226 | err = ramfs_parse_options(data, &fsi->mount_opts); |
227 | if (err) |
228 | goto fail; |
229 | |
230 | sb->s_maxbytes = MAX_LFS_FILESIZE; |
231 | sb->s_blocksize = PAGE_CACHE_SIZE; |
232 | sb->s_blocksize_bits = PAGE_CACHE_SHIFT; |
233 | sb->s_magic = RAMFS_MAGIC; |
234 | sb->s_op = &ramfs_ops; |
235 | sb->s_time_gran = 1; |
236 | |
237 | inode = ramfs_get_inode(sb, NULL, S_IFDIR | fsi->mount_opts.mode, 0); |
238 | if (!inode) { |
239 | err = -ENOMEM; |
240 | goto fail; |
241 | } |
242 | |
243 | root = d_alloc_root(inode); |
244 | sb->s_root = root; |
245 | if (!root) { |
246 | err = -ENOMEM; |
247 | goto fail; |
248 | } |
249 | |
250 | return 0; |
251 | fail: |
252 | kfree(fsi); |
253 | sb->s_fs_info = NULL; |
254 | iput(inode); |
255 | return err; |
256 | } |
257 | |
258 | struct dentry *ramfs_mount(struct file_system_type *fs_type, |
259 | int flags, const char *dev_name, void *data) |
260 | { |
261 | return mount_nodev(fs_type, flags, data, ramfs_fill_super); |
262 | } |
263 | |
264 | static struct dentry *rootfs_mount(struct file_system_type *fs_type, |
265 | int flags, const char *dev_name, void *data) |
266 | { |
267 | return mount_nodev(fs_type, flags|MS_NOUSER, data, ramfs_fill_super); |
268 | } |
269 | |
270 | static void ramfs_kill_sb(struct super_block *sb) |
271 | { |
272 | kfree(sb->s_fs_info); |
273 | kill_litter_super(sb); |
274 | } |
275 | |
276 | static struct file_system_type ramfs_fs_type = { |
277 | .name = "ramfs", |
278 | .mount = ramfs_mount, |
279 | .kill_sb = ramfs_kill_sb, |
280 | }; |
281 | static struct file_system_type rootfs_fs_type = { |
282 | .name = "rootfs", |
283 | .mount = rootfs_mount, |
284 | .kill_sb = kill_litter_super, |
285 | }; |
286 | |
287 | static int __init init_ramfs_fs(void) |
288 | { |
289 | return register_filesystem(&ramfs_fs_type); |
290 | } |
291 | |
292 | static void __exit exit_ramfs_fs(void) |
293 | { |
294 | unregister_filesystem(&ramfs_fs_type); |
295 | } |
296 | |
297 | module_init(init_ramfs_fs) |
298 | module_exit(exit_ramfs_fs) |
299 | |
300 | int __init init_rootfs(void) |
301 | { |
302 | int err; |
303 | |
304 | err = bdi_init(&ramfs_backing_dev_info); |
305 | if (err) |
306 | return err; |
307 | |
308 | err = register_filesystem(&rootfs_fs_type); |
309 | if (err) |
310 | bdi_destroy(&ramfs_backing_dev_info); |
311 | |
312 | return err; |
313 | } |
314 | |
315 | MODULE_LICENSE("GPL"); |
316 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9