btrfs: do not double complete bio on errors during compressed reads

[platform/kernel/linux-starfive.git] / fs / btrfs / compression.c

diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 71e5b2e..be476f0 100644 (file)
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -219,7 +219,7 @@ static bool dec_and_test_compressed_bio(struct compressed_bio *cb, struct bio *b
                bi_size += bvec->bv_len;
 
        if (bio->bi_status)
-               cb->errors = 1;
+               cb->status = bio->bi_status;
 
        ASSERT(bi_size && bi_size <= cb->compressed_len);
        last_io = refcount_sub_and_test(bi_size >> fs_info->sectorsize_bits,
@@ -234,7 +234,7 @@ static bool dec_and_test_compressed_bio(struct compressed_bio *cb, struct bio *b
        return last_io;
 }
 
-static void finish_compressed_bio_read(struct compressed_bio *cb, struct bio *bio)
+static void finish_compressed_bio_read(struct compressed_bio *cb)
 {
        unsigned int index;
        struct page *page;
@@ -247,19 +247,18 @@ static void finish_compressed_bio_read(struct compressed_bio *cb, struct bio *bi
        }
 
        /* Do io completion on the original bio */
-       if (cb->errors) {
-               bio_io_error(cb->orig_bio);
+       if (cb->status != BLK_STS_OK) {
+               cb->orig_bio->bi_status = cb->status;
+               bio_endio(cb->orig_bio);
        } else {
                struct bio_vec *bvec;
                struct bvec_iter_all iter_all;
 
-               ASSERT(bio);
-               ASSERT(!bio->bi_status);
                /*
                 * We have verified the checksum already, set page checked so
                 * the end_io handlers know about it
                 */
-               ASSERT(!bio_flagged(bio, BIO_CLONED));
+               ASSERT(!bio_flagged(cb->orig_bio, BIO_CLONED));
                bio_for_each_segment_all(bvec, cb->orig_bio, iter_all) {
                        u64 bvec_start = page_offset(bvec->bv_page) +
                                         bvec->bv_offset;
@@ -308,7 +307,7 @@ static void end_compressed_bio_read(struct bio *bio)
         * Some IO in this cb have failed, just skip checksum as there
         * is no way it could be correct.
         */
-       if (cb->errors == 1)
+       if (cb->status != BLK_STS_OK)
                goto csum_failed;
 
        inode = cb->inode;
@@ -324,8 +323,8 @@ static void end_compressed_bio_read(struct bio *bio)
 
 csum_failed:
        if (ret)
-               cb->errors = 1;
-       finish_compressed_bio_read(cb, bio);
+               cb->status = errno_to_blk_status(ret);
+       finish_compressed_bio_read(cb);
 out:
        bio_put(bio);
 }
@@ -342,11 +341,12 @@ static noinline void end_compressed_writeback(struct inode *inode,
        unsigned long end_index = (cb->start + cb->len - 1) >> PAGE_SHIFT;
        struct page *pages[16];
        unsigned long nr_pages = end_index - index + 1;
+       const int errno = blk_status_to_errno(cb->status);
        int i;
        int ret;
 
-       if (cb->errors)
-               mapping_set_error(inode->i_mapping, -EIO);
+       if (errno)
+               mapping_set_error(inode->i_mapping, errno);
 
        while (nr_pages > 0) {
                ret = find_get_pages_contig(inode->i_mapping, index,
@@ -358,7 +358,7 @@ static noinline void end_compressed_writeback(struct inode *inode,
                        continue;
                }
                for (i = 0; i < ret; i++) {
-                       if (cb->errors)
+                       if (errno)
                                SetPageError(pages[i]);
                        btrfs_page_clamp_clear_writeback(fs_info, pages[i],
                                                         cb->start, cb->len);
@@ -381,9 +381,10 @@ static void finish_compressed_bio_write(struct compressed_bio *cb)
         */
        btrfs_writepage_endio_finish_ordered(BTRFS_I(inode), NULL,
                        cb->start, cb->start + cb->len - 1,
-                       !cb->errors);
+                       cb->status == BLK_STS_OK);
 
-       end_compressed_writeback(inode, cb);
+       if (cb->writeback)
+               end_compressed_writeback(inode, cb);
        /* Note, our inode could be gone now */
 
        /*
@@ -506,7 +507,8 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
                                 struct page **compressed_pages,
                                 unsigned int nr_pages,
                                 unsigned int write_flags,
-                                struct cgroup_subsys_state *blkcg_css)
+                                struct cgroup_subsys_state *blkcg_css,
+                                bool writeback)
 {
        struct btrfs_fs_info *fs_info = inode->root->fs_info;
        struct bio *bio = NULL;
@@ -524,13 +526,14 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
        if (!cb)
                return BLK_STS_RESOURCE;
        refcount_set(&cb->pending_sectors, compressed_len >> fs_info->sectorsize_bits);
-       cb->errors = 0;
+       cb->status = BLK_STS_OK;
        cb->inode = &inode->vfs_inode;
        cb->start = start;
        cb->len = len;
        cb->mirror_num = 0;
        cb->compressed_pages = compressed_pages;
        cb->compressed_len = compressed_len;
+       cb->writeback = writeback;
        cb->orig_bio = NULL;
        cb->nr_pages = nr_pages;
 
@@ -591,7 +594,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
 
                if (submit) {
                        if (!skip_sum) {
-                               ret = btrfs_csum_one_bio(inode, bio, start, 1);
+                               ret = btrfs_csum_one_bio(inode, bio, start, true);
                                if (ret)
                                        goto finish_cb;
                        }
@@ -808,7 +811,7 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
        u64 em_len;
        u64 em_start;
        struct extent_map *em;
-       blk_status_t ret = BLK_STS_RESOURCE;
+       blk_status_t ret;
        int faili = 0;
        u8 *sums;
 
@@ -821,17 +824,21 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
        read_lock(&em_tree->lock);
        em = lookup_extent_mapping(em_tree, file_offset, fs_info->sectorsize);
        read_unlock(&em_tree->lock);
-       if (!em)
-               return BLK_STS_IOERR;
+       if (!em) {
+               ret = BLK_STS_IOERR;
+               goto out;
+       }
 
        ASSERT(em->compress_type != BTRFS_COMPRESS_NONE);
        compressed_len = em->block_len;
        cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
-       if (!cb)
+       if (!cb) {
+               ret = BLK_STS_RESOURCE;
                goto out;
+       }
 
        refcount_set(&cb->pending_sectors, compressed_len >> fs_info->sectorsize_bits);
-       cb->errors = 0;
+       cb->status = BLK_STS_OK;
        cb->inode = inode;
        cb->mirror_num = mirror_num;
        sums = cb->sums;
@@ -851,8 +858,10 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
        nr_pages = DIV_ROUND_UP(compressed_len, PAGE_SIZE);
        cb->compressed_pages = kcalloc(nr_pages, sizeof(struct page *),
                                       GFP_NOFS);
-       if (!cb->compressed_pages)
+       if (!cb->compressed_pages) {
+               ret = BLK_STS_RESOURCE;
                goto fail1;
+       }
 
        for (pg_index = 0; pg_index < nr_pages; pg_index++) {
                cb->compressed_pages[pg_index] = alloc_page(GFP_NOFS);
@@ -938,7 +947,7 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                        comp_bio = NULL;
                }
        }
-       return 0;
+       return BLK_STS_OK;
 
 fail2:
        while (faili >= 0) {
@@ -951,6 +960,8 @@ fail1:
        kfree(cb);
 out:
        free_extent_map(em);
+       bio->bi_status = ret;
+       bio_endio(bio);
        return ret;
 finish_cb:
        if (comp_bio) {
@@ -970,7 +981,7 @@ finish_cb:
         */
        ASSERT(refcount_read(&cb->pending_sectors));
        /* Now we are the only one referring @cb, can finish it safely. */
-       finish_compressed_bio_read(cb, NULL);
+       finish_compressed_bio_read(cb);
        return ret;
 }