Merge branch 'for-3.11/core' of git://git.kernel.dk/linux-block

[firefly-linux-kernel-4.4.55.git] / fs / btrfs / scrub.c

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 79bd479317cb53cbea30a7021d81a891ed9ae20c..4ba2a69a60ad4ffc327697ec4a8db3d04159d0a8 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -2126,8 +2126,7 @@ static int scrub_find_csum(struct scrub_ctx *sctx, u64 logical, u64 len,
                           u8 *csum)
 {
        struct btrfs_ordered_sum *sum = NULL;
-       int ret = 0;
-       unsigned long i;
+       unsigned long index;
        unsigned long num_sectors;
 
        while (!list_empty(&sctx->csum_list)) {
@@ -2146,19 +2145,14 @@ static int scrub_find_csum(struct scrub_ctx *sctx, u64 logical, u64 len,
        if (!sum)
                return 0;
 
+       index = ((u32)(logical - sum->bytenr)) / sctx->sectorsize;
        num_sectors = sum->len / sctx->sectorsize;
-       for (i = 0; i < num_sectors; ++i) {
-               if (sum->sums[i].bytenr == logical) {
-                       memcpy(csum, &sum->sums[i].sum, sctx->csum_size);
-                       ret = 1;
-                       break;
-               }
-       }
-       if (ret && i == num_sectors - 1) {
+       memcpy(csum, sum->sums + index, sctx->csum_size);
+       if (index == num_sectors - 1) {
                list_del(&sum->list);
                kfree(sum);
        }
-       return ret;
+       return 1;
 }
 
 /* scrub extent tries to collect up to 64 kB for each bio */
@@ -2505,6 +2499,7 @@ again:
                        if (ret)
                                goto out;
 
+                       scrub_free_csums(sctx);
                        if (extent_logical + extent_len <
                            key.objectid + bytes) {
                                logical += increment;
@@ -3204,16 +3199,18 @@ out:
 
 static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
 {
-       unsigned long index;
        struct scrub_copy_nocow_ctx *nocow_ctx = ctx;
-       int ret = 0;
+       struct btrfs_fs_info *fs_info = nocow_ctx->sctx->dev_root->fs_info;
        struct btrfs_key key;
-       struct inode *inode = NULL;
+       struct inode *inode;
+       struct page *page;
        struct btrfs_root *local_root;
        u64 physical_for_dev_replace;
        u64 len;
-       struct btrfs_fs_info *fs_info = nocow_ctx->sctx->dev_root->fs_info;
+       unsigned long index;
        int srcu_index;
+       int ret;
+       int err;
 
        key.objectid = root;
        key.type = BTRFS_ROOT_ITEM_KEY;
@@ -3227,6 +3224,11 @@ static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
                return PTR_ERR(local_root);
        }
 
+       if (btrfs_root_refs(&local_root->root_item) == 0) {
+               srcu_read_unlock(&fs_info->subvol_srcu, srcu_index);
+               return -ENOENT;
+       }
+
        key.type = BTRFS_INODE_ITEM_KEY;
        key.objectid = inum;
        key.offset = 0;
@@ -3235,19 +3237,21 @@ static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
        if (IS_ERR(inode))
                return PTR_ERR(inode);
 
+       /* Avoid truncate/dio/punch hole.. */
+       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;
        while (len >= PAGE_CACHE_SIZE) {
-               struct page *page = NULL;
-               int ret_sub;
-
                index = offset >> PAGE_CACHE_SHIFT;
-
+again:
                page = find_or_create_page(inode->i_mapping, index, GFP_NOFS);
                if (!page) {
                        pr_err("find_or_create_page() failed\n");
                        ret = -ENOMEM;
-                       goto next_page;
+                       goto out;
                }
 
                if (PageUptodate(page)) {
@@ -3255,39 +3259,49 @@ static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
                                goto next_page;
                } else {
                        ClearPageError(page);
-                       ret_sub = extent_read_full_page(&BTRFS_I(inode)->
+                       err = extent_read_full_page(&BTRFS_I(inode)->
                                                         io_tree,
                                                        page, btrfs_get_extent,
                                                        nocow_ctx->mirror_num);
-                       if (ret_sub) {
-                               ret = ret_sub;
+                       if (err) {
+                               ret = err;
                                goto next_page;
                        }
-                       wait_on_page_locked(page);
+
+                       lock_page(page);
+                       /*
+                        * If the page has been remove from the page cache,
+                        * the data on it is meaningless, because it may be
+                        * old one, the new data may be written into the new
+                        * page in the page cache.
+                        */
+                       if (page->mapping != inode->i_mapping) {
+                               page_cache_release(page);
+                               goto again;
+                       }
                        if (!PageUptodate(page)) {
                                ret = -EIO;
                                goto next_page;
                        }
                }
-               ret_sub = write_page_nocow(nocow_ctx->sctx,
-                                          physical_for_dev_replace, page);
-               if (ret_sub) {
-                       ret = ret_sub;
-                       goto next_page;
-               }
-
+               err = write_page_nocow(nocow_ctx->sctx,
+                                      physical_for_dev_replace, page);
+               if (err)
+                       ret = err;
 next_page:
-               if (page) {
-                       unlock_page(page);
-                       put_page(page);
-               }
+               unlock_page(page);
+               page_cache_release(page);
+
+               if (ret)
+                       break;
+
                offset += PAGE_CACHE_SIZE;
                physical_for_dev_replace += PAGE_CACHE_SIZE;
                len -= PAGE_CACHE_SIZE;
        }
-
-       if (inode)
-               iput(inode);
+out:
+       mutex_unlock(&inode->i_mutex);
+       iput(inode);
        return ret;
 }