[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-block] [PATCH v3 1/6] block: Fragment reads to max transfer length
From: |
Eric Blake |
Subject: |
[Qemu-block] [PATCH v3 1/6] block: Fragment reads to max transfer length |
Date: |
Fri, 15 Jul 2016 12:31:59 -0600 |
Drivers should be able to rely on the block layer honoring the
max transfer length, rather than needing to return -EINVAL
(iscsi) or manually fragment things (nbd). This patch adds
the fragmentation in the block layer, after requests have been
aligned (fragmenting before alignment would lead to multiple
unaligned requests, rather than just the head and tail).
The return value was previously nebulous on success on whether
it was zero or the length read; and fragmenting may introduce
yet other non-zero values if we use the last length read. But
as at least some callers are sloppy and expect only zero on
success, it is easiest to just guarantee 0.
Signed-off-by: Eric Blake <address@hidden>
---
v3: Slam 'ret' to 0, not 'bytes', as some callers choke otherwise
v2: Fix uninitialized use of 'ret' for an all-zero read beyond eof
---
block/io.c | 55 ++++++++++++++++++++++++++++++++++---------------------
1 file changed, 34 insertions(+), 21 deletions(-)
diff --git a/block/io.c b/block/io.c
index 2887394..ceff694 100644
--- a/block/io.c
+++ b/block/io.c
@@ -971,8 +971,8 @@ err:
/*
* Forwards an already correctly aligned request to the BlockDriver. This
- * handles copy on read and zeroing after EOF; any other features must be
- * implemented by the caller.
+ * handles copy on read, zeroing after EOF, and fragmentation of large
+ * reads; any other features must be implemented by the caller.
*/
static int coroutine_fn bdrv_aligned_preadv(BlockDriverState *bs,
BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
@@ -980,12 +980,16 @@ static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState *bs,
{
int64_t total_bytes, max_bytes;
int ret;
+ uint64_t bytes_remaining = bytes;
+ int max_transfer;
assert(is_power_of_2(align));
assert((offset & (align - 1)) == 0);
assert((bytes & (align - 1)) == 0);
assert(!qiov || bytes == qiov->size);
assert((bs->open_flags & BDRV_O_NO_IO) == 0);
+ max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),
+ align);
/* TODO: We would need a per-BDS .supported_read_flags and
* potential fallback support, if we ever implement any read flags
@@ -1024,7 +1028,7 @@ static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState *bs,
}
}
- /* Forward the request to the BlockDriver */
+ /* Forward the request to the BlockDriver, possibly fragmenting it */
total_bytes = bdrv_getlength(bs);
if (total_bytes < 0) {
ret = total_bytes;
@@ -1032,30 +1036,39 @@ static int coroutine_fn
bdrv_aligned_preadv(BlockDriverState *bs,
}
max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);
- if (bytes <= max_bytes) {
+ if (bytes <= max_bytes && bytes <= max_transfer) {
ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0);
- } else if (max_bytes > 0) {
- QEMUIOVector local_qiov;
-
- qemu_iovec_init(&local_qiov, qiov->niov);
- qemu_iovec_concat(&local_qiov, qiov, 0, max_bytes);
-
- ret = bdrv_driver_preadv(bs, offset, max_bytes, &local_qiov, 0);
-
- qemu_iovec_destroy(&local_qiov);
- } else {
- ret = 0;
+ goto out;
}
- /* Reading beyond end of file is supposed to produce zeroes */
- if (ret == 0 && total_bytes < offset + bytes) {
- uint64_t zero_offset = MAX(0, total_bytes - offset);
- uint64_t zero_bytes = offset + bytes - zero_offset;
- qemu_iovec_memset(qiov, zero_offset, 0, zero_bytes);
+ while (bytes_remaining) {
+ int num;
+
+ if (max_bytes) {
+ QEMUIOVector local_qiov;
+
+ num = MIN(bytes_remaining, MIN(max_bytes, max_transfer));
+ assert(num);
+ qemu_iovec_init(&local_qiov, qiov->niov);
+ qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
+
+ ret = bdrv_driver_preadv(bs, offset + bytes - bytes_remaining,
+ num, &local_qiov, 0);
+ max_bytes -= num;
+ qemu_iovec_destroy(&local_qiov);
+ } else {
+ num = bytes_remaining;
+ ret = qemu_iovec_memset(qiov, bytes - bytes_remaining, 0,
+ bytes_remaining);
+ }
+ if (ret < 0) {
+ goto out;
+ }
+ bytes_remaining -= num;
}
out:
- return ret;
+ return ret < 0 ? ret : 0;
}
/*
--
2.5.5
- [Qemu-block] [PATCH v3 0/6] Auto-fragment large transactions at the block layer, Eric Blake, 2016/07/15
- [Qemu-block] [PATCH v3 5/6] nbd: Drop unused offset parameter, Eric Blake, 2016/07/15
- [Qemu-block] [PATCH v3 6/6] iscsi: Rely on block layer to break up large requests, Eric Blake, 2016/07/15
- [Qemu-block] [PATCH v3 1/6] block: Fragment reads to max transfer length,
Eric Blake <=
- [Qemu-block] [PATCH v3 2/6] raw_bsd: Don't advertise flags not supported by protocol layer, Eric Blake, 2016/07/15
- [Qemu-block] [PATCH v3 4/6] nbd: Rely on block layer to break up large requests, Eric Blake, 2016/07/15
- [Qemu-block] [PATCH v3 3/6] block: Fragment writes to max transfer length, Eric Blake, 2016/07/15
- Re: [Qemu-block] [Qemu-devel] [PATCH v3 0/6] Auto-fragment large transactions at the block layer, Stefan Hajnoczi, 2016/07/19