Merge git://git.kernel.org/pub/scm/linux/kernel/git/mingo/linux-2.6-sched
[linux-2.6] / fs / ext4 / fsync.c
1 /*
2  *  linux/fs/ext4/fsync.c
3  *
4  *  Copyright (C) 1993  Stephen Tweedie (sct@redhat.com)
5  *  from
6  *  Copyright (C) 1992  Remy Card (card@masi.ibp.fr)
7  *                      Laboratoire MASI - Institut Blaise Pascal
8  *                      Universite Pierre et Marie Curie (Paris VI)
9  *  from
10  *  linux/fs/minix/truncate.c   Copyright (C) 1991, 1992  Linus Torvalds
11  *
12  *  ext4fs fsync primitive
13  *
14  *  Big-endian to little-endian byte-swapping/bitmaps by
15  *        David S. Miller (davem@caip.rutgers.edu), 1995
16  *
17  *  Removed unnecessary code duplication for little endian machines
18  *  and excessive __inline__s.
19  *        Andi Kleen, 1997
20  *
21  * Major simplications and cleanup - we only need to do the metadata, because
22  * we can depend on generic_block_fdatasync() to sync the data blocks.
23  */
24
25 #include <linux/time.h>
26 #include <linux/fs.h>
27 #include <linux/sched.h>
28 #include <linux/writeback.h>
29 #include <linux/jbd2.h>
30 #include <linux/ext4_fs.h>
31 #include <linux/ext4_jbd2.h>
32
33 /*
34  * akpm: A new design for ext4_sync_file().
35  *
36  * This is only called from sys_fsync(), sys_fdatasync() and sys_msync().
37  * There cannot be a transaction open by this task.
38  * Another task could have dirtied this inode.  Its data can be in any
39  * state in the journalling system.
40  *
41  * What we do is just kick off a commit and wait on it.  This will snapshot the
42  * inode to disk.
43  */
44
45 int ext4_sync_file(struct file * file, struct dentry *dentry, int datasync)
46 {
47         struct inode *inode = dentry->d_inode;
48         int ret = 0;
49
50         J_ASSERT(ext4_journal_current_handle() == NULL);
51
52         /*
53          * data=writeback:
54          *  The caller's filemap_fdatawrite()/wait will sync the data.
55          *  sync_inode() will sync the metadata
56          *
57          * data=ordered:
58          *  The caller's filemap_fdatawrite() will write the data and
59          *  sync_inode() will write the inode if it is dirty.  Then the caller's
60          *  filemap_fdatawait() will wait on the pages.
61          *
62          * data=journal:
63          *  filemap_fdatawrite won't do anything (the buffers are clean).
64          *  ext4_force_commit will write the file data into the journal and
65          *  will wait on that.
66          *  filemap_fdatawait() will encounter a ton of newly-dirtied pages
67          *  (they were dirtied by commit).  But that's OK - the blocks are
68          *  safe in-journal, which is all fsync() needs to ensure.
69          */
70         if (ext4_should_journal_data(inode)) {
71                 ret = ext4_force_commit(inode->i_sb);
72                 goto out;
73         }
74
75         /*
76          * The VFS has written the file data.  If the inode is unaltered
77          * then we need not start a commit.
78          */
79         if (inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC)) {
80                 struct writeback_control wbc = {
81                         .sync_mode = WB_SYNC_ALL,
82                         .nr_to_write = 0, /* sys_fsync did this */
83                 };
84                 ret = sync_inode(inode, &wbc);
85         }
86 out:
87         return ret;
88 }