1 files changed, 116 insertions, 42 deletions

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 0afcd452fcb3..2544805544f0 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -158,12 +158,20 @@ struct scrub_fixup_nodatasum {
         int                     mirror_num;
 };
 
+struct scrub_nocow_inode {
+        u64                     inum;
+        u64                     offset;
+        u64                     root;
+        struct list_head        list;
+};
+
 struct scrub_copy_nocow_ctx {
         struct scrub_ctx        *sctx;
         u64                     logical;
         u64                     len;
         int                     mirror_num;
         u64                     physical_for_dev_replace;
+        struct list_head        inodes;
         struct btrfs_work       work;
 };
 
@@ -245,7 +253,7 @@ static void scrub_wr_bio_end_io_worker(struct btrfs_work *work);
 static int write_page_nocow(struct scrub_ctx *sctx,
                             u64 physical_for_dev_replace, struct page *page);
 static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root,
-                                      void *ctx);
+                                      struct scrub_copy_nocow_ctx *ctx);
 static int copy_nocow_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
                             int mirror_num, u64 physical_for_dev_replace);
 static void copy_nocow_pages_worker(struct btrfs_work *work);
@@ -2709,8 +2717,6 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,
                 mutex_unlock(&fs_info->scrub_lock);
                 wake_up(&fs_info->scrub_pause_wait);
 
-                dev_replace->cursor_left = dev_replace->cursor_right;
-                dev_replace->item_needs_writeback = 1;
                 btrfs_put_block_group(cache);
                 if (ret)
                         break;
@@ -2724,6 +2730,9 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,
                         break;
                 }
 
+                dev_replace->cursor_left = dev_replace->cursor_right;
+                dev_replace->item_needs_writeback = 1;
+
                 key.offset = found_key.offset + length;
                 btrfs_release_path(path);
         }
@@ -2775,7 +2784,6 @@ static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info,
 {
         int ret = 0;
 
-        mutex_lock(&fs_info->scrub_lock);
         if (fs_info->scrub_workers_refcnt == 0) {
                 if (is_dev_replace)
                         btrfs_init_workers(&fs_info->scrub_workers, "scrub", 1,
@@ -2805,21 +2813,17 @@ static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info,
         }
         ++fs_info->scrub_workers_refcnt;
 out:
-        mutex_unlock(&fs_info->scrub_lock);
-
         return ret;
 }
 
 static noinline_for_stack void scrub_workers_put(struct btrfs_fs_info *fs_info)
 {
-        mutex_lock(&fs_info->scrub_lock);
         if (--fs_info->scrub_workers_refcnt == 0) {
                 btrfs_stop_workers(&fs_info->scrub_workers);
                 btrfs_stop_workers(&fs_info->scrub_wr_completion_workers);
                 btrfs_stop_workers(&fs_info->scrub_nocow_workers);
         }
         WARN_ON(fs_info->scrub_workers_refcnt < 0);
-        mutex_unlock(&fs_info->scrub_lock);
 }
 
 int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
@@ -2880,23 +2884,18 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
                 return -EINVAL;
         }
 
-        ret = scrub_workers_get(fs_info, is_dev_replace);
-        if (ret)
-                return ret;
 
         mutex_lock(&fs_info->fs_devices->device_list_mutex);
         dev = btrfs_find_device(fs_info, devid, NULL, NULL);
         if (!dev || (dev->missing && !is_dev_replace)) {
                 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(fs_info);
                 return -ENODEV;
         }
-        mutex_lock(&fs_info->scrub_lock);
 
+        mutex_lock(&fs_info->scrub_lock);
         if (!dev->in_fs_metadata || dev->is_tgtdev_for_dev_replace) {
                 mutex_unlock(&fs_info->scrub_lock);
                 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(fs_info);
                 return -EIO;
         }
 
@@ -2907,10 +2906,17 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
                 btrfs_dev_replace_unlock(&fs_info->dev_replace);
                 mutex_unlock(&fs_info->scrub_lock);
                 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(fs_info);
                 return -EINPROGRESS;
         }
         btrfs_dev_replace_unlock(&fs_info->dev_replace);
+
+        ret = scrub_workers_get(fs_info, is_dev_replace);
+        if (ret) {
+                mutex_unlock(&fs_info->scrub_lock);
+                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+                return ret;
+        }
+
         sctx = scrub_setup_ctx(dev, is_dev_replace);
         if (IS_ERR(sctx)) {
                 mutex_unlock(&fs_info->scrub_lock);
@@ -2923,13 +2929,15 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
 
         atomic_inc(&fs_info->scrubs_running);
         mutex_unlock(&fs_info->scrub_lock);
-        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
 
         if (!is_dev_replace) {
-                down_read(&fs_info->scrub_super_lock);
+                /*
+                 * by holding device list mutex, we can
+                 * kick off writing super in log tree sync.
+                 */
                 ret = scrub_supers(sctx, dev);
-                up_read(&fs_info->scrub_super_lock);
         }
+        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
 
         if (!ret)
                 ret = scrub_enumerate_chunks(sctx, dev, start, end,
@@ -2946,10 +2954,10 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
 
         mutex_lock(&fs_info->scrub_lock);
         dev->scrub_device = NULL;
+        scrub_workers_put(fs_info);
         mutex_unlock(&fs_info->scrub_lock);
 
         scrub_free_ctx(sctx);
-        scrub_workers_put(fs_info);
 
         return ret;
 }
@@ -2979,16 +2987,6 @@ void btrfs_scrub_continue(struct btrfs_root *root)
         wake_up(&fs_info->scrub_pause_wait);
 }
 
-void btrfs_scrub_pause_super(struct btrfs_root *root)
-{
-        down_write(&root->fs_info->scrub_super_lock);
-}
-
-void btrfs_scrub_continue_super(struct btrfs_root *root)
-{
-        up_write(&root->fs_info->scrub_super_lock);
-}
-
 int btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)
 {
         mutex_lock(&fs_info->scrub_lock);
@@ -3126,12 +3124,30 @@ static int copy_nocow_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
         nocow_ctx->mirror_num = mirror_num;
         nocow_ctx->physical_for_dev_replace = physical_for_dev_replace;
         nocow_ctx->work.func = copy_nocow_pages_worker;
+        INIT_LIST_HEAD(&nocow_ctx->inodes);
         btrfs_queue_worker(&fs_info->scrub_nocow_workers,
                            &nocow_ctx->work);
 
         return 0;
 }
 
+static int record_inode_for_nocow(u64 inum, u64 offset, u64 root, void *ctx)
+{
+        struct scrub_copy_nocow_ctx *nocow_ctx = ctx;
+        struct scrub_nocow_inode *nocow_inode;
+
+        nocow_inode = kzalloc(sizeof(*nocow_inode), GFP_NOFS);
+        if (!nocow_inode)
+                return -ENOMEM;
+        nocow_inode->inum = inum;
+        nocow_inode->offset = offset;
+        nocow_inode->root = root;
+        list_add_tail(&nocow_inode->list, &nocow_ctx->inodes);
+        return 0;
+}
+
+#define COPY_COMPLETE 1
+
 static void copy_nocow_pages_worker(struct btrfs_work *work)
 {
         struct scrub_copy_nocow_ctx *nocow_ctx =
@@ -3167,8 +3183,7 @@ static void copy_nocow_pages_worker(struct btrfs_work *work)
         }
 
         ret = iterate_inodes_from_logical(logical, fs_info, path,
-                                          copy_nocow_pages_for_inode,
-                                          nocow_ctx);
+                                          record_inode_for_nocow, nocow_ctx);
         if (ret != 0 && ret != -ENOENT) {
                 pr_warn("iterate_inodes_from_logical() failed: log %llu, phys %llu, len %llu, mir %u, ret %d\n",
                         logical, physical_for_dev_replace, len, mirror_num,
@@ -3177,7 +3192,33 @@ static void copy_nocow_pages_worker(struct btrfs_work *work)
                 goto out;
         }
 
+        btrfs_end_transaction(trans, root);
+        trans = NULL;
+        while (!list_empty(&nocow_ctx->inodes)) {
+                struct scrub_nocow_inode *entry;
+                entry = list_first_entry(&nocow_ctx->inodes,
+                                         struct scrub_nocow_inode,
+                                         list);
+                list_del_init(&entry->list);
+                ret = copy_nocow_pages_for_inode(entry->inum, entry->offset,
+                                                 entry->root, nocow_ctx);
+                kfree(entry);
+                if (ret == COPY_COMPLETE) {
+                        ret = 0;
+                        break;
+                } else if (ret) {
+                        break;
+                }
+        }
 out:
+        while (!list_empty(&nocow_ctx->inodes)) {
+                struct scrub_nocow_inode *entry;
+                entry = list_first_entry(&nocow_ctx->inodes,
+                                         struct scrub_nocow_inode,
+                                         list);
+                list_del_init(&entry->list);
+                kfree(entry);
+        }
         if (trans && !IS_ERR(trans))
                 btrfs_end_transaction(trans, root);
         if (not_written)
@@ -3190,20 +3231,25 @@ out:
         scrub_pending_trans_workers_dec(sctx);
 }
 
-static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
+static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root,
+                                      struct scrub_copy_nocow_ctx *nocow_ctx)
 {
-        struct scrub_copy_nocow_ctx *nocow_ctx = ctx;
         struct btrfs_fs_info *fs_info = nocow_ctx->sctx->dev_root->fs_info;
         struct btrfs_key key;
         struct inode *inode;
         struct page *page;
         struct btrfs_root *local_root;
+        struct btrfs_ordered_extent *ordered;
+        struct extent_map *em;
+        struct extent_state *cached_state = NULL;
+        struct extent_io_tree *io_tree;
         u64 physical_for_dev_replace;
-        u64 len;
+        u64 len = nocow_ctx->len;
+        u64 lockstart = offset, lockend = offset + len - 1;
         unsigned long index;
         int srcu_index;
-        int ret;
-        int err;
+        int ret = 0;
+        int err = 0;
 
         key.objectid = root;
         key.type = BTRFS_ROOT_ITEM_KEY;
@@ -3229,9 +3275,33 @@ static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
         mutex_lock(&inode->i_mutex);
         inode_dio_wait(inode);
 
-        ret = 0;
         physical_for_dev_replace = nocow_ctx->physical_for_dev_replace;
-        len = nocow_ctx->len;
+        io_tree = &BTRFS_I(inode)->io_tree;
+
+        lock_extent_bits(io_tree, lockstart, lockend, 0, &cached_state);
+        ordered = btrfs_lookup_ordered_range(inode, lockstart, len);
+        if (ordered) {
+                btrfs_put_ordered_extent(ordered);
+                goto out_unlock;
+        }
+
+        em = btrfs_get_extent(inode, NULL, 0, lockstart, len, 0);
+        if (IS_ERR(em)) {
+                ret = PTR_ERR(em);
+                goto out_unlock;
+        }
+
+        /*
+         * This extent does not actually cover the logical extent anymore,
+         * move on to the next inode.
+         */
+        if (em->block_start > nocow_ctx->logical ||
+            em->block_start + em->block_len < nocow_ctx->logical + len) {
+                free_extent_map(em);
+                goto out_unlock;
+        }
+        free_extent_map(em);
+
         while (len >= PAGE_CACHE_SIZE) {
                 index = offset >> PAGE_CACHE_SHIFT;
 again:
@@ -3247,10 +3317,9 @@ again:
                                 goto next_page;
                 } else {
                         ClearPageError(page);
-                        err = extent_read_full_page(&BTRFS_I(inode)->
-                                                         io_tree,
-                                                        page, btrfs_get_extent,
-                                                        nocow_ctx->mirror_num);
+                        err = extent_read_full_page_nolock(io_tree, page,
+                                                           btrfs_get_extent,
+                                                           nocow_ctx->mirror_num);
                         if (err) {
                                 ret = err;
                                 goto next_page;
@@ -3264,6 +3333,7 @@ again:
                          * page in the page cache.
                          */
                         if (page->mapping != inode->i_mapping) {
+                                unlock_page(page);
                                 page_cache_release(page);
                                 goto again;
                         }
@@ -3287,6 +3357,10 @@ next_page:
                 physical_for_dev_replace += PAGE_CACHE_SIZE;
                 len -= PAGE_CACHE_SIZE;
         }
+        ret = COPY_COMPLETE;
+out_unlock:
+        unlock_extent_cached(io_tree, lockstart, lockend, &cached_state,
+                             GFP_NOFS);
 out:
         mutex_unlock(&inode->i_mutex);
         iput(inode);