Merge branch 'for-linus-4.7' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs

Pull btrfs updates from Chris Mason:
 "This has our merge window series of cleanups and fixes.  These target
  a wide range of issues, but do include some important fixes for
  qgroups, O_DIRECT, and fsync handling.  Jeff Mahoney moved around a
  few definitions to make them easier for userland to consume.

  Also whiteout support is included now that issues with overlayfs have
  been cleared up.

  I have one more fix pending for page faults during btrfs_copy_from_user,
  but I wanted to get this bulk out the door first"

* 'for-linus-4.7' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (90 commits)
  btrfs: fix memory leak during RAID 5/6 device replacement
  Btrfs: add semaphore to synchronize direct IO writes with fsync
  Btrfs: fix race between block group relocation and nocow writes
  Btrfs: fix race between fsync and direct IO writes for prealloc extents
  Btrfs: fix number of transaction units for renames with whiteout
  Btrfs: pin logs earlier when doing a rename exchange operation
  Btrfs: unpin logs if rename exchange operation fails
  Btrfs: fix inode leak on failure to setup whiteout inode in rename
  btrfs: add support for RENAME_EXCHANGE and RENAME_WHITEOUT
  Btrfs: pin log earlier when renaming
  Btrfs: unpin log if rename operation fails
  Btrfs: don't do unnecessary delalloc flushes when relocating
  Btrfs: don't wait for unrelated IO to finish before relocation
  Btrfs: fix empty symlink after creating symlink and fsync parent dir
  Btrfs: fix for incorrect directory entries after fsync log replay
  btrfs: build fixup for qgroup_account_snapshot
  btrfs: qgroup: Fix qgroup accounting when creating snapshot
  Btrfs: fix fspath error deallocation
  btrfs: make find_workspace warn if there are no workspaces
  btrfs: make find_workspace always succeed
  ...

1 files changed, 138 insertions, 29 deletions

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 84e060eb0de8..9424864fd01a 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -3824,6 +3824,59 @@ int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
         return readonly;
 }
 
+bool btrfs_inc_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr)
+{
+        struct btrfs_block_group_cache *bg;
+        bool ret = true;
+
+        bg = btrfs_lookup_block_group(fs_info, bytenr);
+        if (!bg)
+                return false;
+
+        spin_lock(&bg->lock);
+        if (bg->ro)
+                ret = false;
+        else
+                atomic_inc(&bg->nocow_writers);
+        spin_unlock(&bg->lock);
+
+        /* no put on block group, done by btrfs_dec_nocow_writers */
+        if (!ret)
+                btrfs_put_block_group(bg);
+
+        return ret;
+
+}
+
+void btrfs_dec_nocow_writers(struct btrfs_fs_info *fs_info, u64 bytenr)
+{
+        struct btrfs_block_group_cache *bg;
+
+        bg = btrfs_lookup_block_group(fs_info, bytenr);
+        ASSERT(bg);
+        if (atomic_dec_and_test(&bg->nocow_writers))
+                wake_up_atomic_t(&bg->nocow_writers);
+        /*
+         * Once for our lookup and once for the lookup done by a previous call
+         * to btrfs_inc_nocow_writers()
+         */
+        btrfs_put_block_group(bg);
+        btrfs_put_block_group(bg);
+}
+
+static int btrfs_wait_nocow_writers_atomic_t(atomic_t *a)
+{
+        schedule();
+        return 0;
+}
+
+void btrfs_wait_nocow_writers(struct btrfs_block_group_cache *bg)
+{
+        wait_on_atomic_t(&bg->nocow_writers,
+                         btrfs_wait_nocow_writers_atomic_t,
+                         TASK_UNINTERRUPTIBLE);
+}
+
 static const char *alloc_name(u64 flags)
 {
         switch (flags) {
@@ -4141,7 +4194,7 @@ commit_trans:
 
                         if (need_commit > 0) {
                                 btrfs_start_delalloc_roots(fs_info, 0, -1);
-                                btrfs_wait_ordered_roots(fs_info, -1);
+                                btrfs_wait_ordered_roots(fs_info, -1, 0, (u64)-1);
                         }
 
                         trans = btrfs_join_transaction(root);
@@ -4583,7 +4636,8 @@ static void btrfs_writeback_inodes_sb_nr(struct btrfs_root *root,
                  */
                 btrfs_start_delalloc_roots(root->fs_info, 0, nr_items);
                 if (!current->journal_info)
-                        btrfs_wait_ordered_roots(root->fs_info, nr_items);
+                        btrfs_wait_ordered_roots(root->fs_info, nr_items,
+                                                 0, (u64)-1);
         }
 }
 
@@ -4620,7 +4674,7 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
 
         /* Calc the number of the pages we need flush for space reservation */
         items = calc_reclaim_items_nr(root, to_reclaim);
-        to_reclaim = items * EXTENT_SIZE_PER_ITEM;
+        to_reclaim = (u64)items * EXTENT_SIZE_PER_ITEM;
 
         trans = (struct btrfs_trans_handle *)current->journal_info;
         block_rsv = &root->fs_info->delalloc_block_rsv;
@@ -4632,7 +4686,8 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
                 if (trans)
                         return;
                 if (wait_ordered)
-                        btrfs_wait_ordered_roots(root->fs_info, items);
+                        btrfs_wait_ordered_roots(root->fs_info, items,
+                                                 0, (u64)-1);
                 return;
         }
 
@@ -4671,7 +4726,8 @@ skip_async:
 
                 loops++;
                 if (wait_ordered && !trans) {
-                        btrfs_wait_ordered_roots(root->fs_info, items);
+                        btrfs_wait_ordered_roots(root->fs_info, items,
+                                                 0, (u64)-1);
                 } else {
                         time_left = schedule_timeout_killable(1);
                         if (time_left)
@@ -6172,6 +6228,57 @@ int btrfs_exclude_logged_extents(struct btrfs_root *log,
         return 0;
 }
 
+static void
+btrfs_inc_block_group_reservations(struct btrfs_block_group_cache *bg)
+{
+        atomic_inc(&bg->reservations);
+}
+
+void btrfs_dec_block_group_reservations(struct btrfs_fs_info *fs_info,
+                                        const u64 start)
+{
+        struct btrfs_block_group_cache *bg;
+
+        bg = btrfs_lookup_block_group(fs_info, start);
+        ASSERT(bg);
+        if (atomic_dec_and_test(&bg->reservations))
+                wake_up_atomic_t(&bg->reservations);
+        btrfs_put_block_group(bg);
+}
+
+static int btrfs_wait_bg_reservations_atomic_t(atomic_t *a)
+{
+        schedule();
+        return 0;
+}
+
+void btrfs_wait_block_group_reservations(struct btrfs_block_group_cache *bg)
+{
+        struct btrfs_space_info *space_info = bg->space_info;
+
+        ASSERT(bg->ro);
+
+        if (!(bg->flags & BTRFS_BLOCK_GROUP_DATA))
+                return;
+
+        /*
+         * Our block group is read only but before we set it to read only,
+         * some task might have had allocated an extent from it already, but it
+         * has not yet created a respective ordered extent (and added it to a
+         * root's list of ordered extents).
+         * Therefore wait for any task currently allocating extents, since the
+         * block group's reservations counter is incremented while a read lock
+         * on the groups' semaphore is held and decremented after releasing
+         * the read access on that semaphore and creating the ordered extent.
+         */
+        down_write(&space_info->groups_sem);
+        up_write(&space_info->groups_sem);
+
+        wait_on_atomic_t(&bg->reservations,
+                         btrfs_wait_bg_reservations_atomic_t,
+                         TASK_UNINTERRUPTIBLE);
+}
+
 /**
  * btrfs_update_reserved_bytes - update the block_group and space info counters
  * @cache:      The cache we are manipulating
@@ -7025,36 +7132,35 @@ btrfs_lock_cluster(struct btrfs_block_group_cache *block_group,
                    int delalloc)
 {
         struct btrfs_block_group_cache *used_bg = NULL;
-        bool locked = false;
-again:
+
         spin_lock(&cluster->refill_lock);
-        if (locked) {
-                if (used_bg == cluster->block_group)
+        while (1) {
+                used_bg = cluster->block_group;
+                if (!used_bg)
+                        return NULL;
+
+                if (used_bg == block_group)
                         return used_bg;
 
-                up_read(&used_bg->data_rwsem);
-                btrfs_put_block_group(used_bg);
-        }
+                btrfs_get_block_group(used_bg);
 
-        used_bg = cluster->block_group;
-        if (!used_bg)
-                return NULL;
+                if (!delalloc)
+                        return used_bg;
 
-        if (used_bg == block_group)
-                return used_bg;
+                if (down_read_trylock(&used_bg->data_rwsem))
+                        return used_bg;
 
-        btrfs_get_block_group(used_bg);
+                spin_unlock(&cluster->refill_lock);
 
-        if (!delalloc)
-                return used_bg;
+                down_read(&used_bg->data_rwsem);
 
-        if (down_read_trylock(&used_bg->data_rwsem))
-                return used_bg;
+                spin_lock(&cluster->refill_lock);
+                if (used_bg == cluster->block_group)
+                        return used_bg;
 
-        spin_unlock(&cluster->refill_lock);
-        down_read(&used_bg->data_rwsem);
-        locked = true;
-        goto again;
+                up_read(&used_bg->data_rwsem);
+                btrfs_put_block_group(used_bg);
+        }
 }
 
 static inline void
@@ -7431,6 +7537,7 @@ checks:
                         btrfs_add_free_space(block_group, offset, num_bytes);
                         goto loop;
                 }
+                btrfs_inc_block_group_reservations(block_group);
 
                 /* we are all good, lets return */
                 ins->objectid = search_start;
@@ -7612,8 +7719,10 @@ again:
         WARN_ON(num_bytes < root->sectorsize);
         ret = find_free_extent(root, num_bytes, empty_size, hint_byte, ins,
                                flags, delalloc);
-
-        if (ret == -ENOSPC) {
+        if (!ret && !is_data) {
+                btrfs_dec_block_group_reservations(root->fs_info,
+                                                   ins->objectid);
+        } else if (ret == -ENOSPC) {
                 if (!final_tried && ins->offset) {
                         num_bytes = min(num_bytes >> 1, ins->offset);
                         num_bytes = round_down(num_bytes, root->sectorsize);
@@ -9058,7 +9167,7 @@ out:
         if (!for_reloc && root_dropped == false)
                 btrfs_add_dead_root(root);
         if (err && err != -EAGAIN)
-                btrfs_std_error(root->fs_info, err, NULL);
+                btrfs_handle_fs_error(root->fs_info, err, NULL);
         return err;
 }