btrfs: rename struct btrfs_io_bio to btrfs_bio

Previously we had "struct btrfs_bio", which records IO context for
mirrored IO and RAID56, and "strcut btrfs_io_bio", which records extra
btrfs specific info for logical bytenr bio.

With "btrfs_bio" renamed to "btrfs_io_context", we are safe to rename
"btrfs_io_bio" to "btrfs_bio" which is a more suitable name now.

The struct btrfs_bio changes meaning by this commit. There was a
suggested name like btrfs_logical_bio but it's a bit long and we'd
prefer to use a shorter name.

This could be a concern for backports to older kernels where the
different meaning could possibly cause confusion or bugs. Comparing the
new and old structures, there's no overlap among the struct members so a
build would break in case of incorrect backport.

We haven't had many backports to bio code anyway so this is more of a
theoretical cause of bugs and a matter of precaution but we'll need to
keep the semantic change in mind.

Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 81b11124b67a873a40f1297b871f2e3050f99851..ed646f2b46f4e6777cc73d273e828d7a9712e9ed 100644 (file)
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -1561,7 +1561,7 @@ static int btrfsic_read_block(struct btrfsic_state *state,
                struct bio *bio;
                unsigned int j;
 
-               bio = btrfs_io_bio_alloc(num_pages - i);
+               bio = btrfs_bio_alloc(num_pages - i);
                bio_set_dev(bio, block_ctx->dev->bdev);
                bio->bi_iter.bi_sector = dev_bytenr >> 9;
                bio->bi_opf = REQ_OP_READ;

diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 4625a3737a6cef06042f8bc71a1b184ffda03ad4..2a86a2a1494b303b432f80ecbea2761362205ec3 100644 (file)
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -179,9 +179,9 @@ static int check_compressed_csum(struct btrfs_inode *inode, struct bio *bio,
                        if (memcmp(&csum, cb_sum, csum_size) != 0) {
                                btrfs_print_data_csum_error(inode, disk_start,
                                                csum, cb_sum, cb->mirror_num);
-                               if (btrfs_io_bio(bio)->device)
+                               if (btrfs_bio(bio)->device)
                                        btrfs_dev_stat_inc_and_print(
-                                               btrfs_io_bio(bio)->device,
+                                               btrfs_bio(bio)->device,
                                                BTRFS_DEV_STAT_CORRUPTION_ERRS);
                                return -EIO;
                        }
@@ -208,7 +208,7 @@ static void end_compressed_bio_read(struct bio *bio)
        struct inode *inode;
        struct page *page;
        unsigned int index;
-       unsigned int mirror = btrfs_io_bio(bio)->mirror_num;
+       unsigned int mirror = btrfs_bio(bio)->mirror_num;
        int ret = 0;
 
        if (bio->bi_status)
@@ -224,7 +224,7 @@ static void end_compressed_bio_read(struct bio *bio)
         * Record the correct mirror_num in cb->orig_bio so that
         * read-repair can work properly.
         */
-       btrfs_io_bio(cb->orig_bio)->mirror_num = mirror;
+       btrfs_bio(cb->orig_bio)->mirror_num = mirror;
        cb->mirror_num = mirror;
 
        /*
@@ -418,7 +418,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
        cb->orig_bio = NULL;
        cb->nr_pages = nr_pages;
 
-       bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+       bio = btrfs_bio_alloc(BIO_MAX_VECS);
        bio->bi_iter.bi_sector = first_byte >> SECTOR_SHIFT;
        bio->bi_opf = bio_op | write_flags;
        bio->bi_private = cb;
@@ -491,7 +491,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
                                bio_endio(bio);
                        }
 
-                       bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+                       bio = btrfs_bio_alloc(BIO_MAX_VECS);
                        bio->bi_iter.bi_sector = first_byte >> SECTOR_SHIFT;
                        bio->bi_opf = bio_op | write_flags;
                        bio->bi_private = cb;
@@ -750,7 +750,7 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
        /* include any pages we added in add_ra-bio_pages */
        cb->len = bio->bi_iter.bi_size;
 
-       comp_bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+       comp_bio = btrfs_bio_alloc(BIO_MAX_VECS);
        comp_bio->bi_iter.bi_sector = cur_disk_byte >> SECTOR_SHIFT;
        comp_bio->bi_opf = REQ_OP_READ;
        comp_bio->bi_private = cb;
@@ -809,7 +809,7 @@ blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                                bio_endio(comp_bio);
                        }
 
-                       comp_bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+                       comp_bio = btrfs_bio_alloc(BIO_MAX_VECS);
                        comp_bio->bi_iter.bi_sector = cur_disk_byte >> SECTOR_SHIFT;
                        comp_bio->bi_opf = REQ_OP_READ;
                        comp_bio->bi_private = cb;

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 41f1718a83df922d4e7241276ca0af5888de3d7d..b394ba4737e41a4cd5c2d87c3f3c03871860bc28 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -48,6 +48,7 @@ extern struct kmem_cache *btrfs_free_space_cachep;
 extern struct kmem_cache *btrfs_free_space_bitmap_cachep;
 struct btrfs_ordered_sum;
 struct btrfs_ref;
+struct btrfs_bio;
 
 #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
 
@@ -3140,8 +3141,9 @@ u64 btrfs_file_extent_end(const struct btrfs_path *path);
 /* inode.c */
 blk_status_t btrfs_submit_data_bio(struct inode *inode, struct bio *bio,
                                   int mirror_num, unsigned long bio_flags);
-unsigned int btrfs_verify_data_csum(struct btrfs_io_bio *io_bio, u32 bio_offset,
-                                   struct page *page, u64 start, u64 end);
+unsigned int btrfs_verify_data_csum(struct btrfs_bio *bbio,
+                                   u32 bio_offset, struct page *page,
+                                   u64 start, u64 end);
 struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
                                           u64 start, u64 len);
 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index be382276d24f321cfb9aeb7684f9f3abfc72b272..b28638c7941365c0346024163eddfec77af5f069 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -683,7 +683,7 @@ err:
        return ret;
 }
 
-int btrfs_validate_metadata_buffer(struct btrfs_io_bio *io_bio,
+int btrfs_validate_metadata_buffer(struct btrfs_bio *bbio,
                                   struct page *page, u64 start, u64 end,
                                   int mirror)
 {

diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index 0e7e9526b6a8350927afed7f348f128d521f7d93..1d3b749c405a891ec5da46708e5864d8e4855062 100644 (file)
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -81,7 +81,7 @@ void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info);
 void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info);
 void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
                                 struct btrfs_root *root);
-int btrfs_validate_metadata_buffer(struct btrfs_io_bio *io_bio,
+int btrfs_validate_metadata_buffer(struct btrfs_bio *bbio,
                                   struct page *page, u64 start, u64 end,
                                   int mirror);
 blk_status_t btrfs_submit_metadata_bio(struct inode *inode, struct bio *bio,

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 55a04790df1c05165e4b6c22eb06e69addf85f4c..c56973f7daae5b449796e9dc9495b827807aa857 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -241,7 +241,7 @@ int __init extent_io_init(void)
                return -ENOMEM;
 
        if (bioset_init(&btrfs_bioset, BIO_POOL_SIZE,
-                       offsetof(struct btrfs_io_bio, bio),
+                       offsetof(struct btrfs_bio, bio),
                        BIOSET_NEED_BVECS))
                goto free_buffer_cache;
 
@@ -2299,7 +2299,7 @@ static int repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start,
        if (btrfs_is_zoned(fs_info))
                return btrfs_repair_one_zone(fs_info, logical);
 
-       bio = btrfs_io_bio_alloc(1);
+       bio = btrfs_bio_alloc(1);
        bio->bi_iter.bi_size = 0;
        map_length = length;
 
@@ -2618,10 +2618,10 @@ int btrfs_repair_one_sector(struct inode *inode,
        struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
        struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
        struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
-       struct btrfs_io_bio *failed_io_bio = btrfs_io_bio(failed_bio);
+       struct btrfs_bio *failed_bbio = btrfs_bio(failed_bio);
        const int icsum = bio_offset >> fs_info->sectorsize_bits;
        struct bio *repair_bio;
-       struct btrfs_io_bio *repair_io_bio;
+       struct btrfs_bio *repair_bbio;
        blk_status_t status;
 
        btrfs_debug(fs_info,
@@ -2639,24 +2639,24 @@ int btrfs_repair_one_sector(struct inode *inode,
                return -EIO;
        }
 
-       repair_bio = btrfs_io_bio_alloc(1);
-       repair_io_bio = btrfs_io_bio(repair_bio);
+       repair_bio = btrfs_bio_alloc(1);
+       repair_bbio = btrfs_bio(repair_bio);
        repair_bio->bi_opf = REQ_OP_READ;
        repair_bio->bi_end_io = failed_bio->bi_end_io;
        repair_bio->bi_iter.bi_sector = failrec->logical >> 9;
        repair_bio->bi_private = failed_bio->bi_private;
 
-       if (failed_io_bio->csum) {
+       if (failed_bbio->csum) {
                const u32 csum_size = fs_info->csum_size;
 
-               repair_io_bio->csum = repair_io_bio->csum_inline;
-               memcpy(repair_io_bio->csum,
-                      failed_io_bio->csum + csum_size * icsum, csum_size);
+               repair_bbio->csum = repair_bbio->csum_inline;
+               memcpy(repair_bbio->csum,
+                      failed_bbio->csum + csum_size * icsum, csum_size);
        }
 
        bio_add_page(repair_bio, page, failrec->len, pgoff);
-       repair_io_bio->logical = failrec->start;
-       repair_io_bio->iter = repair_bio->bi_iter;
+       repair_bbio->logical = failrec->start;
+       repair_bbio->iter = repair_bio->bi_iter;
 
        btrfs_debug(btrfs_sb(inode->i_sb),
                    "repair read error: submitting new read to mirror %d",
@@ -2976,7 +2976,7 @@ static struct extent_buffer *find_extent_buffer_readpage(
 static void end_bio_extent_readpage(struct bio *bio)
 {
        struct bio_vec *bvec;
-       struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
+       struct btrfs_bio *bbio = btrfs_bio(bio);
        struct extent_io_tree *tree, *failure_tree;
        struct processed_extent processed = { 0 };
        /*
@@ -3003,7 +3003,7 @@ static void end_bio_extent_readpage(struct bio *bio)
                btrfs_debug(fs_info,
                        "end_bio_extent_readpage: bi_sector=%llu, err=%d, mirror=%u",
                        bio->bi_iter.bi_sector, bio->bi_status,
-                       io_bio->mirror_num);
+                       bbio->mirror_num);
                tree = &BTRFS_I(inode)->io_tree;
                failure_tree = &BTRFS_I(inode)->io_failure_tree;
 
@@ -3028,14 +3028,14 @@ static void end_bio_extent_readpage(struct bio *bio)
                end = start + bvec->bv_len - 1;
                len = bvec->bv_len;
 
-               mirror = io_bio->mirror_num;
+               mirror = bbio->mirror_num;
                if (likely(uptodate)) {
                        if (is_data_inode(inode)) {
-                               error_bitmap = btrfs_verify_data_csum(io_bio,
+                               error_bitmap = btrfs_verify_data_csum(bbio,
                                                bio_offset, page, start, end);
                                ret = error_bitmap;
                        } else {
-                               ret = btrfs_validate_metadata_buffer(io_bio,
+                               ret = btrfs_validate_metadata_buffer(bbio,
                                        page, start, end, mirror);
                        }
                        if (ret)
@@ -3106,7 +3106,7 @@ readpage_ok:
        }
        /* Release the last extent */
        endio_readpage_release_extent(&processed, NULL, 0, 0, false);
-       btrfs_io_bio_free_csum(io_bio);
+       btrfs_bio_free_csum(bbio);
        bio_put(bio);
 }
 
@@ -3115,9 +3115,9 @@ readpage_ok:
  * new bio by bio_alloc_bioset as it does not initialize the bytes outside of
  * 'bio' because use of __GFP_ZERO is not supported.
  */
-static inline void btrfs_io_bio_init(struct btrfs_io_bio *btrfs_bio)
+static inline void btrfs_bio_init(struct btrfs_bio *bbio)
 {
-       memset(btrfs_bio, 0, offsetof(struct btrfs_io_bio, bio));
+       memset(bbio, 0, offsetof(struct btrfs_bio, bio));
 }
 
 /*
@@ -3125,33 +3125,33 @@ static inline void btrfs_io_bio_init(struct btrfs_io_bio *btrfs_bio)
  *
  * The bio allocation is backed by bioset and does not fail.
  */
-struct bio *btrfs_io_bio_alloc(unsigned int nr_iovecs)
+struct bio *btrfs_bio_alloc(unsigned int nr_iovecs)
 {
        struct bio *bio;
 
        ASSERT(0 < nr_iovecs && nr_iovecs <= BIO_MAX_VECS);
        bio = bio_alloc_bioset(GFP_NOFS, nr_iovecs, &btrfs_bioset);
-       btrfs_io_bio_init(btrfs_io_bio(bio));
+       btrfs_bio_init(btrfs_bio(bio));
        return bio;
 }
 
 struct bio *btrfs_bio_clone(struct bio *bio)
 {
-       struct btrfs_io_bio *btrfs_bio;
+       struct btrfs_bio *bbio;
        struct bio *new;
 
        /* Bio allocation backed by a bioset does not fail */
        new = bio_clone_fast(bio, GFP_NOFS, &btrfs_bioset);
-       btrfs_bio = btrfs_io_bio(new);
-       btrfs_io_bio_init(btrfs_bio);
-       btrfs_bio->iter = bio->bi_iter;
+       bbio = btrfs_bio(new);
+       btrfs_bio_init(bbio);
+       bbio->iter = bio->bi_iter;
        return new;
 }
 
 struct bio *btrfs_bio_clone_partial(struct bio *orig, u64 offset, u64 size)
 {
        struct bio *bio;
-       struct btrfs_io_bio *btrfs_bio;
+       struct btrfs_bio *bbio;
 
        ASSERT(offset <= UINT_MAX && size <= UINT_MAX);
 
@@ -3159,11 +3159,11 @@ struct bio *btrfs_bio_clone_partial(struct bio *orig, u64 offset, u64 size)
        bio = bio_clone_fast(orig, GFP_NOFS, &btrfs_bioset);
        ASSERT(bio);
 
-       btrfs_bio = btrfs_io_bio(bio);
-       btrfs_io_bio_init(btrfs_bio);
+       bbio = btrfs_bio(bio);
+       btrfs_bio_init(bbio);
 
        bio_trim(bio, offset >> 9, size >> 9);
-       btrfs_bio->iter = bio->bi_iter;
+       bbio->iter = bio->bi_iter;
        return bio;
 }
 
@@ -3297,7 +3297,7 @@ static int alloc_new_bio(struct btrfs_inode *inode,
        struct bio *bio;
        int ret;
 
-       bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+       bio = btrfs_bio_alloc(BIO_MAX_VECS);
        /*
         * For compressed page range, its disk_bytenr is always @disk_bytenr
         * passed in, no matter if we have added any range into previous bio.
@@ -3332,7 +3332,7 @@ static int alloc_new_bio(struct btrfs_inode *inode,
                        goto error;
                }
 
-               btrfs_io_bio(bio)->device = device;
+               btrfs_bio(bio)->device = device;
        }
        return 0;
 error:

diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 81fa68eaa699e4d834a6d3987220f59c29b6aca3..a3ecfd4f37ac2fc9364fb86328ac19cb2c8a57e8 100644 (file)
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -278,7 +278,7 @@ void extent_range_redirty_for_io(struct inode *inode, u64 start, u64 end);
 void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end,
                                  struct page *locked_page,
                                  u32 bits_to_clear, unsigned long page_ops);
-struct bio *btrfs_io_bio_alloc(unsigned int nr_iovecs);
+struct bio *btrfs_bio_alloc(unsigned int nr_iovecs);
 struct bio *btrfs_bio_clone(struct bio *bio);
 struct bio *btrfs_bio_clone_partial(struct bio *orig, u64 offset, u64 size);
 

diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 0b9401a5afd3335e8cd108f5006284e74a81a340..ddb9c7ee796f07401d387521e0d018b4b2652e37 100644 (file)
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -358,7 +358,7 @@ static int search_file_offset_in_bio(struct bio *bio, struct inode *inode,
  * @dst: Buffer of size nblocks * btrfs_super_csum_size() used to return
  *       checksum (nblocks = bio->bi_iter.bi_size / fs_info->sectorsize). If
  *       NULL, the checksum buffer is allocated and returned in
- *       btrfs_io_bio(bio)->csum instead.
+ *       btrfs_bio(bio)->csum instead.
  *
  * Return: BLK_STS_RESOURCE if allocating memory fails, BLK_STS_OK otherwise.
  */
@@ -397,19 +397,18 @@ blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u8 *dst
                return BLK_STS_RESOURCE;
 
        if (!dst) {
-               struct btrfs_io_bio *btrfs_bio = btrfs_io_bio(bio);
+               struct btrfs_bio *bbio = btrfs_bio(bio);
 
                if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {
-                       btrfs_bio->csum = kmalloc_array(nblocks, csum_size,
-                                                       GFP_NOFS);
-                       if (!btrfs_bio->csum) {
+                       bbio->csum = kmalloc_array(nblocks, csum_size, GFP_NOFS);
+                       if (!bbio->csum) {
                                btrfs_free_path(path);
                                return BLK_STS_RESOURCE;
                        }
                } else {
-                       btrfs_bio->csum = btrfs_bio->csum_inline;
+                       bbio->csum = bbio->csum_inline;
                }
-               csum = btrfs_bio->csum;
+               csum = bbio->csum;
        } else {
                csum = dst;
        }

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 027f2ebc8dc31e924cda073f0c0845552c7716f7..a643be30c18a8858fa6444f9765f0938d90fa0df 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3217,7 +3217,7 @@ void btrfs_writepage_endio_finish_ordered(struct btrfs_inode *inode,
  *
  * The length of such check is always one sector size.
  */
-static int check_data_csum(struct inode *inode, struct btrfs_io_bio *io_bio,
+static int check_data_csum(struct inode *inode, struct btrfs_bio *bbio,
                           u32 bio_offset, struct page *page, u32 pgoff,
                           u64 start)
 {
@@ -3233,7 +3233,7 @@ static int check_data_csum(struct inode *inode, struct btrfs_io_bio *io_bio,
        ASSERT(pgoff + len <= PAGE_SIZE);
 
        offset_sectors = bio_offset >> fs_info->sectorsize_bits;
-       csum_expected = ((u8 *)io_bio->csum) + offset_sectors * csum_size;
+       csum_expected = ((u8 *)bbio->csum) + offset_sectors * csum_size;
 
        kaddr = kmap_atomic(page);
        shash->tfm = fs_info->csum_shash;
@@ -3247,9 +3247,9 @@ static int check_data_csum(struct inode *inode, struct btrfs_io_bio *io_bio,
        return 0;
 zeroit:
        btrfs_print_data_csum_error(BTRFS_I(inode), start, csum, csum_expected,
-                                   io_bio->mirror_num);
-       if (io_bio->device)
-               btrfs_dev_stat_inc_and_print(io_bio->device,
+                                   bbio->mirror_num);
+       if (bbio->device)
+               btrfs_dev_stat_inc_and_print(bbio->device,
                                             BTRFS_DEV_STAT_CORRUPTION_ERRS);
        memset(kaddr + pgoff, 1, len);
        flush_dcache_page(page);
@@ -3269,8 +3269,9 @@ zeroit:
  * Return a bitmap where bit set means a csum mismatch, and bit not set means
  * csum match.
  */
-unsigned int btrfs_verify_data_csum(struct btrfs_io_bio *io_bio, u32 bio_offset,
-                                   struct page *page, u64 start, u64 end)
+unsigned int btrfs_verify_data_csum(struct btrfs_bio *bbio,
+                                   u32 bio_offset, struct page *page,
+                                   u64 start, u64 end)
 {
        struct inode *inode = page->mapping->host;
        struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
@@ -3288,14 +3289,14 @@ unsigned int btrfs_verify_data_csum(struct btrfs_io_bio *io_bio, u32 bio_offset,
         * For subpage case, above PageChecked is not safe as it's not subpage
         * compatible.
         * But for now only cow fixup and compressed read utilize PageChecked
-        * flag, while in this context we can easily use io_bio->csum to
+        * flag, while in this context we can easily use bbio->csum to
         * determine if we really need to do csum verification.
         *
-        * So for now, just exit if io_bio->csum is NULL, as it means it's
+        * So for now, just exit if bbio->csum is NULL, as it means it's
         * compressed read, and its compressed data csum has already been
         * verified.
         */
-       if (io_bio->csum == NULL)
+       if (bbio->csum == NULL)
                return 0;
 
        if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
@@ -3322,7 +3323,7 @@ unsigned int btrfs_verify_data_csum(struct btrfs_io_bio *io_bio, u32 bio_offset,
                                          EXTENT_NODATASUM);
                        continue;
                }
-               ret = check_data_csum(inode, io_bio, bio_offset, page, pg_off,
+               ret = check_data_csum(inode, bbio, bio_offset, page, pg_off,
                                      page_offset(page) + pg_off);
                if (ret < 0) {
                        const int nr_bit = (pg_off - offset_in_page(start)) >>
@@ -8082,7 +8083,7 @@ static blk_status_t submit_dio_repair_bio(struct inode *inode, struct bio *bio,
 }
 
 static blk_status_t btrfs_check_read_dio_bio(struct inode *inode,
-                                            struct btrfs_io_bio *io_bio,
+                                            struct btrfs_bio *bbio,
                                             const bool uptodate)
 {
        struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
@@ -8092,11 +8093,11 @@ static blk_status_t btrfs_check_read_dio_bio(struct inode *inode,
        const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);
        struct bio_vec bvec;
        struct bvec_iter iter;
-       u64 start = io_bio->logical;
+       u64 start = bbio->logical;
        u32 bio_offset = 0;
        blk_status_t err = BLK_STS_OK;
 
-       __bio_for_each_segment(bvec, &io_bio->bio, iter, io_bio->iter) {
+       __bio_for_each_segment(bvec, &bbio->bio, iter, bbio->iter) {
                unsigned int i, nr_sectors, pgoff;
 
                nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, bvec.bv_len);
@@ -8104,7 +8105,7 @@ static blk_status_t btrfs_check_read_dio_bio(struct inode *inode,
                for (i = 0; i < nr_sectors; i++) {
                        ASSERT(pgoff < PAGE_SIZE);
                        if (uptodate &&
-                           (!csum || !check_data_csum(inode, io_bio,
+                           (!csum || !check_data_csum(inode, bbio,
                                                       bio_offset, bvec.bv_page,
                                                       pgoff, start))) {
                                clean_io_failure(fs_info, failure_tree, io_tree,
@@ -8114,12 +8115,12 @@ static blk_status_t btrfs_check_read_dio_bio(struct inode *inode,
                        } else {
                                int ret;
 
-                               ASSERT((start - io_bio->logical) < UINT_MAX);
+                               ASSERT((start - bbio->logical) < UINT_MAX);
                                ret = btrfs_repair_one_sector(inode,
-                                               &io_bio->bio,
-                                               start - io_bio->logical,
+                                               &bbio->bio,
+                                               start - bbio->logical,
                                                bvec.bv_page, pgoff,
-                                               start, io_bio->mirror_num,
+                                               start, bbio->mirror_num,
                                                submit_dio_repair_bio);
                                if (ret)
                                        err = errno_to_blk_status(ret);
@@ -8161,8 +8162,8 @@ static void btrfs_end_dio_bio(struct bio *bio)
                           bio->bi_iter.bi_size, err);
 
        if (bio_op(bio) == REQ_OP_READ) {
-               err = btrfs_check_read_dio_bio(dip->inode, btrfs_io_bio(bio),
-                                              !err);
+               err = btrfs_check_read_dio_bio(dip->inode,
+                                              btrfs_bio(bio), !err);
        }
 
        if (err)
@@ -8213,7 +8214,7 @@ static inline blk_status_t btrfs_submit_dio_bio(struct bio *bio,
                csum_offset = file_offset - dip->logical_offset;
                csum_offset >>= fs_info->sectorsize_bits;
                csum_offset *= fs_info->csum_size;
-               btrfs_io_bio(bio)->csum = dip->csums + csum_offset;
+               btrfs_bio(bio)->csum = dip->csums + csum_offset;
        }
 map:
        ret = btrfs_map_bio(fs_info, bio, 0);
@@ -8329,7 +8330,7 @@ static blk_qc_t btrfs_submit_direct(const struct iomap_iter *iter,
                bio = btrfs_bio_clone_partial(dio_bio, clone_offset, clone_len);
                bio->bi_private = dip;
                bio->bi_end_io = btrfs_end_dio_bio;
-               btrfs_io_bio(bio)->logical = file_offset;
+               btrfs_bio(bio)->logical = file_offset;
 
                if (bio_op(bio) == REQ_OP_ZONE_APPEND) {
                        status = extract_ordered_extent(BTRFS_I(inode), bio,

diff --git a/fs/btrfs/raid56.c b/fs/btrfs/raid56.c
index 893d93e3c516da672c83030012fdfd829e75d8a5..02aa3fbb8108f4fdea57a463e80356f3a4861000 100644 (file)
--- a/fs/btrfs/raid56.c
+++ b/fs/btrfs/raid56.c
@@ -1104,8 +1104,8 @@ static int rbio_add_io_page(struct btrfs_raid_bio *rbio,
        }
 
        /* put a new bio on the list */
-       bio = btrfs_io_bio_alloc(bio_max_len >> PAGE_SHIFT ?: 1);
-       btrfs_io_bio(bio)->device = stripe->dev;
+       bio = btrfs_bio_alloc(bio_max_len >> PAGE_SHIFT ?: 1);
+       btrfs_bio(bio)->device = stripe->dev;
        bio->bi_iter.bi_size = 0;
        bio_set_dev(bio, stripe->dev->bdev);
        bio->bi_iter.bi_sector = disk_start >> 9;
@@ -1158,7 +1158,7 @@ static void index_rbio_pages(struct btrfs_raid_bio *rbio)
                page_index = stripe_offset >> PAGE_SHIFT;
 
                if (bio_flagged(bio, BIO_CLONED))
-                       bio->bi_iter = btrfs_io_bio(bio)->iter;
+                       bio->bi_iter = btrfs_bio(bio)->iter;
 
                bio_for_each_segment(bvec, bio, iter) {
                        rbio->bio_pages[page_index + i] = bvec.bv_page;
@@ -2124,7 +2124,7 @@ int raid56_parity_recover(struct btrfs_fs_info *fs_info, struct bio *bio,
 
        if (generic_io) {
                ASSERT(bioc->mirror_num == mirror_num);
-               btrfs_io_bio(bio)->mirror_num = mirror_num;
+               btrfs_bio(bio)->mirror_num = mirror_num;
        }
 
        rbio = alloc_rbio(fs_info, bioc, stripe_len);

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 1a9d485f80568bebf4f086ced0be1cc87ba1b115..c8658546607f8f838585748711a6ca84326e7c47 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -1422,7 +1422,7 @@ static void scrub_recheck_block_on_raid56(struct btrfs_fs_info *fs_info,
        if (!first_page->dev->bdev)
                goto out;
 
-       bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+       bio = btrfs_bio_alloc(BIO_MAX_VECS);
        bio_set_dev(bio, first_page->dev->bdev);
 
        for (page_num = 0; page_num < sblock->page_count; page_num++) {
@@ -1479,7 +1479,7 @@ static void scrub_recheck_block(struct btrfs_fs_info *fs_info,
                }
 
                WARN_ON(!spage->page);
-               bio = btrfs_io_bio_alloc(1);
+               bio = btrfs_bio_alloc(1);
                bio_set_dev(bio, spage->dev->bdev);
 
                bio_add_page(bio, spage->page, fs_info->sectorsize, 0);
@@ -1561,7 +1561,7 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
                        return -EIO;
                }
 
-               bio = btrfs_io_bio_alloc(1);
+               bio = btrfs_bio_alloc(1);
                bio_set_dev(bio, spage_bad->dev->bdev);
                bio->bi_iter.bi_sector = spage_bad->physical >> 9;
                bio->bi_opf = REQ_OP_WRITE;
@@ -1675,7 +1675,7 @@ again:
                sbio->dev = sctx->wr_tgtdev;
                bio = sbio->bio;
                if (!bio) {
-                       bio = btrfs_io_bio_alloc(sctx->pages_per_wr_bio);
+                       bio = btrfs_bio_alloc(sctx->pages_per_wr_bio);
                        sbio->bio = bio;
                }
 
@@ -2101,7 +2101,7 @@ again:
                sbio->dev = spage->dev;
                bio = sbio->bio;
                if (!bio) {
-                       bio = btrfs_io_bio_alloc(sctx->pages_per_rd_bio);
+                       bio = btrfs_bio_alloc(sctx->pages_per_rd_bio);
                        sbio->bio = bio;
                }
 
@@ -2225,7 +2225,7 @@ static void scrub_missing_raid56_pages(struct scrub_block *sblock)
                goto bioc_out;
        }
 
-       bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+       bio = btrfs_bio_alloc(BIO_MAX_VECS);
        bio->bi_iter.bi_sector = logical >> 9;
        bio->bi_private = sblock;
        bio->bi_end_io = scrub_missing_raid56_end_io;
@@ -2841,7 +2841,7 @@ static void scrub_parity_check_and_repair(struct scrub_parity *sparity)
        if (ret || !bioc || !bioc->raid_map)
                goto bioc_out;
 
-       bio = btrfs_io_bio_alloc(BIO_MAX_VECS);
+       bio = btrfs_bio_alloc(BIO_MAX_VECS);
        bio->bi_iter.bi_sector = sparity->logic_start >> 9;
        bio->bi_private = sparity;
        bio->bi_end_io = scrub_parity_bio_endio;

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 627505500467c8ded7645e76a86b9f7b6a2fb7b6..ccc4718ae8a39b44069a82bf761a408b181df6d1 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -6573,7 +6573,7 @@ static void btrfs_end_bio(struct bio *bio)
                atomic_inc(&bioc->error);
                if (bio->bi_status == BLK_STS_IOERR ||
                    bio->bi_status == BLK_STS_TARGET) {
-                       struct btrfs_device *dev = btrfs_io_bio(bio)->device;
+                       struct btrfs_device *dev = btrfs_bio(bio)->device;
 
                        ASSERT(dev->bdev);
                        if (btrfs_op(bio) == BTRFS_MAP_WRITE)
@@ -6599,7 +6599,7 @@ static void btrfs_end_bio(struct bio *bio)
                        bio = bioc->orig_bio;
                }
 
-               btrfs_io_bio(bio)->mirror_num = bioc->mirror_num;
+               btrfs_bio(bio)->mirror_num = bioc->mirror_num;
                /* only send an error to the higher layers if it is
                 * beyond the tolerance of the btrfs bio
                 */
@@ -6625,7 +6625,7 @@ static void submit_stripe_bio(struct btrfs_io_context *bioc, struct bio *bio,
        struct btrfs_fs_info *fs_info = bioc->fs_info;
 
        bio->bi_private = bioc;
-       btrfs_io_bio(bio)->device = dev;
+       btrfs_bio(bio)->device = dev;
        bio->bi_end_io = btrfs_end_bio;
        bio->bi_iter.bi_sector = physical >> 9;
        /*
@@ -6661,7 +6661,7 @@ static void bioc_error(struct btrfs_io_context *bioc, struct bio *bio, u64 logic
                /* Should be the original bio. */
                WARN_ON(bio != bioc->orig_bio);
 
-               btrfs_io_bio(bio)->mirror_num = bioc->mirror_num;
+               btrfs_bio(bio)->mirror_num = bioc->mirror_num;
                bio->bi_iter.bi_sector = logical >> 9;
                if (atomic_read(&bioc->error) > bioc->max_errors)
                        bio->bi_status = BLK_STS_IOERR;

diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index b69755fc0e0d45c4a0989c31127774e690dba852..83075d6855dba72ab588c5d6738226e1aa5502f2 100644 (file)
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -304,38 +304,37 @@ struct btrfs_fs_devices {
                                / sizeof(struct btrfs_stripe) + 1)
 
 /*
- * we need the mirror number and stripe index to be passed around
- * the call chain while we are processing end_io (especially errors).
- * Really, what we need is a btrfs_io_context structure that has this info
- * and is properly sized with its stripe array, but we're not there
- * quite yet.  We have our own btrfs bioset, and all of the bios
- * we allocate are actually btrfs_io_bios.  We'll cram as much of
- * struct btrfs_io_context as we can into this over time.
+ * Additional info to pass along bio.
+ *
+ * Mostly for btrfs specific features like csum and mirror_num.
  */
-struct btrfs_io_bio {
+struct btrfs_bio {
        unsigned int mirror_num;
+
+       /* @device is for stripe IO submission. */
        struct btrfs_device *device;
        u64 logical;
        u8 *csum;
        u8 csum_inline[BTRFS_BIO_INLINE_CSUM_SIZE];
        struct bvec_iter iter;
+
        /*
         * This member must come last, bio_alloc_bioset will allocate enough
-        * bytes for entire btrfs_io_bio but relies on bio being last.
+        * bytes for entire btrfs_bio but relies on bio being last.
         */
        struct bio bio;
 };
 
-static inline struct btrfs_io_bio *btrfs_io_bio(struct bio *bio)
+static inline struct btrfs_bio *btrfs_bio(struct bio *bio)
 {
-       return container_of(bio, struct btrfs_io_bio, bio);
+       return container_of(bio, struct btrfs_bio, bio);
 }
 
-static inline void btrfs_io_bio_free_csum(struct btrfs_io_bio *io_bio)
+static inline void btrfs_bio_free_csum(struct btrfs_bio *bbio)
 {
-       if (io_bio->csum != io_bio->csum_inline) {
-               kfree(io_bio->csum);
-               io_bio->csum = NULL;
+       if (bbio->csum != bbio->csum_inline) {
+               kfree(bbio->csum);
+               bbio->csum = NULL;
        }
 }