sparse pointer use of zero as null
[linux-3.10.git] / fs / ext3 / fsync.c
1 /*
2  *  linux/fs/ext3/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  *  ext3fs 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/jbd.h>
30 #include <linux/ext3_fs.h>
31 #include <linux/ext3_jbd.h>
32
33 /*
34  * akpm: A new design for ext3_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 ext3_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(ext3_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          *  ext3_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 (ext3_should_journal_data(inode)) {
71                 ret = ext3_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 }