[PATCH] (5/5) more BKL shifting
[opensuse:kernel.git] / fs / ramfs / inode.c
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/init.h>
30 #include <linux/string.h>
31 #include <linux/locks.h>
32 #include <linux/smp_lock.h>
33
34 #include <asm/uaccess.h>
35
36 /* some random number */
37 #define RAMFS_MAGIC     0x858458f6
38
39 static struct super_operations ramfs_ops;
40 static struct address_space_operations ramfs_aops;
41 static struct file_operations ramfs_dir_operations;
42 static struct file_operations ramfs_file_operations;
43 static struct inode_operations ramfs_dir_inode_operations;
44
45 static int ramfs_statfs(struct super_block *sb, struct statfs *buf)
46 {
47         buf->f_type = RAMFS_MAGIC;
48         buf->f_bsize = PAGE_CACHE_SIZE;
49         buf->f_namelen = 255;
50         return 0;
51 }
52
53 /*
54  * Lookup the data. This is trivial - if the dentry didn't already
55  * exist, we know it is negative.
56  */
57 /* SMP-safe */
58 static struct dentry * ramfs_lookup(struct inode *dir, struct dentry *dentry)
59 {
60         d_add(dentry, NULL);
61         return NULL;
62 }
63
64 /*
65  * Read a page. Again trivial. If it didn't already exist
66  * in the page cache, it is zero-filled.
67  */
68 static int ramfs_readpage(struct file *file, struct page * page)
69 {
70         if (!Page_Uptodate(page)) {
71                 memset(kmap(page), 0, PAGE_CACHE_SIZE);
72                 kunmap(page);
73                 flush_dcache_page(page);
74                 SetPageUptodate(page);
75         }
76         UnlockPage(page);
77         return 0;
78 }
79
80 static int ramfs_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to)
81 {
82         void *addr = kmap(page);
83         if (!Page_Uptodate(page)) {
84                 memset(addr, 0, PAGE_CACHE_SIZE);
85                 flush_dcache_page(page);
86                 SetPageUptodate(page);
87         }
88         SetPageDirty(page);
89         return 0;
90 }
91
92 static int ramfs_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to)
93 {
94         struct inode *inode = page->mapping->host;
95         loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
96
97         kunmap(page);
98         if (pos > inode->i_size)
99                 inode->i_size = pos;
100         return 0;
101 }
102
103 struct inode *ramfs_get_inode(struct super_block *sb, int mode, int dev)
104 {
105         struct inode * inode = new_inode(sb);
106
107         if (inode) {
108                 inode->i_mode = mode;
109                 inode->i_uid = current->fsuid;
110                 inode->i_gid = current->fsgid;
111                 inode->i_blksize = PAGE_CACHE_SIZE;
112                 inode->i_blocks = 0;
113                 inode->i_rdev = NODEV;
114                 inode->i_mapping->a_ops = &ramfs_aops;
115                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
116                 switch (mode & S_IFMT) {
117                 default:
118                         init_special_inode(inode, mode, dev);
119                         break;
120                 case S_IFREG:
121                         inode->i_fop = &ramfs_file_operations;
122                         break;
123                 case S_IFDIR:
124                         inode->i_op = &ramfs_dir_inode_operations;
125                         inode->i_fop = &ramfs_dir_operations;
126                         break;
127                 case S_IFLNK:
128                         inode->i_op = &page_symlink_inode_operations;
129                         break;
130                 }
131         }
132         return inode;
133 }
134
135 /*
136  * File creation. Allocate an inode, and we're done..
137  */
138 /* SMP-safe */
139 static int ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev)
140 {
141         struct inode * inode = ramfs_get_inode(dir->i_sb, mode, dev);
142         int error = -ENOSPC;
143
144         if (inode) {
145                 d_instantiate(dentry, inode);
146                 dget(dentry);           /* Extra count - pin the dentry in core */
147                 error = 0;
148         }
149         return error;
150 }
151
152 static int ramfs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
153 {
154         return ramfs_mknod(dir, dentry, mode | S_IFDIR, 0);
155 }
156
157 static int ramfs_create(struct inode *dir, struct dentry *dentry, int mode)
158 {
159         return ramfs_mknod(dir, dentry, mode | S_IFREG, 0);
160 }
161
162 /*
163  * Link a file..
164  */
165 static int ramfs_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry)
166 {
167         struct inode *inode = old_dentry->d_inode;
168
169         inode->i_nlink++;
170         atomic_inc(&inode->i_count);    /* New dentry reference */
171         dget(dentry);           /* Extra pinning count for the created dentry */
172         d_instantiate(dentry, inode);
173         return 0;
174 }
175
176 static inline int ramfs_positive(struct dentry *dentry)
177 {
178         return dentry->d_inode && !d_unhashed(dentry);
179 }
180
181 /*
182  * Check that a directory is empty (this works
183  * for regular files too, they'll just always be
184  * considered empty..).
185  *
186  * Note that an empty directory can still have
187  * children, they just all have to be negative..
188  */
189 static int ramfs_empty(struct dentry *dentry)
190 {
191         struct list_head *list;
192
193         spin_lock(&dcache_lock);
194         list = dentry->d_subdirs.next;
195
196         while (list != &dentry->d_subdirs) {
197                 struct dentry *de = list_entry(list, struct dentry, d_child);
198
199                 if (ramfs_positive(de)) {
200                         spin_unlock(&dcache_lock);
201                         return 0;
202                 }
203                 list = list->next;
204         }
205         spin_unlock(&dcache_lock);
206         return 1;
207 }
208
209 /*
210  * This works for both directories and regular files.
211  * (non-directories will always have empty subdirs)
212  */
213 static int ramfs_unlink(struct inode * dir, struct dentry *dentry)
214 {
215         int retval = -ENOTEMPTY;
216
217         if (ramfs_empty(dentry)) {
218                 struct inode *inode = dentry->d_inode;
219
220                 inode->i_nlink--;
221                 dput(dentry);                   /* Undo the count from "create" - this does all the work */
222                 retval = 0;
223         }
224         return retval;
225 }
226
227 #define ramfs_rmdir ramfs_unlink
228
229 /*
230  * The VFS layer already does all the dentry stuff for rename,
231  * we just have to decrement the usage count for the target if
232  * it exists so that the VFS layer correctly free's it when it
233  * gets overwritten.
234  */
235 static int ramfs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry)
236 {
237         int error = -ENOTEMPTY;
238
239         if (ramfs_empty(new_dentry)) {
240                 struct inode *inode = new_dentry->d_inode;
241                 if (inode) {
242                         inode->i_nlink--;
243                         dput(new_dentry);
244                 }
245                 error = 0;
246         }
247         return error;
248 }
249
250 static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
251 {
252         struct inode *inode;
253         int error = -ENOSPC;
254
255         inode = ramfs_get_inode(dir->i_sb, S_IFLNK|S_IRWXUGO, 0);
256         if (inode) {
257                 int l = strlen(symname)+1;
258                 error = block_symlink(inode, symname, l);
259                 if (!error) {
260                         d_instantiate(dentry, inode);
261                         dget(dentry);
262                 } else
263                         iput(inode);
264         }
265         return error;
266 }
267
268 static int ramfs_sync_file(struct file * file, struct dentry *dentry, int datasync)
269 {
270         return 0;
271 }
272
273 static struct address_space_operations ramfs_aops = {
274         readpage:       ramfs_readpage,
275         writepage:      fail_writepage,
276         prepare_write:  ramfs_prepare_write,
277         commit_write:   ramfs_commit_write
278 };
279
280 static struct file_operations ramfs_file_operations = {
281         read:           generic_file_read,
282         write:          generic_file_write,
283         mmap:           generic_file_mmap,
284         fsync:          ramfs_sync_file,
285 };
286
287 static struct file_operations ramfs_dir_operations = {
288         read:           generic_read_dir,
289         readdir:        dcache_readdir,
290         fsync:          ramfs_sync_file,
291 };
292
293 static struct inode_operations ramfs_dir_inode_operations = {
294         create:         ramfs_create,
295         lookup:         ramfs_lookup,
296         link:           ramfs_link,
297         unlink:         ramfs_unlink,
298         symlink:        ramfs_symlink,
299         mkdir:          ramfs_mkdir,
300         rmdir:          ramfs_rmdir,
301         mknod:          ramfs_mknod,
302         rename:         ramfs_rename,
303 };
304
305 static struct super_operations ramfs_ops = {
306         statfs:         ramfs_statfs,
307         put_inode:      force_delete,
308 };
309
310 static int ramfs_fill_super(struct super_block * sb, void * data, int silent)
311 {
312         struct inode * inode;
313         struct dentry * root;
314
315         sb->s_blocksize = PAGE_CACHE_SIZE;
316         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
317         sb->s_magic = RAMFS_MAGIC;
318         sb->s_op = &ramfs_ops;
319         inode = ramfs_get_inode(sb, S_IFDIR | 0755, 0);
320         if (!inode)
321                 return -ENOMEM;
322
323         root = d_alloc_root(inode);
324         if (!root) {
325                 iput(inode);
326                 return -ENOMEM;
327         }
328         sb->s_root = root;
329         return 0;
330 }
331
332 static struct super_block *ramfs_get_sb(struct file_system_type *fs_type,
333         int flags, char *dev_name, void *data)
334 {
335         return get_sb_nodev(fs_type, flags, data, ramfs_fill_super);
336 }
337
338 static struct file_system_type ramfs_fs_type = {
339         name:           "ramfs",
340         get_sb:         ramfs_get_sb,
341         fs_flags:       FS_LITTER,
342 };
343 static struct file_system_type rootfs_fs_type = {
344         name:           "rootfs",
345         get_sb:         ramfs_get_sb,
346         fs_flags:       FS_NOMOUNT|FS_LITTER,
347 };
348
349 static int __init init_ramfs_fs(void)
350 {
351         return register_filesystem(&ramfs_fs_type);
352 }
353
354 static void __exit exit_ramfs_fs(void)
355 {
356         unregister_filesystem(&ramfs_fs_type);
357 }
358
359 module_init(init_ramfs_fs)
360 module_exit(exit_ramfs_fs)
361
362 int __init init_rootfs(void)
363 {
364         return register_filesystem(&rootfs_fs_type);
365 }
366
367 MODULE_LICENSE("GPL");
368