1 files changed, 33 insertions, 32 deletions

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index faa7d390841b..467620a3b1f9 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -273,11 +273,7 @@ void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info)
                 defrag = rb_entry(node, struct inode_defrag, rb_node);
                 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
 
-                if (need_resched()) {
-                        spin_unlock(&fs_info->defrag_inodes_lock);
-                        cond_resched();
-                        spin_lock(&fs_info->defrag_inodes_lock);
-                }
+                cond_resched_lock(&fs_info->defrag_inodes_lock);
 
                 node = rb_first(&fs_info->defrag_inodes);
         }
@@ -868,7 +864,7 @@ next_slot:
 
                         memcpy(&new_key, &key, sizeof(new_key));
                         new_key.offset = end;
-                        btrfs_set_item_key_safe(root, path, &new_key);
+                        btrfs_set_item_key_safe(root->fs_info, path, &new_key);
 
                         extent_offset += end - key.offset;
                         btrfs_set_file_extent_offset(leaf, fi, extent_offset);
@@ -1126,7 +1122,7 @@ again:
                                      ino, bytenr, orig_offset,
                                      &other_start, &other_end)) {
                         new_key.offset = end;
-                        btrfs_set_item_key_safe(root, path, &new_key);
+                        btrfs_set_item_key_safe(root->fs_info, path, &new_key);
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
                         btrfs_set_file_extent_generation(leaf, fi,
@@ -1160,7 +1156,7 @@ again:
                                                          trans->transid);
                         path->slots[0]++;
                         new_key.offset = start;
-                        btrfs_set_item_key_safe(root, path, &new_key);
+                        btrfs_set_item_key_safe(root->fs_info, path, &new_key);
 
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
@@ -1485,7 +1481,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                         PAGE_CACHE_SIZE / (sizeof(struct page *)));
         nrptrs = min(nrptrs, current->nr_dirtied_pause - current->nr_dirtied);
         nrptrs = max(nrptrs, 8);
-        pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL);
+        pages = kmalloc_array(nrptrs, sizeof(struct page *), GFP_KERNEL);
         if (!pages)
                 return -ENOMEM;
 
@@ -1514,7 +1510,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                 }
 
                 reserve_bytes = num_pages << PAGE_CACHE_SHIFT;
-                ret = btrfs_check_data_free_space(inode, reserve_bytes);
+                ret = btrfs_check_data_free_space(inode, reserve_bytes, write_bytes);
                 if (ret == -ENOSPC &&
                     (BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
                                               BTRFS_INODE_PREALLOC))) {
@@ -1635,8 +1631,8 @@ again:
                         btrfs_end_write_no_snapshoting(root);
 
                 if (only_release_metadata && copied > 0) {
-                        u64 lockstart = round_down(pos, root->sectorsize);
-                        u64 lockend = lockstart +
+                        lockstart = round_down(pos, root->sectorsize);
+                        lockend = lockstart +
                                 (dirty_pages << PAGE_CACHE_SHIFT) - 1;
 
                         set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
@@ -1809,7 +1805,9 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
          * otherwise subsequent syncs to a file that's been synced in this
          * transaction will appear to have already occured.
          */
+        spin_lock(&BTRFS_I(inode)->lock);
         BTRFS_I(inode)->last_sub_trans = root->log_transid;
+        spin_unlock(&BTRFS_I(inode)->lock);
         if (num_written > 0) {
                 err = generic_write_sync(file, pos, num_written);
                 if (err < 0)
@@ -2162,7 +2160,7 @@ static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
                 u64 num_bytes;
 
                 key.offset = offset;
-                btrfs_set_item_key_safe(root, path, &key);
+                btrfs_set_item_key_safe(root->fs_info, path, &key);
                 fi = btrfs_item_ptr(leaf, path->slots[0],
                                     struct btrfs_file_extent_item);
                 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
@@ -2545,7 +2543,6 @@ static long btrfs_fallocate(struct file *file, int mode,
 {
         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;
@@ -2570,14 +2567,9 @@ static long btrfs_fallocate(struct file *file, int mode,
          * Make sure we have enough space before we do the
          * allocation.
          */
-        ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start);
+        ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start, 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;
-        }
 
         mutex_lock(&inode->i_mutex);
         ret = inode_newsize_ok(inode, alloc_end);
@@ -2667,23 +2659,35 @@ static long btrfs_fallocate(struct file *file, int mode,
                                                         1 << inode->i_blkbits,
                                                         offset + len,
                                                         &alloc_hint);
-
-                        if (ret < 0) {
-                                free_extent_map(em);
-                                break;
-                        }
                 } else if (actual_end > inode->i_size &&
                            !(mode & FALLOC_FL_KEEP_SIZE)) {
+                        struct btrfs_trans_handle *trans;
+                        struct btrfs_root *root = BTRFS_I(inode)->root;
+
                         /*
                          * We didn't need to allocate any more space, but we
                          * still extended the size of the file so we need to
-                         * update i_size.
+                         * update i_size and the inode item.
                          */
-                        inode->i_ctime = CURRENT_TIME;
-                        i_size_write(inode, actual_end);
-                        btrfs_ordered_update_i_size(inode, actual_end, NULL);
+                        trans = btrfs_start_transaction(root, 1);
+                        if (IS_ERR(trans)) {
+                                ret = PTR_ERR(trans);
+                        } else {
+                                inode->i_ctime = CURRENT_TIME;
+                                i_size_write(inode, actual_end);
+                                btrfs_ordered_update_i_size(inode, actual_end,
+                                                            NULL);
+                                ret = btrfs_update_inode(trans, root, inode);
+                                if (ret)
+                                        btrfs_end_transaction(trans, root);
+                                else
+                                        ret = btrfs_end_transaction(trans,
+                                                                    root);
+                        }
                 }
                 free_extent_map(em);
+                if (ret < 0)
+                        break;
 
                 cur_offset = last_byte;
                 if (cur_offset >= alloc_end) {
@@ -2695,9 +2699,6 @@ 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;