1 files changed, 61 insertions, 14 deletions

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index aeb84469d2c4..ade03e6f7bd2 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -30,11 +30,11 @@
 #include <linux/statfs.h>
 #include <linux/compat.h>
 #include <linux/slab.h>
+#include <linux/btrfs.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
 #include "btrfs_inode.h"
-#include "ioctl.h"
 #include "print-tree.h"
 #include "tree-log.h"
 #include "locking.h"
@@ -374,6 +374,11 @@ int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
 
         atomic_inc(&fs_info->defrag_running);
         while(1) {
+                /* Pause the auto defragger. */
+                if (test_bit(BTRFS_FS_STATE_REMOUNTING,
+                             &fs_info->fs_state))
+                        break;
+
                 if (!__need_auto_defrag(fs_info->tree_root))
                         break;
 
@@ -505,8 +510,7 @@ int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
         loff_t isize = i_size_read(inode);
 
         start_pos = pos & ~((u64)root->sectorsize - 1);
-        num_bytes = (write_bytes + pos - start_pos +
-                    root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
+        num_bytes = ALIGN(write_bytes + pos - start_pos, root->sectorsize);
 
         end_of_last_block = start_pos + num_bytes - 1;
         err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block,
@@ -587,6 +591,7 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 }
                 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                 clear_bit(EXTENT_FLAG_PINNED, &em->flags);
+                clear_bit(EXTENT_FLAG_LOGGING, &flags);
                 remove_extent_mapping(em_tree, em);
                 if (no_splits)
                         goto next;
@@ -1225,7 +1230,7 @@ static noinline int prepare_pages(struct btrfs_root *root, struct file *file,
         struct extent_state *cached_state = NULL;
         int i;
         unsigned long index = pos >> PAGE_CACHE_SHIFT;
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
         int err = 0;
         int faili = 0;
@@ -1312,7 +1317,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                                                struct iov_iter *i,
                                                loff_t pos)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct page **pages = NULL;
         unsigned long first_index;
@@ -1500,7 +1505,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                                     unsigned long nr_segs, loff_t pos)
 {
         struct file *file = iocb->ki_filp;
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         loff_t *ppos = &iocb->ki_pos;
         u64 start_pos;
@@ -1544,7 +1549,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
          * although we have opened a file as writable, we have
          * to stop this write operation to ensure FS consistency.
          */
-        if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
+        if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
                 mutex_unlock(&inode->i_mutex);
                 err = -EROFS;
                 goto out;
@@ -1627,7 +1632,20 @@ int btrfs_release_file(struct inode *inode, struct file *filp)
          */
         if (test_and_clear_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
                                &BTRFS_I(inode)->runtime_flags)) {
-                btrfs_add_ordered_operation(NULL, BTRFS_I(inode)->root, inode);
+                struct btrfs_trans_handle *trans;
+                struct btrfs_root *root = BTRFS_I(inode)->root;
+
+                /*
+                 * We need to block on a committing transaction to keep us from
+                 * throwing a ordered operation on to the list and causing
+                 * something like sync to deadlock trying to flush out this
+                 * inode.
+                 */
+                trans = btrfs_start_transaction(root, 0);
+                if (IS_ERR(trans))
+                        return PTR_ERR(trans);
+                btrfs_add_ordered_operation(trans, BTRFS_I(inode)->root, inode);
+                btrfs_end_transaction(trans, root);
                 if (inode->i_size > BTRFS_ORDERED_OPERATIONS_FLUSH_LIMIT)
                         filemap_flush(inode->i_mapping);
         }
@@ -1654,16 +1672,21 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret = 0;
         struct btrfs_trans_handle *trans;
+        bool full_sync = 0;
 
         trace_btrfs_sync_file(file, datasync);
 
         /*
          * We write the dirty pages in the range and wait until they complete
          * out of the ->i_mutex. If so, we can flush the dirty pages by
-         * multi-task, and make the performance up.
+         * multi-task, and make the performance up.  See
+         * btrfs_wait_ordered_range for an explanation of the ASYNC check.
          */
         atomic_inc(&BTRFS_I(inode)->sync_writers);
-        ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
+        if (!ret && test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
+                             &BTRFS_I(inode)->runtime_flags))
+                ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
         atomic_dec(&BTRFS_I(inode)->sync_writers);
         if (ret)
                 return ret;
@@ -1675,7 +1698,10 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
          * range being left.
          */
         atomic_inc(&root->log_batch);
-        btrfs_wait_ordered_range(inode, start, end - start + 1);
+        full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                             &BTRFS_I(inode)->runtime_flags);
+        if (full_sync)
+                btrfs_wait_ordered_range(inode, start, end - start + 1);
         atomic_inc(&root->log_batch);
 
         /*
@@ -1742,13 +1768,25 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 
         if (ret != BTRFS_NO_LOG_SYNC) {
                 if (ret > 0) {
+                        /*
+                         * If we didn't already wait for ordered extents we need
+                         * to do that now.
+                         */
+                        if (!full_sync)
+                                btrfs_wait_ordered_range(inode, start,
+                                                         end - start + 1);
                         ret = btrfs_commit_transaction(trans, root);
                 } else {
                         ret = btrfs_sync_log(trans, root);
-                        if (ret == 0)
+                        if (ret == 0) {
                                 ret = btrfs_end_transaction(trans, root);
-                        else
+                        } else {
+                                if (!full_sync)
+                                        btrfs_wait_ordered_range(inode, start,
+                                                                 end -
+                                                                 start + 1);
                                 ret = btrfs_commit_transaction(trans, root);
+                        }
                 }
         } else {
                 ret = btrfs_end_transaction(trans, root);
@@ -2102,8 +2140,9 @@ out:
 static long btrfs_fallocate(struct file *file, int mode,
                             loff_t offset, loff_t len)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        struct inode *inode = file_inode(file);
         struct extent_state *cached_state = NULL;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
         u64 cur_offset;
         u64 last_byte;
         u64 alloc_start;
@@ -2131,6 +2170,11 @@ static long btrfs_fallocate(struct file *file, int mode,
         ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start);
         if (ret)
                 return ret;
+        if (root->fs_info->quota_enabled) {
+                ret = btrfs_qgroup_reserve(root, alloc_end - alloc_start);
+                if (ret)
+                        goto out_reserve_fail;
+        }
 
         /*
          * wait for ordered IO before we have any locks.  We'll loop again
@@ -2234,6 +2278,9 @@ static long btrfs_fallocate(struct file *file, int mode,
                              &cached_state, GFP_NOFS);
 out:
         mutex_unlock(&inode->i_mutex);
+        if (root->fs_info->quota_enabled)
+                btrfs_qgroup_free(root, alloc_end - alloc_start);
+out_reserve_fail:
         /* Let go of our reservation. */
         btrfs_free_reserved_data_space(inode, alloc_end - alloc_start);
         return ret;