btrfs: simplify the btrfs_csum_one_bio calling convention

To prepare for further bio submission changes btrfs_csum_one_bio
should be able to take all it's arguments from the btrfs_bio structure.
It can always use the bbio->inode already, and once the compression code
is updated to set ->file_offset that one can be used unconditionally
as well instead of looking at the page mapping now that btrfs doesn't
allow ordered extents to span discontiguous data ranges.

The only slightly tricky bit is the one_ordered flag set by the
compressed writes.  Replace that one with the driver private bio
flag, which gets cleared before the bio is handed off to the block layer
so that we don't get in the way of driver use.

Note: this leaves an argument and a flag to btrfs_wq_submit_bio unused.
But that whole mechanism will be removed in its current form in the
next patch.

Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/bio.c b/fs/btrfs/bio.c
index d75c118084821f9f4e4e9da3c99811b360424b45..6af0a788c5421e99c881a4c2b80e83a4a4bfce30 100644 (file)
--- a/fs/btrfs/bio.c
+++ b/fs/btrfs/bio.c
@@ -438,6 +438,9 @@ void btrfs_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio, int mirror
                        goto fail;
        }
 
+       /* Do not leak our private flag into the block layer. */
+       bio->bi_opf &= ~REQ_BTRFS_ONE_ORDERED;
+
        if (!bioc) {
                /* Single mirror read/write fast path */
                bbio->mirror_num = mirror_num;

diff --git a/fs/btrfs/bio.h b/fs/btrfs/bio.h
index a96bcb3f36f684e49d7c1c8aaa33fbc19302b444..4142004ce053a130c86fdc55a06d45251f066203 100644 (file)
--- a/fs/btrfs/bio.h
+++ b/fs/btrfs/bio.h
@@ -86,6 +86,9 @@ static inline void btrfs_bio_end_io(struct btrfs_bio *bbio, blk_status_t status)
        bbio->end_io(bbio);
 }
 
+/* Bio only refers to one ordered extent. */
+#define REQ_BTRFS_ONE_ORDERED                  REQ_DRV
+
 void btrfs_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio,
                      int mirror_num);
 int btrfs_repair_io_failure(struct btrfs_fs_info *fs_info, u64 ino, u64 start,

diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 9c2d3f5b4028acad60dd249764223ccf6d18ec08..7999c28aa5e129eec3103aeaa192a4cf7b587acd 100644 (file)
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -357,7 +357,8 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
        blk_status_t ret = BLK_STS_OK;
        int skip_sum = inode->flags & BTRFS_INODE_NODATASUM;
        const bool use_append = btrfs_use_zone_append(inode, disk_start);
-       const enum req_op bio_op = use_append ? REQ_OP_ZONE_APPEND : REQ_OP_WRITE;
+       const enum req_op bio_op = REQ_BTRFS_ONE_ORDERED |
+                                  (use_append ? REQ_OP_ZONE_APPEND : REQ_OP_WRITE);
 
        ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
               IS_ALIGNED(len, fs_info->sectorsize));
@@ -395,6 +396,7 @@ blk_status_t btrfs_submit_compressed_write(struct btrfs_inode *inode, u64 start,
                                ret = errno_to_blk_status(PTR_ERR(bio));
                                break;
                        }
+                       btrfs_bio(bio)->file_offset = start;
                        if (blkcg_css)
                                bio->bi_opf |= REQ_CGROUP_PUNT;
                }
@@ -436,7 +438,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, true);
+                               ret = btrfs_csum_one_bio(btrfs_bio(bio));
                                if (ret) {
                                        btrfs_bio_end_io(btrfs_bio(bio), ret);
                                        break;

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 764ee9338637e61efdeefc5cdfdf79b6e70b355f..0270226389a7b3399c317576c482590d45d4de4c 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -730,11 +730,8 @@ static void run_one_async_start(struct btrfs_work *work)
                ret = btree_csum_one_bio(async->bio);
                break;
        case WQ_SUBMIT_DATA:
-               ret = btrfs_csum_one_bio(async->inode, async->bio, (u64)-1, false);
-               break;
        case WQ_SUBMIT_DATA_DIO:
-               ret = btrfs_csum_one_bio(async->inode, async->bio,
-                                        async->dio_file_offset, false);
+               ret = btrfs_csum_one_bio(btrfs_bio(async->bio));
                break;
        default:
                /* Can't happen so return something that would prevent the IO. */

diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index c5324fe8f4be7a563381436003bdfdd28a98bcb6..41c77a10085357dd983f43e7929fbdae1bc96055 100644 (file)
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -772,23 +772,16 @@ fail:
 
 /*
  * Calculate checksums of the data contained inside a bio.
- *
- * @inode:      Owner of the data inside the bio
- * @bio:        Contains the data to be checksummed
- * @offset:      If (u64)-1, @bio may contain discontiguous bio vecs, so the
- *               file offsets are determined from the page offsets in the bio.
- *               Otherwise, this is the starting file offset of the bio vecs in
- *               @bio, which must be contiguous.
- * @one_ordered: If true, @bio only refers to one ordered extent.
  */
-blk_status_t btrfs_csum_one_bio(struct btrfs_inode *inode, struct bio *bio,
-                               u64 offset, bool one_ordered)
+blk_status_t btrfs_csum_one_bio(struct btrfs_bio *bbio)
 {
+       struct btrfs_inode *inode = bbio->inode;
        struct btrfs_fs_info *fs_info = inode->root->fs_info;
        SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
+       struct bio *bio = &bbio->bio;
+       u64 offset = bbio->file_offset;
        struct btrfs_ordered_sum *sums;
        struct btrfs_ordered_extent *ordered = NULL;
-       const bool use_page_offsets = (offset == (u64)-1);
        char *data;
        struct bvec_iter iter;
        struct bio_vec bvec;
@@ -816,9 +809,6 @@ blk_status_t btrfs_csum_one_bio(struct btrfs_inode *inode, struct bio *bio,
        shash->tfm = fs_info->csum_shash;
 
        bio_for_each_segment(bvec, bio, iter) {
-               if (use_page_offsets)
-                       offset = page_offset(bvec.bv_page) + bvec.bv_offset;
-
                if (!ordered) {
                        ordered = btrfs_lookup_ordered_extent(inode, offset);
                        /*
@@ -840,7 +830,7 @@ blk_status_t btrfs_csum_one_bio(struct btrfs_inode *inode, struct bio *bio,
                                                 - 1);
 
                for (i = 0; i < blockcount; i++) {
-                       if (!one_ordered &&
+                       if (!(bio->bi_opf & REQ_BTRFS_ONE_ORDERED) &&
                            !in_range(offset, ordered->file_offset,
                                      ordered->num_bytes)) {
                                unsigned long bytes_left;

diff --git a/fs/btrfs/file-item.h b/fs/btrfs/file-item.h
index a2f9747adf3ac05ec9b137f1b6e4f5198f63a2c3..cd7f2ae515c0ca105a4a14c0c6266521b374020d 100644 (file)
--- a/fs/btrfs/file-item.h
+++ b/fs/btrfs/file-item.h
@@ -49,8 +49,10 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
                           struct btrfs_root *root,
                           struct btrfs_ordered_sum *sums);
-blk_status_t btrfs_csum_one_bio(struct btrfs_inode *inode, struct bio *bio,
-                               u64 offset, bool one_ordered);
+blk_status_t btrfs_csum_one_bio(struct btrfs_bio *bbio);
+int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
+                            struct list_head *list, int search_commit,
+                            bool nowait);
 int btrfs_lookup_csums_list(struct btrfs_root *root, u64 start, u64 end,
                            struct list_head *list, int search_commit,
                            bool nowait);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index cdb0f8cb0d4f22f77a4f653f6faef5374c6d2896..f542d539b831e1c3b7b6ae90a729d6a813987270 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2736,7 +2736,7 @@ void btrfs_submit_data_write_bio(struct btrfs_inode *inode, struct bio *bio, int
                    btrfs_wq_submit_bio(inode, bio, mirror_num, 0, WQ_SUBMIT_DATA))
                        return;
 
-               ret = btrfs_csum_one_bio(inode, bio, (u64)-1, false);
+               ret = btrfs_csum_one_bio(btrfs_bio(bio));
                if (ret) {
                        btrfs_bio_end_io(btrfs_bio(bio), ret);
                        return;
@@ -7863,7 +7863,7 @@ static void btrfs_submit_dio_bio(struct bio *bio, struct btrfs_inode *inode,
                 * If we aren't doing async submit, calculate the csum of the
                 * bio now.
                 */
-               ret = btrfs_csum_one_bio(inode, bio, file_offset, false);
+               ret = btrfs_csum_one_bio(btrfs_bio(bio));
                if (ret) {
                        btrfs_bio_end_io(btrfs_bio(bio), ret);
                        return;