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 d75c118..6af0a78 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 a96bcb3..4142004 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 9c2d3f5..7999c28 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 764ee93..0270226 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 c5324fe..41c77a1 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 a2f9747..cd7f2ae 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 cdb0f8c..f542d53 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;