drop unused dentry argument to ->fsync

[safe/jmp/linux-2.6] / fs / ext3 / fsync.c

diff --git a/fs/ext3/fsync.c b/fs/ext3/fsync.c
index d336341..d7e9f74 100644 (file)
--- a/fs/ext3/fsync.c
+++ b/fs/ext3/fsync.c
@@ -23,6 +23,7 @@
  */
 
 #include <linux/time.h>
+#include <linux/blkdev.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
 #include <linux/writeback.h>
@@ -42,22 +43,24 @@
  * inode to disk.
  */
 
-int ext3_sync_file(struct file * file, struct dentry *dentry, int datasync)
+int ext3_sync_file(struct file *file, int datasync)
 {
-       struct inode *inode = dentry->d_inode;
-       int ret = 0;
+       struct inode *inode = file->f_mapping->host;
+       struct ext3_inode_info *ei = EXT3_I(inode);
+       journal_t *journal = EXT3_SB(inode->i_sb)->s_journal;
+       int ret, needs_barrier = 0;
+       tid_t commit_tid;
+
+       if (inode->i_sb->s_flags & MS_RDONLY)
+               return 0;
 
        J_ASSERT(ext3_journal_current_handle() == NULL);
 
        /*
-        * data=writeback:
+        * data=writeback,ordered:
         *  The caller's filemap_fdatawrite()/wait will sync the data.
-        *  sync_inode() will sync the metadata
-        *
-        * data=ordered:
-        *  The caller's filemap_fdatawrite() will write the data and
-        *  sync_inode() will write the inode if it is dirty.  Then the caller's
-        *  filemap_fdatawait() will wait on the pages.
+        *  Metadata is in the journal, we wait for a proper transaction
+        *  to commit here.
         *
         * data=journal:
         *  filemap_fdatawrite won't do anything (the buffers are clean).
@@ -67,25 +70,27 @@ int ext3_sync_file(struct file * file, struct dentry *dentry, int datasync)
         *  (they were dirtied by commit).  But that's OK - the blocks are
         *  safe in-journal, which is all fsync() needs to ensure.
         */
-       if (ext3_should_journal_data(inode)) {
-               ret = ext3_force_commit(inode->i_sb);
-               goto out;
-       }
+       if (ext3_should_journal_data(inode))
+               return ext3_force_commit(inode->i_sb);
+
+       if (datasync)
+               commit_tid = atomic_read(&ei->i_datasync_tid);
+       else
+               commit_tid = atomic_read(&ei->i_sync_tid);
 
-       if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
-               goto out;
+       if (test_opt(inode->i_sb, BARRIER) &&
+           !journal_trans_will_send_data_barrier(journal, commit_tid))
+               needs_barrier = 1;
+       log_start_commit(journal, commit_tid);
+       ret = log_wait_commit(journal, commit_tid);
 
        /*
-        * The VFS has written the file data.  If the inode is unaltered
-        * then we need not start a commit.
+        * In case we didn't commit a transaction, we have to flush
+        * disk caches manually so that data really is on persistent
+        * storage
         */
-       if (inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC)) {
-               struct writeback_control wbc = {
-                       .sync_mode = WB_SYNC_ALL,
-                       .nr_to_write = 0, /* sys_fsync did this */
-               };
-               ret = sync_inode(inode, &wbc);
-       }
-out:
+       if (needs_barrier)
+               blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL,
+                               BLKDEV_IFL_WAIT);
        return ret;
 }