Re: [PATCH 40/40] btrfs: use the iomap direct I/O bio directly

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 





On 2022/3/22 23:56, Christoph Hellwig wrote:
Make the iomap code allocate btrfs dios by setting the bio_set field,
and then feed these directly into btrfs_map_dio.

For this to work iomap_begin needs to report a range that only contains
a single chunk, and thus is changed to a two level iteration.

This needs another extra field in struct btrfs_dio.  We culd overlay
it with other fields not used after I/O submittion, or split out a
new btrfs_dio_bio for the file_offset, iter and repair_refs, but
compared to the overall saving of the series this is a minor detail.

The per-iomap csum lookup is gone for now as well.  At least for
small I/Os this just creates a lot of overhead, but for large I/O
we could look into optimizing this in one for or another, but I'd
love to see a reproducer where it actually matters first.  With the
state as of this patch the direct I/O bio submission is so close
to the buffered one that they could be unified with very little
work, so diverging again would be a bit counterproductive.  OTOH
if the optimization is indeed very useful we should do it in a way
that also works for buffered reads.

Signed-off-by: Christoph Hellwig <hch@xxxxxx>

Not familar with iomap thus I can be totally wrong, but isn't the idea
of iomap to separate more code from fs?

My (mostly poor) understanding of iomap is, iomap just crafting a bio
(with the help from fs callbacks).

For btrfs or stacked drivers, they can do whatever to split/clone the
bio, as long as the original bio can be fullfiled, how btrfs/stacked
drivers do the work is their own business.


I'm really not sure if it's a good idea to expose btrfs internal bio_set
just for iomap.

Personally speaking I didn't see much problem of cloning an iomap bio,
it only causes extra memory of btrfs_bio, which is pretty small previously.

Or did I miss something specific to iomap?

Thanks,
Qu
---
  fs/btrfs/btrfs_inode.h |  25 ---
  fs/btrfs/ctree.h       |   1 -
  fs/btrfs/extent_io.c   |  22 +-
  fs/btrfs/extent_io.h   |   4 +-
  fs/btrfs/inode.c       | 451 ++++++++++++++++-------------------------
  fs/btrfs/volumes.h     |   1 +
  6 files changed, 184 insertions(+), 320 deletions(-)

diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index b3e46aabc3d86..a3199020f0001 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -346,31 +346,6 @@ static inline bool btrfs_inode_in_log(struct btrfs_inode *inode, u64 generation)
  	return ret;
  }

-struct btrfs_dio_private {
-	struct inode *inode;
-
-	/*
-	 * Since DIO can use anonymous page, we cannot use page_offset() to
-	 * grab the file offset, thus need a dedicated member for file offset.
-	 */
-	u64 file_offset;
-	u64 disk_bytenr;
-	/* Used for bio::bi_size */
-	u32 bytes;
-
-	/*
-	 * References to this structure. There is one reference per in-flight
-	 * bio plus one while we're still setting up.
-	 */
-	refcount_t refs;
-
-	/* dio_bio came from fs/direct-io.c */
-	struct bio *dio_bio;
-
-	/* Array of checksums */
-	u8 csums[];
-};
-
  /*
   * btrfs_inode_item stores flags in a u64, btrfs_inode stores them in two
   * separate u32s. These two functions convert between the two representations.
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 196f308e3e0d7..64ef20b84f694 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3136,7 +3136,6 @@ int btrfs_del_orphan_item(struct btrfs_trans_handle *trans,
  int btrfs_find_orphan_item(struct btrfs_root *root, u64 offset);

  /* file-item.c */
-struct btrfs_dio_private;
  int btrfs_del_csums(struct btrfs_trans_handle *trans,
  		    struct btrfs_root *root, u64 bytenr, u64 len);
  blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u8 *dst);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 5a1447db28228..f705e4ec9b961 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -31,7 +31,7 @@

  static struct kmem_cache *extent_state_cache;
  static struct kmem_cache *extent_buffer_cache;
-static struct bio_set btrfs_bioset;
+struct bio_set btrfs_bioset;

  static inline bool extent_state_in_tree(const struct extent_state *state)
  {
@@ -3150,26 +3150,6 @@ struct bio *btrfs_bio_alloc(struct inode *inode, unsigned int nr_iovecs,
  	return bio;
  }

-struct bio *btrfs_bio_clone_partial(struct inode *inode, struct bio *orig,
-		u64 offset, u64 size)
-{
-	struct bio *bio;
-	struct btrfs_bio *bbio;
-
-	ASSERT(offset <= UINT_MAX && size <= UINT_MAX);
-
-	/* this will never fail when it's backed by a bioset */
-	bio = bio_alloc_clone(orig->bi_bdev, orig, GFP_NOFS, &btrfs_bioset);
-	ASSERT(bio);
-
-	bbio = btrfs_bio(bio);
-	btrfs_bio_init(btrfs_bio(bio), inode);
-
-	bio_trim(bio, offset >> 9, size >> 9);
-	bbio->iter = bio->bi_iter;
-	return bio;
-}
-
  /**
   * Attempt to add a page to bio
   *
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 54e54269cfdba..b416531721dfb 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -279,8 +279,6 @@ void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end,
  				  u32 bits_to_clear, unsigned long page_ops);
  struct bio *btrfs_bio_alloc(struct inode *inode, unsigned int nr_iovecs,
  		unsigned int opf);
-struct bio *btrfs_bio_clone_partial(struct inode *inode, struct bio *orig,
-		u64 offset, u64 size);

  void end_extent_writepage(struct page *page, int err, u64 start, u64 end);
  int btrfs_repair_eb_io_failure(const struct extent_buffer *eb, int mirror_num);
@@ -323,4 +321,6 @@ void btrfs_extent_buffer_leak_debug_check(struct btrfs_fs_info *fs_info);
  #define btrfs_extent_buffer_leak_debug_check(fs_info)	do {} while (0)
  #endif

+extern struct bio_set btrfs_bioset;
+
  #endif
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index e25d9d860c679..6ea6ef214abdb 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -62,8 +62,8 @@ struct btrfs_iget_args {
  };

  struct btrfs_dio_data {
-	ssize_t submitted;
  	struct extent_changeset *data_reserved;
+	struct iomap extent;
  };

  static const struct inode_operations btrfs_dir_inode_operations;
@@ -7507,16 +7507,16 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map,
  	return ret;
  }

-static int btrfs_dio_iomap_begin(struct iomap_iter *iter)
+static int btrfs_dio_iomap_begin_extent(struct iomap_iter *iter)
  {
  	struct inode *inode = iter->inode;
  	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
  	loff_t start = iter->pos;
  	loff_t length = iter->len;
-	struct iomap *iomap = &iter->iomap;
  	struct extent_map *em;
  	struct extent_state *cached_state = NULL;
  	struct btrfs_dio_data *dio_data = iter->private;
+	struct iomap *iomap = &dio_data->extent;
  	u64 lockstart, lockend;
  	bool write = (iter->flags & IOMAP_WRITE);
  	int ret = 0;
@@ -7543,7 +7543,6 @@ static int btrfs_dio_iomap_begin(struct iomap_iter *iter)
  			return ret;
  	}

-	dio_data->submitted = 0;
  	dio_data->data_reserved = NULL;

  	/*
@@ -7647,14 +7646,12 @@ static int btrfs_dio_iomap_begin(struct iomap_iter *iter)
  		iomap->type = IOMAP_MAPPED;
  	}
  	iomap->offset = start;
-	iomap->bdev = fs_info->fs_devices->latest_dev->bdev;
  	iomap->length = len;

  	if (write && btrfs_use_zone_append(BTRFS_I(inode), em->block_start))
  		iomap->flags |= IOMAP_F_ZONE_APPEND;

  	free_extent_map(em);
-
  	return 0;

  unlock_err:
@@ -7663,53 +7660,95 @@ static int btrfs_dio_iomap_begin(struct iomap_iter *iter)
  	return ret;
  }

-static int btrfs_dio_iomap_end(struct iomap_iter *iter)
+static void btrfs_dio_unlock_remaining_extent(struct btrfs_inode *bi,
+		u64 pos, u64 len, u64 processed, bool write)
  {
-	struct btrfs_dio_data *dio_data = iter->private;
+	if (write)
+		__endio_write_update_ordered(bi, pos + processed,
+				len - processed, false);
+	else
+		unlock_extent(&bi->io_tree, pos + processed,
+				pos + len - 1);
+}
+
+static int btrfs_dio_iomap_begin_chunk(struct iomap_iter *iter)
+{
+	struct btrfs_fs_info *fs_info = btrfs_sb(iter->inode->i_sb);
  	struct btrfs_inode *bi = BTRFS_I(iter->inode);
-	bool write = (iter->flags & IOMAP_WRITE);
-	loff_t length = iomap_length(iter);
-	loff_t pos = iter->pos;
-	int ret = 0;
+	struct btrfs_dio_data *dio_data = iter->private;
+	struct block_device *bdev;
+	u64 len;
+
+	iter->iomap = dio_data->extent;

-	if (!write && iter->iomap.type == IOMAP_HOLE) {
-		/* If reading from a hole, unlock and return */
-		unlock_extent(&bi->io_tree, pos, pos + length - 1);
+	if (dio_data->extent.type != IOMAP_MAPPED)
  		return 0;
+
+	bdev = btrfs_get_stripe_info(fs_info, (iter->flags & IOMAP_WRITE) ?
+			BTRFS_MAP_WRITE : BTRFS_MAP_READ,
+			iter->iomap.addr, iter->iomap.length, &len);
+	if (WARN_ON_ONCE(IS_ERR(bdev))) {
+		btrfs_dio_unlock_remaining_extent(bi, dio_data->extent.offset,
+						  dio_data->extent.length, 0,
+						  iter->flags & IOMAP_WRITE);
+		return PTR_ERR(bdev);
  	}

-	if (dio_data->submitted < length) {
-		pos += dio_data->submitted;
-		length -= dio_data->submitted;
-		if (write)
-			__endio_write_update_ordered(bi, pos, length, false);
-		else
-			unlock_extent(&bi->io_tree, pos, pos + length - 1);
-		ret = -ENOTBLK;
+	iter->iomap.bdev = bdev;
+	iter->iomap.length = min(iter->iomap.length, len);
+	return 0;
+}
+
+static bool btrfs_dio_iomap_end(struct iomap_iter *iter)
+{
+	struct btrfs_inode *bi = BTRFS_I(iter->inode);
+	struct btrfs_dio_data *dio_data = iter->private;
+	struct iomap *extent = &dio_data->extent;
+	loff_t processed = iomap_processed(iter);
+	loff_t length = iomap_length(iter);
+
+	if (iter->iomap.type == IOMAP_HOLE) {
+		ASSERT(!(iter->flags & IOMAP_WRITE));
+
+		/* If reading from a hole, unlock the whole range here */
+		unlock_extent(&bi->io_tree, iter->pos, iter->pos + length - 1);
+	} else if (processed < length) {
+		btrfs_dio_unlock_remaining_extent(bi, extent->offset,
+						  extent->length, processed,
+						  iter->flags & IOMAP_WRITE);
+	} else if (iter->pos + processed < extent->offset + extent->length) {
+		extent->offset += processed;
+		extent->addr += processed;
+		extent->length -= processed;
+		return true;
  	}

-	if (write)
+	if (iter->flags & IOMAP_WRITE)
  		extent_changeset_free(dio_data->data_reserved);
-	return ret;
+	return false;
  }

  static int btrfs_dio_iomap_iter(struct iomap_iter *iter)
  {
+	bool keep_extent = false;
  	int ret;

-	if (iter->iomap.length) {
-		ret = btrfs_dio_iomap_end(iter);
-		if (ret < 0 && !iter->processed)
-			return ret;
-	}
+	if (iter->iomap.length)
+		keep_extent = btrfs_dio_iomap_end(iter);

  	ret = iomap_iter_advance(iter);
  	if (ret <= 0)
  		return ret;

-	ret = btrfs_dio_iomap_begin(iter);
-	if (ret < 0)
+	if (!keep_extent) {
+		ret = btrfs_dio_iomap_begin_extent(iter);
+		if (ret < 0)
+			return ret;
+	}
+	ret = btrfs_dio_iomap_begin_chunk(iter);
+	if (ret < 0)
  		return ret;
+
  	iomap_iter_done(iter);
  	return 1;
  }
@@ -7718,54 +7757,40 @@ static const struct iomap_ops btrfs_dio_iomap_ops = {
  	.iomap_iter		= btrfs_dio_iomap_iter,
  };

-static void btrfs_dio_private_put(struct btrfs_dio_private *dip)
+static void btrfs_end_read_dio_bio(struct btrfs_bio *bbio,
+		struct btrfs_bio *main_bbio);
+
+static void btrfs_dio_repair_end_io(struct bio *bio)
  {
-	/*
-	 * This implies a barrier so that stores to dio_bio->bi_status before
-	 * this and loads of dio_bio->bi_status after this are fully ordered.
-	 */
-	if (!refcount_dec_and_test(&dip->refs))
-		return;
+	struct btrfs_bio *bbio = btrfs_bio(bio);
+	struct btrfs_inode *bi = BTRFS_I(bbio->inode);
+	struct btrfs_bio *failed_bbio = bio->bi_private;

-	if (btrfs_op(dip->dio_bio) == BTRFS_MAP_WRITE) {
-		__endio_write_update_ordered(BTRFS_I(dip->inode),
-					     dip->file_offset,
-					     dip->bytes,
-					     !dip->dio_bio->bi_status);
-	} else {
-		unlock_extent(&BTRFS_I(dip->inode)->io_tree,
-			      dip->file_offset,
-			      dip->file_offset + dip->bytes - 1);
+	if (bio->bi_status) {
+		btrfs_warn(bi->root->fs_info,
+			   "direct IO failed ino %llu rw %d,%u sector %#Lx len %u err no %d",
+			   btrfs_ino(bi), bio_op(bio), bio->bi_opf,
+			   bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
+			   bio->bi_status);
  	}
+	btrfs_end_read_dio_bio(bbio, failed_bbio);

-	bio_endio(dip->dio_bio);
-	kfree(dip);
+	bio_put(bio);
  }

  static blk_status_t submit_dio_repair_bio(struct inode *inode, struct bio *bio,
  					  int mirror_num,
  					  unsigned long bio_flags)
  {
-	struct btrfs_dio_private *dip = bio->bi_private;
-	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-	blk_status_t ret;
-
  	BUG_ON(bio_op(bio) == REQ_OP_WRITE);
-
  	btrfs_bio(bio)->end_io_type = BTRFS_ENDIO_WQ_DATA_WRITE;
-
-	refcount_inc(&dip->refs);
-	ret = btrfs_map_bio(fs_info, bio, mirror_num);
-	if (ret)
-		refcount_dec(&dip->refs);
-	return ret;
+	return btrfs_map_bio(btrfs_sb(inode->i_sb), bio, mirror_num);
  }

-static blk_status_t btrfs_check_read_dio_bio(struct btrfs_dio_private *dip,
-					     struct btrfs_bio *bbio,
-					     const bool uptodate)
+static void btrfs_end_read_dio_bio(struct btrfs_bio *this_bbio,
+		struct btrfs_bio *main_bbio)
  {
-	struct inode *inode = dip->inode;
+	struct inode *inode = main_bbio->inode;
  	struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
  	const u32 sectorsize = fs_info->sectorsize;
  	struct extent_io_tree *failure_tree = &BTRFS_I(inode)->io_failure_tree;
@@ -7773,20 +7798,22 @@ static blk_status_t btrfs_check_read_dio_bio(struct btrfs_dio_private *dip,
  	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);
  	struct bio_vec bvec;
  	struct bvec_iter iter;
+	bool uptodate = !this_bbio->bio.bi_status;
  	u32 bio_offset = 0;
-	blk_status_t err = BLK_STS_OK;

-	__bio_for_each_segment(bvec, &bbio->bio, iter, bbio->iter) {
+	main_bbio->bio.bi_status = BLK_STS_OK;
+
+	__bio_for_each_segment(bvec, &this_bbio->bio, iter, this_bbio->iter) {
  		unsigned int i, nr_sectors, pgoff;

  		nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, bvec.bv_len);
  		pgoff = bvec.bv_offset;
  		for (i = 0; i < nr_sectors; i++) {
-			u64 start = bbio->file_offset + bio_offset;
+			u64 start = this_bbio->file_offset + bio_offset;

  			ASSERT(pgoff < PAGE_SIZE);
  			if (uptodate &&
-			    (!csum || !check_data_csum(inode, bbio,
+			    (!csum || !check_data_csum(inode, this_bbio,
  						       bio_offset, bvec.bv_page,
  						       pgoff, start))) {
  				clean_io_failure(fs_info, failure_tree, io_tree,
@@ -7796,21 +7823,56 @@ static blk_status_t btrfs_check_read_dio_bio(struct btrfs_dio_private *dip,
  			} else {
  				blk_status_t ret;

-				ret = btrfs_repair_one_sector(inode, &bbio->bio,
-						bio_offset, bvec.bv_page, pgoff,
-						start, bbio->mirror_num,
+				atomic_inc(&main_bbio->repair_refs);
+				ret = btrfs_repair_one_sector(inode,
+						&this_bbio->bio, bio_offset,
+						bvec.bv_page, pgoff, start,
+						this_bbio->mirror_num,
  						submit_dio_repair_bio,
-						bbio->bio.bi_private,
-						bbio->bio.bi_end_io);
-				if (ret)
-					err = ret;
+						main_bbio,
+						btrfs_dio_repair_end_io);
+				if (ret) {
+					main_bbio->bio.bi_status = ret;
+					atomic_dec(&main_bbio->repair_refs);
+				}
  			}
  			ASSERT(bio_offset + sectorsize > bio_offset);
  			bio_offset += sectorsize;
  			pgoff += sectorsize;
  		}
  	}
-	return err;
+
+	if (atomic_dec_and_test(&main_bbio->repair_refs)) {
+		unlock_extent(&BTRFS_I(inode)->io_tree, main_bbio->file_offset,
+			main_bbio->file_offset + main_bbio->iter.bi_size - 1);
+		iomap_dio_bio_end_io(&main_bbio->bio);
+	}
+}
+
+static void btrfs_dio_bio_end_io(struct bio *bio)
+{
+	struct btrfs_bio *bbio = btrfs_bio(bio);
+	struct btrfs_inode *bi = BTRFS_I(bbio->inode);
+
+	if (bio->bi_status) {
+		btrfs_warn(bi->root->fs_info,
+			   "direct IO failed ino %llu rw %d,%u sector %#Lx len %u err no %d",
+			   btrfs_ino(bi), bio_op(bio), bio->bi_opf,
+			   bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
+			   bio->bi_status);
+	}
+
+	if (bio_op(bio) == REQ_OP_READ) {
+		atomic_set(&bbio->repair_refs, 1);
+		btrfs_end_read_dio_bio(bbio, bbio);
+	} else {
+		btrfs_record_physical_zoned(bbio->inode, bbio->file_offset,
+					    bio);
+		__endio_write_update_ordered(bi, bbio->file_offset,
+					     bbio->iter.bi_size,
+					     !bio->bi_status);
+		iomap_dio_bio_end_io(bio);
+	}
  }

  static void __endio_write_update_ordered(struct btrfs_inode *inode,
@@ -7829,47 +7891,47 @@ static void btrfs_submit_bio_start_direct_io(struct btrfs_work *work)
  			&bbio->bio, bbio->file_offset, 1);
  }

-static void btrfs_end_dio_bio(struct bio *bio)
+/*
+ * If we are submitting more than one bio, submit them all asynchronously.  The
+ * exception is RAID 5 or 6, as asynchronous checksums make it difficult to
+ * collect full stripe writes.
+ */
+static bool btrfs_dio_allow_async_write(struct btrfs_fs_info *fs_info,
+		struct btrfs_inode *bi)
  {
-	struct btrfs_dio_private *dip = bio->bi_private;
-	struct btrfs_bio *bbio = btrfs_bio(bio);
-	blk_status_t err = bio->bi_status;
-
-	if (err)
-		btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,
-			   "direct IO failed ino %llu rw %d,%u sector %#Lx len %u err no %d",
-			   btrfs_ino(BTRFS_I(dip->inode)), bio_op(bio),
-			   bio->bi_opf, bio->bi_iter.bi_sector,
-			   bio->bi_iter.bi_size, err);
-
-	if (bio_op(bio) == REQ_OP_READ)
-		err = btrfs_check_read_dio_bio(dip, bbio, !err);
-
-	if (err)
-		dip->dio_bio->bi_status = err;
-
-	btrfs_record_physical_zoned(dip->inode, bbio->file_offset, bio);
-
-	bio_put(bio);
-	btrfs_dio_private_put(dip);
+	if (btrfs_data_alloc_profile(fs_info) & BTRFS_BLOCK_GROUP_RAID56_MASK)
+		return false;
+	if (atomic_read(&bi->sync_writers))
+		return false;
+	return true;
  }

-static inline blk_status_t btrfs_submit_dio_bio(struct bio *bio,
-		struct inode *inode, u64 file_offset, int async_submit)
+static void btrfs_dio_submit_io(const struct iomap_iter *iter,
+		struct bio *bio, loff_t file_offset, bool more)
  {
-	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-	struct btrfs_inode *bi = BTRFS_I(inode);
-	struct btrfs_dio_private *dip = bio->bi_private;
+	struct btrfs_fs_info *fs_info = btrfs_sb(iter->inode->i_sb);
+	struct btrfs_inode *bi = BTRFS_I(iter->inode);
  	struct btrfs_bio *bbio = btrfs_bio(bio);
  	blk_status_t ret;

+	memset(bbio, 0, offsetof(struct btrfs_bio, bio));
+	bbio->inode = iter->inode;
+	bbio->file_offset = file_offset;
+	bbio->iter = bio->bi_iter;
+	bio->bi_end_io = btrfs_dio_bio_end_io;
+
  	if (btrfs_op(bio) == BTRFS_MAP_WRITE) {
+		if (bio_op(bio) == REQ_OP_ZONE_APPEND) {
+			ret = extract_ordered_extent(bi, bio, file_offset);
+			if (ret)
+				goto out_err;
+		}
+
  		if (!(bi->flags & BTRFS_INODE_NODATASUM)) {
-			/* See btrfs_submit_data_bio for async submit rules */
-			if (async_submit && !atomic_read(&bi->sync_writers)) {
+			if (more && btrfs_dio_allow_async_write(fs_info, bi)) {
  				btrfs_submit_bio_async(bbio,
  					btrfs_submit_bio_start_direct_io);
-				return BLK_STS_OK;
+				return;
  			}

  			/*
@@ -7878,189 +7940,36 @@ static inline blk_status_t btrfs_submit_dio_bio(struct bio *bio,
  			 */
  			ret = btrfs_csum_one_bio(bi, bio, file_offset, 1);
  			if (ret)
-				return ret;
+				goto out_err;
  		}
  	} else {
  		bbio->end_io_type = BTRFS_ENDIO_WQ_DATA_READ;

-		if (!(bi->flags & BTRFS_INODE_NODATASUM)) {
-			u64 csum_offset;
-
-			csum_offset = file_offset - dip->file_offset;
-			csum_offset >>= fs_info->sectorsize_bits;
-			csum_offset *= fs_info->csum_size;
-			btrfs_bio(bio)->csum = dip->csums + csum_offset;
-		}
-	}
-
-	return btrfs_map_bio(fs_info, bio, 0);
-}
-
-/*
- * If this succeeds, the btrfs_dio_private is responsible for cleaning up locked
- * or ordered extents whether or not we submit any bios.
- */
-static struct btrfs_dio_private *btrfs_create_dio_private(struct bio *dio_bio,
-							  struct inode *inode,
-							  loff_t file_offset)
-{
-	const bool write = (btrfs_op(dio_bio) == BTRFS_MAP_WRITE);
-	const bool csum = !(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM);
-	size_t dip_size;
-	struct btrfs_dio_private *dip;
-
-	dip_size = sizeof(*dip);
-	if (!write && csum) {
-		struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-		size_t nblocks;
-
-		nblocks = dio_bio->bi_iter.bi_size >> fs_info->sectorsize_bits;
-		dip_size += fs_info->csum_size * nblocks;
-	}
-
-	dip = kzalloc(dip_size, GFP_NOFS);
-	if (!dip)
-		return NULL;
-
-	dip->inode = inode;
-	dip->file_offset = file_offset;
-	dip->bytes = dio_bio->bi_iter.bi_size;
-	dip->disk_bytenr = dio_bio->bi_iter.bi_sector << 9;
-	dip->dio_bio = dio_bio;
-	refcount_set(&dip->refs, 1);
-	return dip;
-}
-
-static void btrfs_submit_direct(const struct iomap_iter *iter,
-		struct bio *dio_bio, loff_t file_offset, bool more)
-{
-	struct inode *inode = iter->inode;
-	const bool write = (btrfs_op(dio_bio) == BTRFS_MAP_WRITE);
-	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-	const bool raid56 = (btrfs_data_alloc_profile(fs_info) &
-			     BTRFS_BLOCK_GROUP_RAID56_MASK);
-	struct btrfs_dio_private *dip;
-	struct bio *bio;
-	u64 start_sector;
-	int async_submit = 0;
-	u64 submit_len;
-	u64 clone_offset = 0;
-	u64 clone_len;
-	blk_status_t status;
-	struct btrfs_dio_data *dio_data = iter->private;
-	u64 len;
-
-	dip = btrfs_create_dio_private(dio_bio, inode, file_offset);
-	if (!dip) {
-		if (!write) {
-			unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
-				file_offset + dio_bio->bi_iter.bi_size - 1);
-		}
-		dio_bio->bi_status = BLK_STS_RESOURCE;
-		bio_endio(dio_bio);
-		return;
-	}
-
-	if (!write) {
-		/*
-		 * Load the csums up front to reduce csum tree searches and
-		 * contention when submitting bios.
-		 *
-		 * If we have csums disabled this will do nothing.
-		 */
-		status = btrfs_lookup_bio_sums(inode, dio_bio, dip->csums);
-		if (status != BLK_STS_OK)
+		ret = btrfs_lookup_bio_sums(iter->inode, bio, NULL);
+		if (ret)
  			goto out_err;
  	}

-	start_sector = dio_bio->bi_iter.bi_sector;
-	submit_len = dio_bio->bi_iter.bi_size;
-
-	do {
-		struct block_device *bdev;
-
-		bdev = btrfs_get_stripe_info(fs_info, btrfs_op(dio_bio),
-				      start_sector << 9, submit_len, &len);
-		if (IS_ERR(bdev)) {
-			status = errno_to_blk_status(PTR_ERR(bdev));
-			goto out_err;
-		}
-
-		clone_len = min(submit_len, len);
-		ASSERT(clone_len <= UINT_MAX);
-
-		/*
-		 * This will never fail as it's passing GPF_NOFS and
-		 * the allocation is backed by btrfs_bioset.
-		 */
-		bio = btrfs_bio_clone_partial(inode, dio_bio, clone_offset,
-					      clone_len);
-		bio->bi_private = dip;
-		bio->bi_end_io = btrfs_end_dio_bio;
-		btrfs_bio(bio)->file_offset = file_offset;
-
-		if (bio_op(bio) == REQ_OP_ZONE_APPEND) {
-			status = extract_ordered_extent(BTRFS_I(inode), bio,
-							file_offset);
-			if (status) {
-				bio_put(bio);
-				goto out_err;
-			}
-		}
-
-		ASSERT(submit_len >= clone_len);
-		submit_len -= clone_len;
-
-		/*
-		 * Increase the count before we submit the bio so we know
-		 * the end IO handler won't happen before we increase the
-		 * count. Otherwise, the dip might get freed before we're
-		 * done setting it up.
-		 *
-		 * We transfer the initial reference to the last bio, so we
-		 * don't need to increment the reference count for the last one.
-		 */
-		if (submit_len > 0) {
-			refcount_inc(&dip->refs);
-			/*
-			 * If we are submitting more than one bio, submit them
-			 * all asynchronously. The exception is RAID 5 or 6, as
-			 * asynchronous checksums make it difficult to collect
-			 * full stripe writes.
-			 */
-			if (!raid56)
-				async_submit = 1;
-		}
-
-		status = btrfs_submit_dio_bio(bio, inode, file_offset,
-						async_submit);
-		if (status) {
-			bio_put(bio);
-			if (submit_len > 0)
-				refcount_dec(&dip->refs);
-			goto out_err;
-		}
+	ret = btrfs_map_bio(fs_info, bio, 0);
+	if (ret)
+		goto out_err;

-		dio_data->submitted += clone_len;
-		clone_offset += clone_len;
-		start_sector += clone_len >> 9;
-		file_offset += clone_len;
-	} while (submit_len > 0);
  	return;

  out_err:
-	dip->dio_bio->bi_status = status;
-	btrfs_dio_private_put(dip);
+	bio->bi_status = ret;
+	bio_endio(bio);
  }

  static const struct iomap_dio_ops btrfs_dio_ops = {
-	.submit_io		= btrfs_submit_direct,
+	.submit_io		= btrfs_dio_submit_io,
+	.bio_set		= &btrfs_bioset,
  };

  ssize_t btrfs_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
  		size_t done_before)
  {
-	struct btrfs_dio_data data;
+	struct btrfs_dio_data data = {};

  	iocb->private = &data;
  	return iomap_dio_rw(iocb, iter, &btrfs_dio_iomap_ops, &btrfs_dio_ops,
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index c6425760f69da..e9d775398141b 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -341,6 +341,7 @@ struct btrfs_bio {

  	/* for direct I/O */
  	u64 file_offset;
+	atomic_t repair_refs;

  	/* @device is for stripe IO submission. */
  	struct btrfs_device *device;




[Index of Archives]     [Linux Ext4 Filesystem]     [Union Filesystem]     [Filesystem Testing]     [Ceph Users]     [Ecryptfs]     [NTFS 3]     [AutoFS]     [Kernel Newbies]     [Share Photos]     [Security]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux Cachefs]     [Reiser Filesystem]     [Linux RAID]     [NTFS 3]     [Samba]     [Device Mapper]     [CEPH Development]

  Powered by Linux