blob: 3a3a9b53bf5a974d3c206f31ae402aaf752dd39c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/libfs.c
3 * Library for filesystems writers.
4 */
5
Paul Gortmaker630d9c42011-11-16 23:57:37 -05006#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/pagemap.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09008#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/mount.h>
10#include <linux/vfs.h>
npiggin@suse.de7bb46a62010-05-27 01:05:33 +100011#include <linux/quotaops.h>
Ingo Molnar7cf34c72006-03-23 03:00:36 -080012#include <linux/mutex.h>
Christoph Hellwig25961102007-10-21 16:42:05 -070013#include <linux/exportfs.h>
Al Virod5aacad2009-06-07 14:56:44 -040014#include <linux/writeback.h>
Al Viroff01bb42011-09-16 02:31:11 -040015#include <linux/buffer_head.h> /* sync_mapping_buffers */
Ingo Molnar7cf34c72006-03-23 03:00:36 -080016
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <asm/uaccess.h>
18
Al Viroa4464db2011-07-07 15:03:58 -040019#include "internal.h"
20
Nick Pigginda502952011-01-07 17:49:33 +110021static inline int simple_positive(struct dentry *dentry)
22{
23 return dentry->d_inode && !d_unhashed(dentry);
24}
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
27 struct kstat *stat)
28{
29 struct inode *inode = dentry->d_inode;
30 generic_fillattr(inode, stat);
31 stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9);
32 return 0;
33}
34
David Howells726c3342006-06-23 02:02:58 -070035int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070036{
David Howells726c3342006-06-23 02:02:58 -070037 buf->f_type = dentry->d_sb->s_magic;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 buf->f_bsize = PAGE_CACHE_SIZE;
39 buf->f_namelen = NAME_MAX;
40 return 0;
41}
42
43/*
44 * Retaining negative dentries for an in-memory filesystem just wastes
45 * memory and lookup time: arrange for them to be deleted immediately.
46 */
Nick Pigginfe15ce42011-01-07 17:49:23 +110047static int simple_delete_dentry(const struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
49 return 1;
50}
51
52/*
53 * Lookup the data. This is trivial - if the dentry didn't already
54 * exist, we know it is negative. Set d_op to delete negative dentries.
55 */
Al Viro00cd8dd2012-06-10 17:13:09 -040056struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070057{
Al Viro3ba13d12009-02-20 06:02:22 +000058 static const struct dentry_operations simple_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 .d_delete = simple_delete_dentry,
60 };
61
62 if (dentry->d_name.len > NAME_MAX)
63 return ERR_PTR(-ENAMETOOLONG);
Al Viro74931da2013-07-14 17:43:25 +040064 if (!dentry->d_sb->s_d_op)
65 d_set_d_op(dentry, &simple_dentry_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 d_add(dentry, NULL);
67 return NULL;
68}
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070int dcache_dir_open(struct inode *inode, struct file *file)
71{
Linus Torvalds26fe5752012-05-10 13:14:12 -070072 static struct qstr cursor_name = QSTR_INIT(".", 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Josef "Jeff" Sipek0f7fc9e42006-12-08 02:36:35 -080074 file->private_data = d_alloc(file->f_path.dentry, &cursor_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76 return file->private_data ? 0 : -ENOMEM;
77}
78
79int dcache_dir_close(struct inode *inode, struct file *file)
80{
81 dput(file->private_data);
82 return 0;
83}
84
Andrew Morton965c8e52012-12-17 15:59:39 -080085loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086{
Nick Piggin2fd6b7f2011-01-07 17:49:34 +110087 struct dentry *dentry = file->f_path.dentry;
88 mutex_lock(&dentry->d_inode->i_mutex);
Andrew Morton965c8e52012-12-17 15:59:39 -080089 switch (whence) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 case 1:
91 offset += file->f_pos;
92 case 0:
93 if (offset >= 0)
94 break;
95 default:
Nick Piggin2fd6b7f2011-01-07 17:49:34 +110096 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 return -EINVAL;
98 }
99 if (offset != file->f_pos) {
100 file->f_pos = offset;
101 if (file->f_pos >= 2) {
102 struct list_head *p;
103 struct dentry *cursor = file->private_data;
104 loff_t n = file->f_pos - 2;
105
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100106 spin_lock(&dentry->d_lock);
107 /* d_lock not required for cursor */
Eric Dumazet5160ee6f2006-01-08 01:03:32 -0800108 list_del(&cursor->d_u.d_child);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100109 p = dentry->d_subdirs.next;
110 while (n && p != &dentry->d_subdirs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 struct dentry *next;
Eric Dumazet5160ee6f2006-01-08 01:03:32 -0800112 next = list_entry(p, struct dentry, d_u.d_child);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100113 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
Nick Pigginda502952011-01-07 17:49:33 +1100114 if (simple_positive(next))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 n--;
Nick Pigginda502952011-01-07 17:49:33 +1100116 spin_unlock(&next->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 p = p->next;
118 }
Eric Dumazet5160ee6f2006-01-08 01:03:32 -0800119 list_add_tail(&cursor->d_u.d_child, p);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100120 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 }
122 }
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100123 mutex_unlock(&dentry->d_inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 return offset;
125}
126
127/* Relationship between i_mode and the DT_xxx types */
128static inline unsigned char dt_type(struct inode *inode)
129{
130 return (inode->i_mode >> 12) & 15;
131}
132
133/*
134 * Directory is locked and all positive dentries in it are safe, since
135 * for ramfs-type trees they can't go away without unlink() or rmdir(),
136 * both impossible due to the lock on directory.
137 */
138
Al Viro5f99f4e2013-05-15 20:23:06 -0400139int dcache_readdir(struct file *file, struct dir_context *ctx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140{
Al Viro5f99f4e2013-05-15 20:23:06 -0400141 struct dentry *dentry = file->f_path.dentry;
142 struct dentry *cursor = file->private_data;
Eric Dumazet5160ee6f2006-01-08 01:03:32 -0800143 struct list_head *p, *q = &cursor->d_u.d_child;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Al Viro5f99f4e2013-05-15 20:23:06 -0400145 if (!dir_emit_dots(file, ctx))
146 return 0;
147 spin_lock(&dentry->d_lock);
148 if (ctx->pos == 2)
149 list_move(q, &dentry->d_subdirs);
Akinobu Mita1bfba4e2006-06-26 00:24:40 -0700150
Al Viro5f99f4e2013-05-15 20:23:06 -0400151 for (p = q->next; p != &dentry->d_subdirs; p = p->next) {
152 struct dentry *next = list_entry(p, struct dentry, d_u.d_child);
153 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
154 if (!simple_positive(next)) {
155 spin_unlock(&next->d_lock);
156 continue;
157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Al Viro5f99f4e2013-05-15 20:23:06 -0400159 spin_unlock(&next->d_lock);
160 spin_unlock(&dentry->d_lock);
161 if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
162 next->d_inode->i_ino, dt_type(next->d_inode)))
163 return 0;
164 spin_lock(&dentry->d_lock);
165 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
166 /* next is still alive */
167 list_move(q, p);
168 spin_unlock(&next->d_lock);
169 p = q;
170 ctx->pos++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 }
Al Viro5f99f4e2013-05-15 20:23:06 -0400172 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return 0;
174}
175
176ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
177{
178 return -EISDIR;
179}
180
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -0800181const struct file_operations simple_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 .open = dcache_dir_open,
183 .release = dcache_dir_close,
184 .llseek = dcache_dir_lseek,
185 .read = generic_read_dir,
Al Viro5f99f4e2013-05-15 20:23:06 -0400186 .iterate = dcache_readdir,
Christoph Hellwig1b061d92010-05-26 17:53:41 +0200187 .fsync = noop_fsync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188};
189
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -0800190const struct inode_operations simple_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 .lookup = simple_lookup,
192};
193
Hugh Dickins759b9772007-03-05 00:30:28 -0800194static const struct super_operations simple_super_operations = {
195 .statfs = simple_statfs,
196};
197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198/*
199 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
200 * will never be mountable)
201 */
Al Viro51139ad2010-07-25 23:47:46 +0400202struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name,
Al Viroc74a1cb2011-01-12 16:59:34 -0500203 const struct super_operations *ops,
204 const struct dentry_operations *dops, unsigned long magic)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
David Howells9249e172012-06-25 12:55:37 +0100206 struct super_block *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 struct dentry *dentry;
208 struct inode *root;
Linus Torvalds26fe5752012-05-10 13:14:12 -0700209 struct qstr d_name = QSTR_INIT(name, strlen(name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
David Howells9249e172012-06-25 12:55:37 +0100211 s = sget(fs_type, NULL, set_anon_super, MS_NOUSER, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 if (IS_ERR(s))
Al Viro51139ad2010-07-25 23:47:46 +0400213 return ERR_CAST(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Jeff Layton89a4eb42009-08-18 14:11:08 -0700215 s->s_maxbytes = MAX_LFS_FILESIZE;
Alex Nixon3971e1a2008-07-29 22:33:03 -0700216 s->s_blocksize = PAGE_SIZE;
217 s->s_blocksize_bits = PAGE_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 s->s_magic = magic;
Hugh Dickins759b9772007-03-05 00:30:28 -0800219 s->s_op = ops ? ops : &simple_super_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 s->s_time_gran = 1;
221 root = new_inode(s);
222 if (!root)
223 goto Enomem;
Jeff Layton1a1c9bb2007-05-08 00:32:31 -0700224 /*
225 * since this is the first inode, make it number 1. New inodes created
226 * after this must take care not to collide with it (by passing
227 * max_reserved of 1 to iunique).
228 */
229 root->i_ino = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
Al Viroa4464db2011-07-07 15:03:58 -0400232 dentry = __d_alloc(s, &d_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 if (!dentry) {
234 iput(root);
235 goto Enomem;
236 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 d_instantiate(dentry, root);
238 s->s_root = dentry;
Al Viroc74a1cb2011-01-12 16:59:34 -0500239 s->s_d_op = dops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 s->s_flags |= MS_ACTIVE;
Al Viro51139ad2010-07-25 23:47:46 +0400241 return dget(s->s_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243Enomem:
Al Viro6f5bbff2009-05-06 01:34:22 -0400244 deactivate_locked_super(s);
Al Viro51139ad2010-07-25 23:47:46 +0400245 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246}
247
Stephen Boyd20955e82012-04-05 14:25:09 -0700248int simple_open(struct inode *inode, struct file *file)
249{
250 if (inode->i_private)
251 file->private_data = inode->i_private;
252 return 0;
253}
254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
256{
257 struct inode *inode = old_dentry->d_inode;
258
259 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
Dave Hansend8c76e62006-09-30 23:29:04 -0700260 inc_nlink(inode);
Al Viro7de9c6ee2010-10-23 11:11:40 -0400261 ihold(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 dget(dentry);
263 d_instantiate(dentry, inode);
264 return 0;
265}
266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267int simple_empty(struct dentry *dentry)
268{
269 struct dentry *child;
270 int ret = 0;
271
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100272 spin_lock(&dentry->d_lock);
Nick Pigginda502952011-01-07 17:49:33 +1100273 list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) {
274 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
275 if (simple_positive(child)) {
276 spin_unlock(&child->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 goto out;
Nick Pigginda502952011-01-07 17:49:33 +1100278 }
279 spin_unlock(&child->d_lock);
280 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 ret = 1;
282out:
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100283 spin_unlock(&dentry->d_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return ret;
285}
286
287int simple_unlink(struct inode *dir, struct dentry *dentry)
288{
289 struct inode *inode = dentry->d_inode;
290
291 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700292 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 dput(dentry);
294 return 0;
295}
296
297int simple_rmdir(struct inode *dir, struct dentry *dentry)
298{
299 if (!simple_empty(dentry))
300 return -ENOTEMPTY;
301
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700302 drop_nlink(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 simple_unlink(dir, dentry);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700304 drop_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 return 0;
306}
307
308int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
309 struct inode *new_dir, struct dentry *new_dentry)
310{
311 struct inode *inode = old_dentry->d_inode;
312 int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode);
313
314 if (!simple_empty(new_dentry))
315 return -ENOTEMPTY;
316
317 if (new_dentry->d_inode) {
318 simple_unlink(new_dir, new_dentry);
Al Viro841590c2011-07-21 15:49:09 -0400319 if (they_are_dirs) {
320 drop_nlink(new_dentry->d_inode);
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700321 drop_nlink(old_dir);
Al Viro841590c2011-07-21 15:49:09 -0400322 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 } else if (they_are_dirs) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700324 drop_nlink(old_dir);
Dave Hansend8c76e62006-09-30 23:29:04 -0700325 inc_nlink(new_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 }
327
328 old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
329 new_dir->i_mtime = inode->i_ctime = CURRENT_TIME;
330
331 return 0;
332}
333
npiggin@suse.de7bb46a62010-05-27 01:05:33 +1000334/**
Christoph Hellwigeef23802010-06-04 11:30:01 +0200335 * simple_setattr - setattr for simple filesystem
npiggin@suse.de7bb46a62010-05-27 01:05:33 +1000336 * @dentry: dentry
337 * @iattr: iattr structure
338 *
339 * Returns 0 on success, -error on failure.
340 *
Christoph Hellwigeef23802010-06-04 11:30:01 +0200341 * simple_setattr is a simple ->setattr implementation without a proper
342 * implementation of size changes.
343 *
344 * It can either be used for in-memory filesystems or special files
345 * on simple regular filesystems. Anything that needs to change on-disk
346 * or wire state on size changes needs its own setattr method.
npiggin@suse.de7bb46a62010-05-27 01:05:33 +1000347 */
348int simple_setattr(struct dentry *dentry, struct iattr *iattr)
349{
350 struct inode *inode = dentry->d_inode;
351 int error;
352
353 error = inode_change_ok(inode, iattr);
354 if (error)
355 return error;
356
Christoph Hellwig2c27c652010-06-04 11:30:04 +0200357 if (iattr->ia_valid & ATTR_SIZE)
358 truncate_setsize(inode, iattr->ia_size);
Christoph Hellwig6a1a90a2010-06-04 11:30:00 +0200359 setattr_copy(inode, iattr);
Christoph Hellwigeef23802010-06-04 11:30:01 +0200360 mark_inode_dirty(inode);
361 return 0;
npiggin@suse.de7bb46a62010-05-27 01:05:33 +1000362}
363EXPORT_SYMBOL(simple_setattr);
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365int simple_readpage(struct file *file, struct page *page)
366{
Pekka J Enbergc0d92cb2006-09-29 01:59:09 -0700367 clear_highpage(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 flush_dcache_page(page);
369 SetPageUptodate(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 unlock_page(page);
371 return 0;
372}
373
Nick Pigginafddba42007-10-16 01:25:01 -0700374int simple_write_begin(struct file *file, struct address_space *mapping,
375 loff_t pos, unsigned len, unsigned flags,
376 struct page **pagep, void **fsdata)
377{
378 struct page *page;
379 pgoff_t index;
Nick Pigginafddba42007-10-16 01:25:01 -0700380
381 index = pos >> PAGE_CACHE_SHIFT;
Nick Pigginafddba42007-10-16 01:25:01 -0700382
Nick Piggin54566b22009-01-04 12:00:53 -0800383 page = grab_cache_page_write_begin(mapping, index, flags);
Nick Pigginafddba42007-10-16 01:25:01 -0700384 if (!page)
385 return -ENOMEM;
386
387 *pagep = page;
388
Boaz Harrosh193cf4b2010-01-12 16:18:08 +0200389 if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) {
390 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
391
392 zero_user_segments(page, 0, from, from + len, PAGE_CACHE_SIZE);
393 }
394 return 0;
Nick Pigginafddba42007-10-16 01:25:01 -0700395}
396
Boaz Harroshad2a722f2010-01-12 15:13:47 +0200397/**
398 * simple_write_end - .write_end helper for non-block-device FSes
399 * @available: See .write_end of address_space_operations
400 * @file: "
401 * @mapping: "
402 * @pos: "
403 * @len: "
404 * @copied: "
405 * @page: "
406 * @fsdata: "
407 *
408 * simple_write_end does the minimum needed for updating a page after writing is
409 * done. It has the same API signature as the .write_end of
410 * address_space_operations vector. So it can just be set onto .write_end for
411 * FSes that don't need any other processing. i_mutex is assumed to be held.
412 * Block based filesystems should use generic_write_end().
413 * NOTE: Even though i_size might get updated by this function, mark_inode_dirty
414 * is not called, so a filesystem that actually does store data in .write_inode
415 * should extend on what's done here with a call to mark_inode_dirty() in the
416 * case that i_size has changed.
417 */
418int simple_write_end(struct file *file, struct address_space *mapping,
419 loff_t pos, unsigned len, unsigned copied,
420 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421{
422 struct inode *inode = page->mapping->host;
Boaz Harroshad2a722f2010-01-12 15:13:47 +0200423 loff_t last_pos = pos + copied;
424
425 /* zero the stale part of the page if we did a short copy */
426 if (copied < len) {
427 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
428
429 zero_user(page, from + copied, len - copied);
430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Nick Piggin955eff52007-02-20 13:58:08 -0800432 if (!PageUptodate(page))
433 SetPageUptodate(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 /*
435 * No need to use i_size_read() here, the i_size
Jes Sorensen1b1dcc12006-01-09 15:59:24 -0800436 * cannot change under us because we hold the i_mutex.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 */
Boaz Harroshad2a722f2010-01-12 15:13:47 +0200438 if (last_pos > inode->i_size)
439 i_size_write(inode, last_pos);
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 set_page_dirty(page);
Nick Pigginafddba42007-10-16 01:25:01 -0700442 unlock_page(page);
443 page_cache_release(page);
444
445 return copied;
446}
447
Jeff Layton1a1c9bb2007-05-08 00:32:31 -0700448/*
449 * the inodes created here are not hashed. If you use iunique to generate
450 * unique inode values later for this filesystem, then you must take care
451 * to pass it an appropriate max_reserved value to avoid collisions.
452 */
Roberto Sassu7d683a02010-06-03 11:58:28 +0200453int simple_fill_super(struct super_block *s, unsigned long magic,
454 struct tree_descr *files)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 struct inode *inode;
457 struct dentry *root;
458 struct dentry *dentry;
459 int i;
460
461 s->s_blocksize = PAGE_CACHE_SIZE;
462 s->s_blocksize_bits = PAGE_CACHE_SHIFT;
463 s->s_magic = magic;
Hugh Dickins759b9772007-03-05 00:30:28 -0800464 s->s_op = &simple_super_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 s->s_time_gran = 1;
466
467 inode = new_inode(s);
468 if (!inode)
469 return -ENOMEM;
Jeff Layton1a1c9bb2007-05-08 00:32:31 -0700470 /*
471 * because the root inode is 1, the files array must not contain an
472 * entry at index 1
473 */
474 inode->i_ino = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 inode->i_mode = S_IFDIR | 0755;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
477 inode->i_op = &simple_dir_inode_operations;
478 inode->i_fop = &simple_dir_operations;
Miklos Szeredibfe86842011-10-28 14:13:29 +0200479 set_nlink(inode, 2);
Al Viro48fde702012-01-08 22:15:13 -0500480 root = d_make_root(inode);
481 if (!root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 for (i = 0; !files->name || files->name[0]; i++, files++) {
484 if (!files->name)
485 continue;
Jeff Layton1a1c9bb2007-05-08 00:32:31 -0700486
487 /* warn if it tries to conflict with the root inode */
488 if (unlikely(i == 1))
489 printk(KERN_WARNING "%s: %s passed in a files array"
490 "with an index of 1!\n", __func__,
491 s->s_type->name);
492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 dentry = d_alloc_name(root, files->name);
494 if (!dentry)
495 goto out;
496 inode = new_inode(s);
Konstantin Khlebnikov32096ea2011-11-01 16:12:33 +0300497 if (!inode) {
498 dput(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 goto out;
Konstantin Khlebnikov32096ea2011-11-01 16:12:33 +0300500 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 inode->i_mode = S_IFREG | files->mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
503 inode->i_fop = files->ops;
504 inode->i_ino = i;
505 d_add(dentry, inode);
506 }
507 s->s_root = root;
508 return 0;
509out:
510 d_genocide(root);
Al Viro640946f22012-04-02 19:22:25 -0400511 shrink_dcache_parent(root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 dput(root);
513 return -ENOMEM;
514}
515
516static DEFINE_SPINLOCK(pin_fs_lock);
517
Trond Myklebust1f5ce9e2006-06-09 09:34:16 -0400518int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
520 struct vfsmount *mnt = NULL;
521 spin_lock(&pin_fs_lock);
522 if (unlikely(!*mount)) {
523 spin_unlock(&pin_fs_lock);
Al Viro24529922012-03-17 02:13:52 -0400524 mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (IS_ERR(mnt))
526 return PTR_ERR(mnt);
527 spin_lock(&pin_fs_lock);
528 if (!*mount)
529 *mount = mnt;
530 }
531 mntget(*mount);
532 ++*count;
533 spin_unlock(&pin_fs_lock);
534 mntput(mnt);
535 return 0;
536}
537
538void simple_release_fs(struct vfsmount **mount, int *count)
539{
540 struct vfsmount *mnt;
541 spin_lock(&pin_fs_lock);
542 mnt = *mount;
543 if (!--*count)
544 *mount = NULL;
545 spin_unlock(&pin_fs_lock);
546 mntput(mnt);
547}
548
Akinobu Mita6d1029b2008-07-04 09:59:51 -0700549/**
550 * simple_read_from_buffer - copy data from the buffer to user space
551 * @to: the user space buffer to read to
552 * @count: the maximum number of bytes to read
553 * @ppos: the current position in the buffer
554 * @from: the buffer to read from
555 * @available: the size of the buffer
556 *
557 * The simple_read_from_buffer() function reads up to @count bytes from the
558 * buffer @from at offset @ppos into the user space address starting at @to.
559 *
560 * On success, the number of bytes read is returned and the offset @ppos is
561 * advanced by this number, or negative value is returned on error.
562 **/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
564 const void *from, size_t available)
565{
566 loff_t pos = *ppos;
Steven Rostedt14be2742009-09-18 13:05:42 -0700567 size_t ret;
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 if (pos < 0)
570 return -EINVAL;
Steven Rostedt14be2742009-09-18 13:05:42 -0700571 if (pos >= available || !count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 return 0;
573 if (count > available - pos)
574 count = available - pos;
Steven Rostedt14be2742009-09-18 13:05:42 -0700575 ret = copy_to_user(to, from + pos, count);
576 if (ret == count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 return -EFAULT;
Steven Rostedt14be2742009-09-18 13:05:42 -0700578 count -= ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 *ppos = pos + count;
580 return count;
581}
582
Akinobu Mita6d1029b2008-07-04 09:59:51 -0700583/**
Jiri Slaby6a727b42010-05-01 23:51:22 +0200584 * simple_write_to_buffer - copy data from user space to the buffer
585 * @to: the buffer to write to
586 * @available: the size of the buffer
587 * @ppos: the current position in the buffer
588 * @from: the user space buffer to read from
589 * @count: the maximum number of bytes to read
590 *
591 * The simple_write_to_buffer() function reads up to @count bytes from the user
592 * space address starting at @from into the buffer @to at offset @ppos.
593 *
594 * On success, the number of bytes written is returned and the offset @ppos is
595 * advanced by this number, or negative value is returned on error.
596 **/
597ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
598 const void __user *from, size_t count)
599{
600 loff_t pos = *ppos;
601 size_t res;
602
603 if (pos < 0)
604 return -EINVAL;
605 if (pos >= available || !count)
606 return 0;
607 if (count > available - pos)
608 count = available - pos;
609 res = copy_from_user(to + pos, from, count);
610 if (res == count)
611 return -EFAULT;
612 count -= res;
613 *ppos = pos + count;
614 return count;
615}
616
617/**
Akinobu Mita6d1029b2008-07-04 09:59:51 -0700618 * memory_read_from_buffer - copy data from the buffer
619 * @to: the kernel space buffer to read to
620 * @count: the maximum number of bytes to read
621 * @ppos: the current position in the buffer
622 * @from: the buffer to read from
623 * @available: the size of the buffer
624 *
625 * The memory_read_from_buffer() function reads up to @count bytes from the
626 * buffer @from at offset @ppos into the kernel space address starting at @to.
627 *
628 * On success, the number of bytes read is returned and the offset @ppos is
629 * advanced by this number, or negative value is returned on error.
630 **/
Akinobu Mita93b07112008-06-05 22:46:21 -0700631ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
632 const void *from, size_t available)
633{
634 loff_t pos = *ppos;
635
636 if (pos < 0)
637 return -EINVAL;
638 if (pos >= available)
639 return 0;
640 if (count > available - pos)
641 count = available - pos;
642 memcpy(to, from + pos, count);
643 *ppos = pos + count;
644
645 return count;
646}
647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648/*
649 * Transaction based IO.
650 * The file expects a single write which triggers the transaction, and then
651 * possibly a read which collects the result - which is stored in a
652 * file-local buffer.
653 */
Ingo Molnar76791ab2009-03-25 16:48:35 +0100654
655void simple_transaction_set(struct file *file, size_t n)
656{
657 struct simple_transaction_argresp *ar = file->private_data;
658
659 BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
660
661 /*
662 * The barrier ensures that ar->size will really remain zero until
663 * ar->data is ready for reading.
664 */
665 smp_mb();
666 ar->size = n;
667}
668
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
670{
671 struct simple_transaction_argresp *ar;
672 static DEFINE_SPINLOCK(simple_transaction_lock);
673
674 if (size > SIMPLE_TRANSACTION_LIMIT - 1)
675 return ERR_PTR(-EFBIG);
676
677 ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
678 if (!ar)
679 return ERR_PTR(-ENOMEM);
680
681 spin_lock(&simple_transaction_lock);
682
683 /* only one write allowed per open */
684 if (file->private_data) {
685 spin_unlock(&simple_transaction_lock);
686 free_page((unsigned long)ar);
687 return ERR_PTR(-EBUSY);
688 }
689
690 file->private_data = ar;
691
692 spin_unlock(&simple_transaction_lock);
693
694 if (copy_from_user(ar->data, buf, size))
695 return ERR_PTR(-EFAULT);
696
697 return ar->data;
698}
699
700ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
701{
702 struct simple_transaction_argresp *ar = file->private_data;
703
704 if (!ar)
705 return 0;
706 return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
707}
708
709int simple_transaction_release(struct inode *inode, struct file *file)
710{
711 free_page((unsigned long)file->private_data);
712 return 0;
713}
714
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200715/* Simple attribute files */
716
717struct simple_attr {
Christoph Hellwig8b88b092008-02-08 04:20:26 -0800718 int (*get)(void *, u64 *);
719 int (*set)(void *, u64);
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200720 char get_buf[24]; /* enough to store a u64 and "\n\0" */
721 char set_buf[24];
722 void *data;
723 const char *fmt; /* format for read operation */
Ingo Molnar7cf34c72006-03-23 03:00:36 -0800724 struct mutex mutex; /* protects access to these buffers */
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200725};
726
727/* simple_attr_open is called by an actual attribute open file operation
728 * to set the attribute specific access operations. */
729int simple_attr_open(struct inode *inode, struct file *file,
Christoph Hellwig8b88b092008-02-08 04:20:26 -0800730 int (*get)(void *, u64 *), int (*set)(void *, u64),
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200731 const char *fmt)
732{
733 struct simple_attr *attr;
734
735 attr = kmalloc(sizeof(*attr), GFP_KERNEL);
736 if (!attr)
737 return -ENOMEM;
738
739 attr->get = get;
740 attr->set = set;
Theodore Ts'o8e18e292006-09-27 01:50:46 -0700741 attr->data = inode->i_private;
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200742 attr->fmt = fmt;
Ingo Molnar7cf34c72006-03-23 03:00:36 -0800743 mutex_init(&attr->mutex);
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200744
745 file->private_data = attr;
746
747 return nonseekable_open(inode, file);
748}
749
Christoph Hellwig74bedc42008-02-08 04:20:28 -0800750int simple_attr_release(struct inode *inode, struct file *file)
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200751{
752 kfree(file->private_data);
753 return 0;
754}
755
756/* read from the buffer that is filled with the get function */
757ssize_t simple_attr_read(struct file *file, char __user *buf,
758 size_t len, loff_t *ppos)
759{
760 struct simple_attr *attr;
761 size_t size;
762 ssize_t ret;
763
764 attr = file->private_data;
765
766 if (!attr->get)
767 return -EACCES;
768
Christoph Hellwig92613032008-02-08 04:20:27 -0800769 ret = mutex_lock_interruptible(&attr->mutex);
770 if (ret)
771 return ret;
772
Christoph Hellwig8b88b092008-02-08 04:20:26 -0800773 if (*ppos) { /* continued read */
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200774 size = strlen(attr->get_buf);
Christoph Hellwig8b88b092008-02-08 04:20:26 -0800775 } else { /* first read */
776 u64 val;
777 ret = attr->get(attr->data, &val);
778 if (ret)
779 goto out;
780
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200781 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
Christoph Hellwig8b88b092008-02-08 04:20:26 -0800782 attr->fmt, (unsigned long long)val);
783 }
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200784
785 ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
Christoph Hellwig8b88b092008-02-08 04:20:26 -0800786out:
Ingo Molnar7cf34c72006-03-23 03:00:36 -0800787 mutex_unlock(&attr->mutex);
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200788 return ret;
789}
790
791/* interpret the buffer as a number to call the set function with */
792ssize_t simple_attr_write(struct file *file, const char __user *buf,
793 size_t len, loff_t *ppos)
794{
795 struct simple_attr *attr;
796 u64 val;
797 size_t size;
798 ssize_t ret;
799
800 attr = file->private_data;
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200801 if (!attr->set)
802 return -EACCES;
803
Christoph Hellwig92613032008-02-08 04:20:27 -0800804 ret = mutex_lock_interruptible(&attr->mutex);
805 if (ret)
806 return ret;
807
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200808 ret = -EFAULT;
809 size = min(sizeof(attr->set_buf) - 1, len);
810 if (copy_from_user(attr->set_buf, buf, size))
811 goto out;
812
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200813 attr->set_buf[size] = '\0';
Akinobu Mitaf7b88632011-07-19 08:49:25 -0700814 val = simple_strtoll(attr->set_buf, NULL, 0);
Wu Fengguang05cc0ce2009-09-18 13:06:03 -0700815 ret = attr->set(attr->data, val);
816 if (ret == 0)
817 ret = len; /* on success, claim we got the whole input */
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200818out:
Ingo Molnar7cf34c72006-03-23 03:00:36 -0800819 mutex_unlock(&attr->mutex);
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200820 return ret;
821}
822
Christoph Hellwig25961102007-10-21 16:42:05 -0700823/**
824 * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
825 * @sb: filesystem to do the file handle conversion on
826 * @fid: file handle to convert
827 * @fh_len: length of the file handle in bytes
828 * @fh_type: type of file handle
829 * @get_inode: filesystem callback to retrieve inode
830 *
831 * This function decodes @fid as long as it has one of the well-known
832 * Linux filehandle types and calls @get_inode on it to retrieve the
833 * inode for the object specified in the file handle.
834 */
835struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid,
836 int fh_len, int fh_type, struct inode *(*get_inode)
837 (struct super_block *sb, u64 ino, u32 gen))
838{
839 struct inode *inode = NULL;
840
841 if (fh_len < 2)
842 return NULL;
843
844 switch (fh_type) {
845 case FILEID_INO32_GEN:
846 case FILEID_INO32_GEN_PARENT:
847 inode = get_inode(sb, fid->i32.ino, fid->i32.gen);
848 break;
849 }
850
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +0200851 return d_obtain_alias(inode);
Christoph Hellwig25961102007-10-21 16:42:05 -0700852}
853EXPORT_SYMBOL_GPL(generic_fh_to_dentry);
854
855/**
Yanchuan Nianca186832012-09-05 16:31:29 +0800856 * generic_fh_to_parent - generic helper for the fh_to_parent export operation
Christoph Hellwig25961102007-10-21 16:42:05 -0700857 * @sb: filesystem to do the file handle conversion on
858 * @fid: file handle to convert
859 * @fh_len: length of the file handle in bytes
860 * @fh_type: type of file handle
861 * @get_inode: filesystem callback to retrieve inode
862 *
863 * This function decodes @fid as long as it has one of the well-known
864 * Linux filehandle types and calls @get_inode on it to retrieve the
865 * inode for the _parent_ object specified in the file handle if it
866 * is specified in the file handle, or NULL otherwise.
867 */
868struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid,
869 int fh_len, int fh_type, struct inode *(*get_inode)
870 (struct super_block *sb, u64 ino, u32 gen))
871{
872 struct inode *inode = NULL;
873
874 if (fh_len <= 2)
875 return NULL;
876
877 switch (fh_type) {
878 case FILEID_INO32_GEN_PARENT:
879 inode = get_inode(sb, fid->i32.parent_ino,
880 (fh_len > 3 ? fid->i32.parent_gen : 0));
881 break;
882 }
883
Christoph Hellwig4ea3ada2008-08-11 15:48:57 +0200884 return d_obtain_alias(inode);
Christoph Hellwig25961102007-10-21 16:42:05 -0700885}
886EXPORT_SYMBOL_GPL(generic_fh_to_parent);
887
Christoph Hellwig1b061d92010-05-26 17:53:41 +0200888/**
889 * generic_file_fsync - generic fsync implementation for simple filesystems
890 * @file: file to synchronize
891 * @datasync: only synchronize essential metadata if true
892 *
893 * This is a generic implementation of the fsync method for simple
894 * filesystems which track all non-inode metadata in the buffers list
895 * hanging off the address_space structure.
896 */
Josef Bacik02c24a82011-07-16 20:44:56 -0400897int generic_file_fsync(struct file *file, loff_t start, loff_t end,
898 int datasync)
Al Virod5aacad2009-06-07 14:56:44 -0400899{
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200900 struct inode *inode = file->f_mapping->host;
Al Virod5aacad2009-06-07 14:56:44 -0400901 int err;
902 int ret;
903
Josef Bacik02c24a82011-07-16 20:44:56 -0400904 err = filemap_write_and_wait_range(inode->i_mapping, start, end);
905 if (err)
906 return err;
907
908 mutex_lock(&inode->i_mutex);
Al Virod5aacad2009-06-07 14:56:44 -0400909 ret = sync_mapping_buffers(inode->i_mapping);
910 if (!(inode->i_state & I_DIRTY))
Josef Bacik02c24a82011-07-16 20:44:56 -0400911 goto out;
Al Virod5aacad2009-06-07 14:56:44 -0400912 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
Josef Bacik02c24a82011-07-16 20:44:56 -0400913 goto out;
Al Virod5aacad2009-06-07 14:56:44 -0400914
Christoph Hellwigc37650162010-10-06 10:48:20 +0200915 err = sync_inode_metadata(inode, 1);
Al Virod5aacad2009-06-07 14:56:44 -0400916 if (ret == 0)
917 ret = err;
Josef Bacik02c24a82011-07-16 20:44:56 -0400918out:
919 mutex_unlock(&inode->i_mutex);
Al Virod5aacad2009-06-07 14:56:44 -0400920 return ret;
921}
Christoph Hellwig1b061d92010-05-26 17:53:41 +0200922EXPORT_SYMBOL(generic_file_fsync);
923
Patrick J. LoPresti30ca22c2010-07-22 15:03:41 -0700924/**
925 * generic_check_addressable - Check addressability of file system
926 * @blocksize_bits: log of file system block size
927 * @num_blocks: number of blocks in file system
928 *
929 * Determine whether a file system with @num_blocks blocks (and a
930 * block size of 2**@blocksize_bits) is addressable by the sector_t
931 * and page cache of the system. Return 0 if so and -EFBIG otherwise.
932 */
933int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks)
934{
935 u64 last_fs_block = num_blocks - 1;
Joel Beckera33f13e2010-08-16 12:10:17 -0700936 u64 last_fs_page =
937 last_fs_block >> (PAGE_CACHE_SHIFT - blocksize_bits);
Patrick J. LoPresti30ca22c2010-07-22 15:03:41 -0700938
939 if (unlikely(num_blocks == 0))
940 return 0;
941
942 if ((blocksize_bits < 9) || (blocksize_bits > PAGE_CACHE_SHIFT))
943 return -EINVAL;
944
Joel Beckera33f13e2010-08-16 12:10:17 -0700945 if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) ||
946 (last_fs_page > (pgoff_t)(~0ULL))) {
Patrick J. LoPresti30ca22c2010-07-22 15:03:41 -0700947 return -EFBIG;
948 }
949 return 0;
950}
951EXPORT_SYMBOL(generic_check_addressable);
952
Christoph Hellwig1b061d92010-05-26 17:53:41 +0200953/*
954 * No-op implementation of ->fsync for in-memory filesystems.
955 */
Josef Bacik02c24a82011-07-16 20:44:56 -0400956int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Christoph Hellwig1b061d92010-05-26 17:53:41 +0200957{
958 return 0;
959}
Al Virod5aacad2009-06-07 14:56:44 -0400960
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961EXPORT_SYMBOL(dcache_dir_close);
962EXPORT_SYMBOL(dcache_dir_lseek);
963EXPORT_SYMBOL(dcache_dir_open);
964EXPORT_SYMBOL(dcache_readdir);
965EXPORT_SYMBOL(generic_read_dir);
Al Viro51139ad2010-07-25 23:47:46 +0400966EXPORT_SYMBOL(mount_pseudo);
Nick Pigginafddba42007-10-16 01:25:01 -0700967EXPORT_SYMBOL(simple_write_begin);
968EXPORT_SYMBOL(simple_write_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969EXPORT_SYMBOL(simple_dir_inode_operations);
970EXPORT_SYMBOL(simple_dir_operations);
971EXPORT_SYMBOL(simple_empty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972EXPORT_SYMBOL(simple_fill_super);
973EXPORT_SYMBOL(simple_getattr);
Stephen Boyd20955e82012-04-05 14:25:09 -0700974EXPORT_SYMBOL(simple_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975EXPORT_SYMBOL(simple_link);
976EXPORT_SYMBOL(simple_lookup);
977EXPORT_SYMBOL(simple_pin_fs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978EXPORT_SYMBOL(simple_readpage);
979EXPORT_SYMBOL(simple_release_fs);
980EXPORT_SYMBOL(simple_rename);
981EXPORT_SYMBOL(simple_rmdir);
982EXPORT_SYMBOL(simple_statfs);
Christoph Hellwig1b061d92010-05-26 17:53:41 +0200983EXPORT_SYMBOL(noop_fsync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984EXPORT_SYMBOL(simple_unlink);
985EXPORT_SYMBOL(simple_read_from_buffer);
Jiri Slaby6a727b42010-05-01 23:51:22 +0200986EXPORT_SYMBOL(simple_write_to_buffer);
Akinobu Mita93b07112008-06-05 22:46:21 -0700987EXPORT_SYMBOL(memory_read_from_buffer);
Ingo Molnar76791ab2009-03-25 16:48:35 +0100988EXPORT_SYMBOL(simple_transaction_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989EXPORT_SYMBOL(simple_transaction_get);
990EXPORT_SYMBOL(simple_transaction_read);
991EXPORT_SYMBOL(simple_transaction_release);
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200992EXPORT_SYMBOL_GPL(simple_attr_open);
Christoph Hellwig74bedc42008-02-08 04:20:28 -0800993EXPORT_SYMBOL_GPL(simple_attr_release);
Arnd Bergmannacaefc22005-05-18 14:40:59 +0200994EXPORT_SYMBOL_GPL(simple_attr_read);
995EXPORT_SYMBOL_GPL(simple_attr_write);