btrfs: remove remaing full_sync logic from btrfs_sync_file

The logic to check if the inode is already in the log can now be
simplified since we always wait for the ordered extents to complete
before deciding whether the inode needs to be logged. The big comment
about it can go away too.

CC: Filipe Manana <fdmanana@suse.com>
Suggested-by: Filipe Manana <fdmanana@suse.com>
[ code and changelog copied from mail discussion ]
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index d5be80fb427c3300265ce842e5dd2e3f6b59ace9..975c590c50d8a6e0ae16382e5454ca63cbed3235 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2042,7 +2042,6 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
        struct btrfs_trans_handle *trans;
        struct btrfs_log_ctx ctx;
        int ret = 0, err;
-       bool full_sync = false;
        u64 len;
 
        /*
@@ -2066,8 +2065,6 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 
        inode_lock(inode);
        atomic_inc(&root->log_batch);
-       full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
-                            &BTRFS_I(inode)->runtime_flags);
 
        /*
         * We have to do this here to avoid the priority inversion of waiting on
@@ -2080,41 +2077,9 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
        }
        atomic_inc(&root->log_batch);
 
-       /*
-        * If the last transaction that changed this file was before the current
-        * transaction and we have the full sync flag set in our inode, we can
-        * bail out now without any syncing.
-        *
-        * Note that we can't bail out if the full sync flag isn't set. This is
-        * because when the full sync flag is set we start all ordered extents
-        * and wait for them to fully complete - when they complete they update
-        * the inode's last_trans field through:
-        *
-        *     btrfs_finish_ordered_io() ->
-        *         btrfs_update_inode_fallback() ->
-        *             btrfs_update_inode() ->
-        *                 btrfs_set_inode_last_trans()
-        *
-        * So we are sure that last_trans is up to date and can do this check to
-        * bail out safely. For the fast path, when the full sync flag is not
-        * set in our inode, we can not do it because we start only our ordered
-        * extents and don't wait for them to complete (that is when
-        * btrfs_finish_ordered_io runs), so here at this point their last_trans
-        * value might be less than or equals to fs_info->last_trans_committed,
-        * and setting a speculative last_trans for an inode when a buffered
-        * write is made (such as fs_info->generation + 1 for example) would not
-        * be reliable since after setting the value and before fsync is called
-        * any number of transactions can start and commit (transaction kthread
-        * commits the current transaction periodically), and a transaction
-        * commit does not start nor waits for ordered extents to complete.
-        */
        smp_mb();
        if (btrfs_inode_in_log(BTRFS_I(inode), fs_info->generation) ||
-           (full_sync && BTRFS_I(inode)->last_trans <=
-            fs_info->last_trans_committed) ||
-           (!btrfs_have_ordered_extents_in_range(inode, start, len) &&
-            BTRFS_I(inode)->last_trans
-            <= fs_info->last_trans_committed)) {
+           BTRFS_I(inode)->last_trans <= fs_info->last_trans_committed) {
                /*
                 * We've had everything committed since the last time we were
                 * modified so clear this flag in case it was set for whatever

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index c35d2aed5ff80f3dcd6c1c6b04b96b869196aa8b..e173b252d79526f5fdef4b642895103da1a047dc 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -790,20 +790,6 @@ out:
        return entry;
 }
 
-bool btrfs_have_ordered_extents_in_range(struct inode *inode,
-                                        u64 file_offset,
-                                        u64 len)
-{
-       struct btrfs_ordered_extent *oe;
-
-       oe = btrfs_lookup_ordered_range(BTRFS_I(inode), file_offset, len);
-       if (oe) {
-               btrfs_put_ordered_extent(oe);
-               return true;
-       }
-       return false;
-}
-
 /*
  * lookup and return any extent before 'file_offset'.  NULL is returned
  * if none is found

diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index b2d3f6a091f71ea88d86b12b9c619f9a854648c1..02d813aaa2619dc57acf958531fe2e88c57f8a5b 100644 (file)
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -178,9 +178,6 @@ struct btrfs_ordered_extent *btrfs_lookup_ordered_range(
                struct btrfs_inode *inode,
                u64 file_offset,
                u64 len);
-bool btrfs_have_ordered_extents_in_range(struct inode *inode,
-                                        u64 file_offset,
-                                        u64 len);
 int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
                                struct btrfs_ordered_extent *ordered);
 int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr,