Merge branch 'fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/davej/cpufreq
[linux-3.10.git] / fs / libfs.c
1 /*
2  *      fs/libfs.c
3  *      Library for filesystems writers.
4  */
5
6 #include <linux/module.h>
7 #include <linux/pagemap.h>
8 #include <linux/slab.h>
9 #include <linux/mount.h>
10 #include <linux/vfs.h>
11 #include <linux/quotaops.h>
12 #include <linux/mutex.h>
13 #include <linux/exportfs.h>
14 #include <linux/writeback.h>
15 #include <linux/buffer_head.h>
16
17 #include <asm/uaccess.h>
18
19 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
20                    struct kstat *stat)
21 {
22         struct inode *inode = dentry->d_inode;
23         generic_fillattr(inode, stat);
24         stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9);
25         return 0;
26 }
27
28 int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
29 {
30         buf->f_type = dentry->d_sb->s_magic;
31         buf->f_bsize = PAGE_CACHE_SIZE;
32         buf->f_namelen = NAME_MAX;
33         return 0;
34 }
35
36 /*
37  * Retaining negative dentries for an in-memory filesystem just wastes
38  * memory and lookup time: arrange for them to be deleted immediately.
39  */
40 static int simple_delete_dentry(struct dentry *dentry)
41 {
42         return 1;
43 }
44
45 /*
46  * Lookup the data. This is trivial - if the dentry didn't already
47  * exist, we know it is negative.  Set d_op to delete negative dentries.
48  */
49 struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
50 {
51         static const struct dentry_operations simple_dentry_operations = {
52                 .d_delete = simple_delete_dentry,
53         };
54
55         if (dentry->d_name.len > NAME_MAX)
56                 return ERR_PTR(-ENAMETOOLONG);
57         dentry->d_op = &simple_dentry_operations;
58         d_add(dentry, NULL);
59         return NULL;
60 }
61
62 int dcache_dir_open(struct inode *inode, struct file *file)
63 {
64         static struct qstr cursor_name = {.len = 1, .name = "."};
65
66         file->private_data = d_alloc(file->f_path.dentry, &cursor_name);
67
68         return file->private_data ? 0 : -ENOMEM;
69 }
70
71 int dcache_dir_close(struct inode *inode, struct file *file)
72 {
73         dput(file->private_data);
74         return 0;
75 }
76
77 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
78 {
79         mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
80         switch (origin) {
81                 case 1:
82                         offset += file->f_pos;
83                 case 0:
84                         if (offset >= 0)
85                                 break;
86                 default:
87                         mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
88                         return -EINVAL;
89         }
90         if (offset != file->f_pos) {
91                 file->f_pos = offset;
92                 if (file->f_pos >= 2) {
93                         struct list_head *p;
94                         struct dentry *cursor = file->private_data;
95                         loff_t n = file->f_pos - 2;
96
97                         spin_lock(&dcache_lock);
98                         list_del(&cursor->d_u.d_child);
99                         p = file->f_path.dentry->d_subdirs.next;
100                         while (n && p != &file->f_path.dentry->d_subdirs) {
101                                 struct dentry *next;
102                                 next = list_entry(p, struct dentry, d_u.d_child);
103                                 if (!d_unhashed(next) && next->d_inode)
104                                         n--;
105                                 p = p->next;
106                         }
107                         list_add_tail(&cursor->d_u.d_child, p);
108                         spin_unlock(&dcache_lock);
109                 }
110         }
111         mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
112         return offset;
113 }
114
115 /* Relationship between i_mode and the DT_xxx types */
116 static inline unsigned char dt_type(struct inode *inode)
117 {
118         return (inode->i_mode >> 12) & 15;
119 }
120
121 /*
122  * Directory is locked and all positive dentries in it are safe, since
123  * for ramfs-type trees they can't go away without unlink() or rmdir(),
124  * both impossible due to the lock on directory.
125  */
126
127 int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
128 {
129         struct dentry *dentry = filp->f_path.dentry;
130         struct dentry *cursor = filp->private_data;
131         struct list_head *p, *q = &cursor->d_u.d_child;
132         ino_t ino;
133         int i = filp->f_pos;
134
135         switch (i) {
136                 case 0:
137                         ino = dentry->d_inode->i_ino;
138                         if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
139                                 break;
140                         filp->f_pos++;
141                         i++;
142                         /* fallthrough */
143                 case 1:
144                         ino = parent_ino(dentry);
145                         if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
146                                 break;
147                         filp->f_pos++;
148                         i++;
149                         /* fallthrough */
150                 default:
151                         spin_lock(&dcache_lock);
152                         if (filp->f_pos == 2)
153                                 list_move(q, &dentry->d_subdirs);
154
155                         for (p=q->next; p != &dentry->d_subdirs; p=p->next) {
156                                 struct dentry *next;
157                                 next = list_entry(p, struct dentry, d_u.d_child);
158                                 if (d_unhashed(next) || !next->d_inode)
159                                         continue;
160
161                                 spin_unlock(&dcache_lock);
162                                 if (filldir(dirent, next->d_name.name, 
163                                             next->d_name.len, filp->f_pos, 
164                                             next->d_inode->i_ino, 
165                                             dt_type(next->d_inode)) < 0)
166                                         return 0;
167                                 spin_lock(&dcache_lock);
168                                 /* next is still alive */
169                                 list_move(q, p);
170                                 p = q;
171                                 filp->f_pos++;
172                         }
173                         spin_unlock(&dcache_lock);
174         }
175         return 0;
176 }
177
178 ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
179 {
180         return -EISDIR;
181 }
182
183 const struct file_operations simple_dir_operations = {
184         .open           = dcache_dir_open,
185         .release        = dcache_dir_close,
186         .llseek         = dcache_dir_lseek,
187         .read           = generic_read_dir,
188         .readdir        = dcache_readdir,
189         .fsync          = noop_fsync,
190 };
191
192 const struct inode_operations simple_dir_inode_operations = {
193         .lookup         = simple_lookup,
194 };
195
196 static const struct super_operations simple_super_operations = {
197         .statfs         = simple_statfs,
198 };
199
200 /*
201  * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
202  * will never be mountable)
203  */
204 int get_sb_pseudo(struct file_system_type *fs_type, char *name,
205         const struct super_operations *ops, unsigned long magic,
206         struct vfsmount *mnt)
207 {
208         struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
209         struct dentry *dentry;
210         struct inode *root;
211         struct qstr d_name = {.name = name, .len = strlen(name)};
212
213         if (IS_ERR(s))
214                 return PTR_ERR(s);
215
216         s->s_flags = MS_NOUSER;
217         s->s_maxbytes = MAX_LFS_FILESIZE;
218         s->s_blocksize = PAGE_SIZE;
219         s->s_blocksize_bits = PAGE_SHIFT;
220         s->s_magic = magic;
221         s->s_op = ops ? ops : &simple_super_operations;
222         s->s_time_gran = 1;
223         root = new_inode(s);
224         if (!root)
225                 goto Enomem;
226         /*
227          * since this is the first inode, make it number 1. New inodes created
228          * after this must take care not to collide with it (by passing
229          * max_reserved of 1 to iunique).
230          */
231         root->i_ino = 1;
232         root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
233         root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
234         dentry = d_alloc(NULL, &d_name);
235         if (!dentry) {
236                 iput(root);
237                 goto Enomem;
238         }
239         dentry->d_sb = s;
240         dentry->d_parent = dentry;
241         d_instantiate(dentry, root);
242         s->s_root = dentry;
243         s->s_flags |= MS_ACTIVE;
244         simple_set_mnt(mnt, s);
245         return 0;
246
247 Enomem:
248         deactivate_locked_super(s);
249         return -ENOMEM;
250 }
251
252 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
253 {
254         struct inode *inode = old_dentry->d_inode;
255
256         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
257         inc_nlink(inode);
258         atomic_inc(&inode->i_count);
259         dget(dentry);
260         d_instantiate(dentry, inode);
261         return 0;
262 }
263
264 static inline int simple_positive(struct dentry *dentry)
265 {
266         return dentry->d_inode && !d_unhashed(dentry);
267 }
268
269 int simple_empty(struct dentry *dentry)
270 {
271         struct dentry *child;
272         int ret = 0;
273
274         spin_lock(&dcache_lock);
275         list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child)
276                 if (simple_positive(child))
277                         goto out;
278         ret = 1;
279 out:
280         spin_unlock(&dcache_lock);
281         return ret;
282 }
283
284 int simple_unlink(struct inode *dir, struct dentry *dentry)
285 {
286         struct inode *inode = dentry->d_inode;
287
288         inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
289         drop_nlink(inode);
290         dput(dentry);
291         return 0;
292 }
293
294 int simple_rmdir(struct inode *dir, struct dentry *dentry)
295 {
296         if (!simple_empty(dentry))
297                 return -ENOTEMPTY;
298
299         drop_nlink(dentry->d_inode);
300         simple_unlink(dir, dentry);
301         drop_nlink(dir);
302         return 0;
303 }
304
305 int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
306                 struct inode *new_dir, struct dentry *new_dentry)
307 {
308         struct inode *inode = old_dentry->d_inode;
309         int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode);
310
311         if (!simple_empty(new_dentry))
312                 return -ENOTEMPTY;
313
314         if (new_dentry->d_inode) {
315                 simple_unlink(new_dir, new_dentry);
316                 if (they_are_dirs)
317                         drop_nlink(old_dir);
318         } else if (they_are_dirs) {
319                 drop_nlink(old_dir);
320                 inc_nlink(new_dir);
321         }
322
323         old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
324                 new_dir->i_mtime = inode->i_ctime = CURRENT_TIME;
325
326         return 0;
327 }
328
329 /**
330  * simple_setsize - handle core mm and vfs requirements for file size change
331  * @inode: inode
332  * @newsize: new file size
333  *
334  * Returns 0 on success, -error on failure.
335  *
336  * simple_setsize must be called with inode_mutex held.
337  *
338  * simple_setsize will check that the requested new size is OK (see
339  * inode_newsize_ok), and then will perform the necessary i_size update
340  * and pagecache truncation (if necessary). It will be typically be called
341  * from the filesystem's setattr function when ATTR_SIZE is passed in.
342  *
343  * The inode itself must have correct permissions and attributes to allow
344  * i_size to be changed, this function then just checks that the new size
345  * requested is valid.
346  *
347  * In the case of simple in-memory filesystems with inodes stored solely
348  * in the inode cache, and file data in the pagecache, nothing more needs
349  * to be done to satisfy a truncate request. Filesystems with on-disk
350  * blocks for example will need to free them in the case of truncate, in
351  * that case it may be easier not to use simple_setsize (but each of its
352  * components will likely be required at some point to update pagecache
353  * and inode etc).
354  */
355 int simple_setsize(struct inode *inode, loff_t newsize)
356 {
357         loff_t oldsize;
358         int error;
359
360         error = inode_newsize_ok(inode, newsize);
361         if (error)
362                 return error;
363
364         oldsize = inode->i_size;
365         i_size_write(inode, newsize);
366         truncate_pagecache(inode, oldsize, newsize);
367
368         return error;
369 }
370 EXPORT_SYMBOL(simple_setsize);
371
372 /**
373  * simple_setattr - setattr for simple in-memory filesystem
374  * @dentry: dentry
375  * @iattr: iattr structure
376  *
377  * Returns 0 on success, -error on failure.
378  *
379  * simple_setattr implements setattr for an in-memory filesystem which
380  * does not store its own file data or metadata (eg. uses the page cache
381  * and inode cache as its data store).
382  */
383 int simple_setattr(struct dentry *dentry, struct iattr *iattr)
384 {
385         struct inode *inode = dentry->d_inode;
386         int error;
387
388         error = inode_change_ok(inode, iattr);
389         if (error)
390                 return error;
391
392         if (iattr->ia_valid & ATTR_SIZE) {
393                 error = simple_setsize(inode, iattr->ia_size);
394                 if (error)
395                         return error;
396         }
397
398         generic_setattr(inode, iattr);
399
400         return error;
401 }
402 EXPORT_SYMBOL(simple_setattr);
403
404 int simple_readpage(struct file *file, struct page *page)
405 {
406         clear_highpage(page);
407         flush_dcache_page(page);
408         SetPageUptodate(page);
409         unlock_page(page);
410         return 0;
411 }
412
413 int simple_write_begin(struct file *file, struct address_space *mapping,
414                         loff_t pos, unsigned len, unsigned flags,
415                         struct page **pagep, void **fsdata)
416 {
417         struct page *page;
418         pgoff_t index;
419
420         index = pos >> PAGE_CACHE_SHIFT;
421
422         page = grab_cache_page_write_begin(mapping, index, flags);
423         if (!page)
424                 return -ENOMEM;
425
426         *pagep = page;
427
428         if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) {
429                 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
430
431                 zero_user_segments(page, 0, from, from + len, PAGE_CACHE_SIZE);
432         }
433         return 0;
434 }
435
436 /**
437  * simple_write_end - .write_end helper for non-block-device FSes
438  * @available: See .write_end of address_space_operations
439  * @file:               "
440  * @mapping:            "
441  * @pos:                "
442  * @len:                "
443  * @copied:             "
444  * @page:               "
445  * @fsdata:             "
446  *
447  * simple_write_end does the minimum needed for updating a page after writing is
448  * done. It has the same API signature as the .write_end of
449  * address_space_operations vector. So it can just be set onto .write_end for
450  * FSes that don't need any other processing. i_mutex is assumed to be held.
451  * Block based filesystems should use generic_write_end().
452  * NOTE: Even though i_size might get updated by this function, mark_inode_dirty
453  * is not called, so a filesystem that actually does store data in .write_inode
454  * should extend on what's done here with a call to mark_inode_dirty() in the
455  * case that i_size has changed.
456  */
457 int simple_write_end(struct file *file, struct address_space *mapping,
458                         loff_t pos, unsigned len, unsigned copied,
459                         struct page *page, void *fsdata)
460 {
461         struct inode *inode = page->mapping->host;
462         loff_t last_pos = pos + copied;
463
464         /* zero the stale part of the page if we did a short copy */
465         if (copied < len) {
466                 unsigned from = pos & (PAGE_CACHE_SIZE - 1);
467
468                 zero_user(page, from + copied, len - copied);
469         }
470
471         if (!PageUptodate(page))
472                 SetPageUptodate(page);
473         /*
474          * No need to use i_size_read() here, the i_size
475          * cannot change under us because we hold the i_mutex.
476          */
477         if (last_pos > inode->i_size)
478                 i_size_write(inode, last_pos);
479
480         set_page_dirty(page);
481         unlock_page(page);
482         page_cache_release(page);
483
484         return copied;
485 }
486
487 /*
488  * the inodes created here are not hashed. If you use iunique to generate
489  * unique inode values later for this filesystem, then you must take care
490  * to pass it an appropriate max_reserved value to avoid collisions.
491  */
492 int simple_fill_super(struct super_block *s, unsigned long magic,
493                       struct tree_descr *files)
494 {
495         struct inode *inode;
496         struct dentry *root;
497         struct dentry *dentry;
498         int i;
499
500         s->s_blocksize = PAGE_CACHE_SIZE;
501         s->s_blocksize_bits = PAGE_CACHE_SHIFT;
502         s->s_magic = magic;
503         s->s_op = &simple_super_operations;
504         s->s_time_gran = 1;
505
506         inode = new_inode(s);
507         if (!inode)
508                 return -ENOMEM;
509         /*
510          * because the root inode is 1, the files array must not contain an
511          * entry at index 1
512          */
513         inode->i_ino = 1;
514         inode->i_mode = S_IFDIR | 0755;
515         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
516         inode->i_op = &simple_dir_inode_operations;
517         inode->i_fop = &simple_dir_operations;
518         inode->i_nlink = 2;
519         root = d_alloc_root(inode);
520         if (!root) {
521                 iput(inode);
522                 return -ENOMEM;
523         }
524         for (i = 0; !files->name || files->name[0]; i++, files++) {
525                 if (!files->name)
526                         continue;
527
528                 /* warn if it tries to conflict with the root inode */
529                 if (unlikely(i == 1))
530                         printk(KERN_WARNING "%s: %s passed in a files array"
531                                 "with an index of 1!\n", __func__,
532                                 s->s_type->name);
533
534                 dentry = d_alloc_name(root, files->name);
535                 if (!dentry)
536                         goto out;
537                 inode = new_inode(s);
538                 if (!inode)
539                         goto out;
540                 inode->i_mode = S_IFREG | files->mode;
541                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
542                 inode->i_fop = files->ops;
543                 inode->i_ino = i;
544                 d_add(dentry, inode);
545         }
546         s->s_root = root;
547         return 0;
548 out:
549         d_genocide(root);
550         dput(root);
551         return -ENOMEM;
552 }
553
554 static DEFINE_SPINLOCK(pin_fs_lock);
555
556 int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
557 {
558         struct vfsmount *mnt = NULL;
559         spin_lock(&pin_fs_lock);
560         if (unlikely(!*mount)) {
561                 spin_unlock(&pin_fs_lock);
562                 mnt = vfs_kern_mount(type, 0, type->name, NULL);
563                 if (IS_ERR(mnt))
564                         return PTR_ERR(mnt);
565                 spin_lock(&pin_fs_lock);
566                 if (!*mount)
567                         *mount = mnt;
568         }
569         mntget(*mount);
570         ++*count;
571         spin_unlock(&pin_fs_lock);
572         mntput(mnt);
573         return 0;
574 }
575
576 void simple_release_fs(struct vfsmount **mount, int *count)
577 {
578         struct vfsmount *mnt;
579         spin_lock(&pin_fs_lock);
580         mnt = *mount;
581         if (!--*count)
582                 *mount = NULL;
583         spin_unlock(&pin_fs_lock);
584         mntput(mnt);
585 }
586
587 /**
588  * simple_read_from_buffer - copy data from the buffer to user space
589  * @to: the user space buffer to read to
590  * @count: the maximum number of bytes to read
591  * @ppos: the current position in the buffer
592  * @from: the buffer to read from
593  * @available: the size of the buffer
594  *
595  * The simple_read_from_buffer() function reads up to @count bytes from the
596  * buffer @from at offset @ppos into the user space address starting at @to.
597  *
598  * On success, the number of bytes read is returned and the offset @ppos is
599  * advanced by this number, or negative value is returned on error.
600  **/
601 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
602                                 const void *from, size_t available)
603 {
604         loff_t pos = *ppos;
605         size_t ret;
606
607         if (pos < 0)
608                 return -EINVAL;
609         if (pos >= available || !count)
610                 return 0;
611         if (count > available - pos)
612                 count = available - pos;
613         ret = copy_to_user(to, from + pos, count);
614         if (ret == count)
615                 return -EFAULT;
616         count -= ret;
617         *ppos = pos + count;
618         return count;
619 }
620
621 /**
622  * simple_write_to_buffer - copy data from user space to the buffer
623  * @to: the buffer to write to
624  * @available: the size of the buffer
625  * @ppos: the current position in the buffer
626  * @from: the user space buffer to read from
627  * @count: the maximum number of bytes to read
628  *
629  * The simple_write_to_buffer() function reads up to @count bytes from the user
630  * space address starting at @from into the buffer @to at offset @ppos.
631  *
632  * On success, the number of bytes written is returned and the offset @ppos is
633  * advanced by this number, or negative value is returned on error.
634  **/
635 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
636                 const void __user *from, size_t count)
637 {
638         loff_t pos = *ppos;
639         size_t res;
640
641         if (pos < 0)
642                 return -EINVAL;
643         if (pos >= available || !count)
644                 return 0;
645         if (count > available - pos)
646                 count = available - pos;
647         res = copy_from_user(to + pos, from, count);
648         if (res == count)
649                 return -EFAULT;
650         count -= res;
651         *ppos = pos + count;
652         return count;
653 }
654
655 /**
656  * memory_read_from_buffer - copy data from the buffer
657  * @to: the kernel space buffer to read to
658  * @count: the maximum number of bytes to read
659  * @ppos: the current position in the buffer
660  * @from: the buffer to read from
661  * @available: the size of the buffer
662  *
663  * The memory_read_from_buffer() function reads up to @count bytes from the
664  * buffer @from at offset @ppos into the kernel space address starting at @to.
665  *
666  * On success, the number of bytes read is returned and the offset @ppos is
667  * advanced by this number, or negative value is returned on error.
668  **/
669 ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
670                                 const void *from, size_t available)
671 {
672         loff_t pos = *ppos;
673
674         if (pos < 0)
675                 return -EINVAL;
676         if (pos >= available)
677                 return 0;
678         if (count > available - pos)
679                 count = available - pos;
680         memcpy(to, from + pos, count);
681         *ppos = pos + count;
682
683         return count;
684 }
685
686 /*
687  * Transaction based IO.
688  * The file expects a single write which triggers the transaction, and then
689  * possibly a read which collects the result - which is stored in a
690  * file-local buffer.
691  */
692
693 void simple_transaction_set(struct file *file, size_t n)
694 {
695         struct simple_transaction_argresp *ar = file->private_data;
696
697         BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
698
699         /*
700          * The barrier ensures that ar->size will really remain zero until
701          * ar->data is ready for reading.
702          */
703         smp_mb();
704         ar->size = n;
705 }
706
707 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
708 {
709         struct simple_transaction_argresp *ar;
710         static DEFINE_SPINLOCK(simple_transaction_lock);
711
712         if (size > SIMPLE_TRANSACTION_LIMIT - 1)
713                 return ERR_PTR(-EFBIG);
714
715         ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
716         if (!ar)
717                 return ERR_PTR(-ENOMEM);
718
719         spin_lock(&simple_transaction_lock);
720
721         /* only one write allowed per open */
722         if (file->private_data) {
723                 spin_unlock(&simple_transaction_lock);
724                 free_page((unsigned long)ar);
725                 return ERR_PTR(-EBUSY);
726         }
727
728         file->private_data = ar;
729
730         spin_unlock(&simple_transaction_lock);
731
732         if (copy_from_user(ar->data, buf, size))
733                 return ERR_PTR(-EFAULT);
734
735         return ar->data;
736 }
737
738 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
739 {
740         struct simple_transaction_argresp *ar = file->private_data;
741
742         if (!ar)
743                 return 0;
744         return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
745 }
746
747 int simple_transaction_release(struct inode *inode, struct file *file)
748 {
749         free_page((unsigned long)file->private_data);
750         return 0;
751 }
752
753 /* Simple attribute files */
754
755 struct simple_attr {
756         int (*get)(void *, u64 *);
757         int (*set)(void *, u64);
758         char get_buf[24];       /* enough to store a u64 and "\n\0" */
759         char set_buf[24];
760         void *data;
761         const char *fmt;        /* format for read operation */
762         struct mutex mutex;     /* protects access to these buffers */
763 };
764
765 /* simple_attr_open is called by an actual attribute open file operation
766  * to set the attribute specific access operations. */
767 int simple_attr_open(struct inode *inode, struct file *file,
768                      int (*get)(void *, u64 *), int (*set)(void *, u64),
769                      const char *fmt)
770 {
771         struct simple_attr *attr;
772
773         attr = kmalloc(sizeof(*attr), GFP_KERNEL);
774         if (!attr)
775                 return -ENOMEM;
776
777         attr->get = get;
778         attr->set = set;
779         attr->data = inode->i_private;
780         attr->fmt = fmt;
781         mutex_init(&attr->mutex);
782
783         file->private_data = attr;
784
785         return nonseekable_open(inode, file);
786 }
787
788 int simple_attr_release(struct inode *inode, struct file *file)
789 {
790         kfree(file->private_data);
791         return 0;
792 }
793
794 /* read from the buffer that is filled with the get function */
795 ssize_t simple_attr_read(struct file *file, char __user *buf,
796                          size_t len, loff_t *ppos)
797 {
798         struct simple_attr *attr;
799         size_t size;
800         ssize_t ret;
801
802         attr = file->private_data;
803
804         if (!attr->get)
805                 return -EACCES;
806
807         ret = mutex_lock_interruptible(&attr->mutex);
808         if (ret)
809                 return ret;
810
811         if (*ppos) {            /* continued read */
812                 size = strlen(attr->get_buf);
813         } else {                /* first read */
814                 u64 val;
815                 ret = attr->get(attr->data, &val);
816                 if (ret)
817                         goto out;
818
819                 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
820                                  attr->fmt, (unsigned long long)val);
821         }
822
823         ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
824 out:
825         mutex_unlock(&attr->mutex);
826         return ret;
827 }
828
829 /* interpret the buffer as a number to call the set function with */
830 ssize_t simple_attr_write(struct file *file, const char __user *buf,
831                           size_t len, loff_t *ppos)
832 {
833         struct simple_attr *attr;
834         u64 val;
835         size_t size;
836         ssize_t ret;
837
838         attr = file->private_data;
839         if (!attr->set)
840                 return -EACCES;
841
842         ret = mutex_lock_interruptible(&attr->mutex);
843         if (ret)
844                 return ret;
845
846         ret = -EFAULT;
847         size = min(sizeof(attr->set_buf) - 1, len);
848         if (copy_from_user(attr->set_buf, buf, size))
849                 goto out;
850
851         attr->set_buf[size] = '\0';
852         val = simple_strtol(attr->set_buf, NULL, 0);
853         ret = attr->set(attr->data, val);
854         if (ret == 0)
855                 ret = len; /* on success, claim we got the whole input */
856 out:
857         mutex_unlock(&attr->mutex);
858         return ret;
859 }
860
861 /**
862  * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
863  * @sb:         filesystem to do the file handle conversion on
864  * @fid:        file handle to convert
865  * @fh_len:     length of the file handle in bytes
866  * @fh_type:    type of file handle
867  * @get_inode:  filesystem callback to retrieve inode
868  *
869  * This function decodes @fid as long as it has one of the well-known
870  * Linux filehandle types and calls @get_inode on it to retrieve the
871  * inode for the object specified in the file handle.
872  */
873 struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid,
874                 int fh_len, int fh_type, struct inode *(*get_inode)
875                         (struct super_block *sb, u64 ino, u32 gen))
876 {
877         struct inode *inode = NULL;
878
879         if (fh_len < 2)
880                 return NULL;
881
882         switch (fh_type) {
883         case FILEID_INO32_GEN:
884         case FILEID_INO32_GEN_PARENT:
885                 inode = get_inode(sb, fid->i32.ino, fid->i32.gen);
886                 break;
887         }
888
889         return d_obtain_alias(inode);
890 }
891 EXPORT_SYMBOL_GPL(generic_fh_to_dentry);
892
893 /**
894  * generic_fh_to_dentry - generic helper for the fh_to_parent export operation
895  * @sb:         filesystem to do the file handle conversion on
896  * @fid:        file handle to convert
897  * @fh_len:     length of the file handle in bytes
898  * @fh_type:    type of file handle
899  * @get_inode:  filesystem callback to retrieve inode
900  *
901  * This function decodes @fid as long as it has one of the well-known
902  * Linux filehandle types and calls @get_inode on it to retrieve the
903  * inode for the _parent_ object specified in the file handle if it
904  * is specified in the file handle, or NULL otherwise.
905  */
906 struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid,
907                 int fh_len, int fh_type, struct inode *(*get_inode)
908                         (struct super_block *sb, u64 ino, u32 gen))
909 {
910         struct inode *inode = NULL;
911
912         if (fh_len <= 2)
913                 return NULL;
914
915         switch (fh_type) {
916         case FILEID_INO32_GEN_PARENT:
917                 inode = get_inode(sb, fid->i32.parent_ino,
918                                   (fh_len > 3 ? fid->i32.parent_gen : 0));
919                 break;
920         }
921
922         return d_obtain_alias(inode);
923 }
924 EXPORT_SYMBOL_GPL(generic_fh_to_parent);
925
926 /**
927  * generic_file_fsync - generic fsync implementation for simple filesystems
928  * @file:       file to synchronize
929  * @datasync:   only synchronize essential metadata if true
930  *
931  * This is a generic implementation of the fsync method for simple
932  * filesystems which track all non-inode metadata in the buffers list
933  * hanging off the address_space structure.
934  */
935 int generic_file_fsync(struct file *file, int datasync)
936 {
937         struct writeback_control wbc = {
938                 .sync_mode = WB_SYNC_ALL,
939                 .nr_to_write = 0, /* metadata-only; caller takes care of data */
940         };
941         struct inode *inode = file->f_mapping->host;
942         int err;
943         int ret;
944
945         ret = sync_mapping_buffers(inode->i_mapping);
946         if (!(inode->i_state & I_DIRTY))
947                 return ret;
948         if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
949                 return ret;
950
951         err = sync_inode(inode, &wbc);
952         if (ret == 0)
953                 ret = err;
954         return ret;
955 }
956 EXPORT_SYMBOL(generic_file_fsync);
957
958 /*
959  * No-op implementation of ->fsync for in-memory filesystems.
960  */
961 int noop_fsync(struct file *file, int datasync)
962 {
963         return 0;
964 }
965
966 EXPORT_SYMBOL(dcache_dir_close);
967 EXPORT_SYMBOL(dcache_dir_lseek);
968 EXPORT_SYMBOL(dcache_dir_open);
969 EXPORT_SYMBOL(dcache_readdir);
970 EXPORT_SYMBOL(generic_read_dir);
971 EXPORT_SYMBOL(get_sb_pseudo);
972 EXPORT_SYMBOL(simple_write_begin);
973 EXPORT_SYMBOL(simple_write_end);
974 EXPORT_SYMBOL(simple_dir_inode_operations);
975 EXPORT_SYMBOL(simple_dir_operations);
976 EXPORT_SYMBOL(simple_empty);
977 EXPORT_SYMBOL(simple_fill_super);
978 EXPORT_SYMBOL(simple_getattr);
979 EXPORT_SYMBOL(simple_link);
980 EXPORT_SYMBOL(simple_lookup);
981 EXPORT_SYMBOL(simple_pin_fs);
982 EXPORT_SYMBOL(simple_readpage);
983 EXPORT_SYMBOL(simple_release_fs);
984 EXPORT_SYMBOL(simple_rename);
985 EXPORT_SYMBOL(simple_rmdir);
986 EXPORT_SYMBOL(simple_statfs);
987 EXPORT_SYMBOL(noop_fsync);
988 EXPORT_SYMBOL(simple_unlink);
989 EXPORT_SYMBOL(simple_read_from_buffer);
990 EXPORT_SYMBOL(simple_write_to_buffer);
991 EXPORT_SYMBOL(memory_read_from_buffer);
992 EXPORT_SYMBOL(simple_transaction_set);
993 EXPORT_SYMBOL(simple_transaction_get);
994 EXPORT_SYMBOL(simple_transaction_read);
995 EXPORT_SYMBOL(simple_transaction_release);
996 EXPORT_SYMBOL_GPL(simple_attr_open);
997 EXPORT_SYMBOL_GPL(simple_attr_release);
998 EXPORT_SYMBOL_GPL(simple_attr_read);
999 EXPORT_SYMBOL_GPL(simple_attr_write);