* [Qemu-devel] [PULL 00/11] Block patches
@ 2018-06-04 11:20 Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 01/11] block: Introduce API for copy offloading Stefan Hajnoczi
` (11 more replies)
0 siblings, 12 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
The following changes since commit c25e8bba1f546ea72744ccfab77f8a9e8a323be8:
Merge remote-tracking branch 'remotes/otubo/tags/pull-seccomp-20180601' into staging (2018-06-01 13:11:30 +0100)
are available in the Git repository at:
git://github.com/stefanha/qemu.git tags/block-pull-request
for you to fetch changes up to 21891a5a3011608845b5d7f1f9cce60cdc2bcc62:
main-loop: drop spin_counter (2018-06-01 16:01:29 +0100)
----------------------------------------------------------------
Pull request
* Copy offloading for qemu-img convert (iSCSI, raw, and qcow2)
If the underlying storage supports copy offloading, qemu-img convert will
use it instead of performing reads and writes. This avoids data transfers
and thus frees up storage bandwidth for other purposes. SCSI EXTENDED COPY
and Linux copy_file_range(2) are used to implement this optimization.
* Drop spurious "WARNING: I\/O thread spun for 1000 iterations" warning
----------------------------------------------------------------
Fam Zheng (10):
block: Introduce API for copy offloading
raw: Check byte range uniformly
raw: Implement copy offloading
qcow2: Implement copy offloading
file-posix: Implement bdrv_co_copy_range
iscsi: Query and save device designator when opening
iscsi: Create and use iscsi_co_wait_for_task
iscsi: Implement copy offloading
block-backend: Add blk_co_copy_range
qemu-img: Convert with copy offloading
Stefan Hajnoczi (1):
main-loop: drop spin_counter
configure | 17 ++
include/block/block.h | 32 ++++
include/block/block_int.h | 38 ++++
include/block/raw-aio.h | 10 +-
include/scsi/constants.h | 4 +
include/sysemu/block-backend.h | 4 +
block/block-backend.c | 18 ++
block/file-posix.c | 98 +++++++++-
block/io.c | 97 ++++++++++
block/iscsi.c | 314 +++++++++++++++++++++++++++----
block/qcow2.c | 229 +++++++++++++++++++---
block/raw-format.c | 96 +++++++---
qemu-img.c | 50 ++++-
util/main-loop.c | 25 ---
tests/qemu-iotests/common.filter | 1 -
15 files changed, 908 insertions(+), 125 deletions(-)
--
2.17.1
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 01/11] block: Introduce API for copy offloading
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 02/11] raw: Check byte range uniformly Stefan Hajnoczi
` (10 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
Introduce the bdrv_co_copy_range() API for copy offloading. Block
drivers implementing this API support efficient copy operations that
avoid reading each block from the source device and writing it to the
destination devices. Examples of copy offload primitives are SCSI
EXTENDED COPY and Linux copy_file_range(2).
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20180601092648.24614-2-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
include/block/block.h | 32 +++++++++++++
include/block/block_int.h | 38 +++++++++++++++
block/io.c | 97 +++++++++++++++++++++++++++++++++++++++
3 files changed, 167 insertions(+)
diff --git a/include/block/block.h b/include/block/block.h
index 3894edda9d..6cc6c7e699 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -611,4 +611,36 @@ bool bdrv_can_store_new_dirty_bitmap(BlockDriverState *bs, const char *name,
*/
void bdrv_register_buf(BlockDriverState *bs, void *host, size_t size);
void bdrv_unregister_buf(BlockDriverState *bs, void *host);
+
+/**
+ *
+ * bdrv_co_copy_range:
+ *
+ * Do offloaded copy between two children. If the operation is not implemented
+ * by the driver, or if the backend storage doesn't support it, a negative
+ * error code will be returned.
+ *
+ * Note: block layer doesn't emulate or fallback to a bounce buffer approach
+ * because usually the caller shouldn't attempt offloaded copy any more (e.g.
+ * calling copy_file_range(2)) after the first error, thus it should fall back
+ * to a read+write path in the caller level.
+ *
+ * @src: Source child to copy data from
+ * @src_offset: offset in @src image to read data
+ * @dst: Destination child to copy data to
+ * @dst_offset: offset in @dst image to write data
+ * @bytes: number of bytes to copy
+ * @flags: request flags. Must be one of:
+ * 0 - actually read data from src;
+ * BDRV_REQ_ZERO_WRITE - treat the @src range as zero data and do zero
+ * write on @dst as if bdrv_co_pwrite_zeroes is
+ * called. Used to simplify caller code, or
+ * during BlockDriver.bdrv_co_copy_range_from()
+ * recursion.
+ *
+ * Returns: 0 if succeeded; negative error code if failed.
+ **/
+int coroutine_fn bdrv_co_copy_range(BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags);
#endif
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 6c0927bce3..888b7f7bff 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -204,6 +204,37 @@ struct BlockDriver {
int coroutine_fn (*bdrv_co_pdiscard)(BlockDriverState *bs,
int64_t offset, int bytes);
+ /* Map [offset, offset + nbytes) range onto a child of @bs to copy from,
+ * and invoke bdrv_co_copy_range_from(child, ...), or invoke
+ * bdrv_co_copy_range_to() if @bs is the leaf child to copy data from.
+ *
+ * See the comment of bdrv_co_copy_range for the parameter and return value
+ * semantics.
+ */
+ int coroutine_fn (*bdrv_co_copy_range_from)(BlockDriverState *bs,
+ BdrvChild *src,
+ uint64_t offset,
+ BdrvChild *dst,
+ uint64_t dst_offset,
+ uint64_t bytes,
+ BdrvRequestFlags flags);
+
+ /* Map [offset, offset + nbytes) range onto a child of bs to copy data to,
+ * and invoke bdrv_co_copy_range_to(child, src, ...), or perform the copy
+ * operation if @bs is the leaf and @src has the same BlockDriver. Return
+ * -ENOTSUP if @bs is the leaf but @src has a different BlockDriver.
+ *
+ * See the comment of bdrv_co_copy_range for the parameter and return value
+ * semantics.
+ */
+ int coroutine_fn (*bdrv_co_copy_range_to)(BlockDriverState *bs,
+ BdrvChild *src,
+ uint64_t src_offset,
+ BdrvChild *dst,
+ uint64_t dst_offset,
+ uint64_t bytes,
+ BdrvRequestFlags flags);
+
/*
* Building block for bdrv_block_status[_above] and
* bdrv_is_allocated[_above]. The driver should answer only
@@ -1102,4 +1133,11 @@ void bdrv_dec_in_flight(BlockDriverState *bs);
void blockdev_close_all_bdrv_states(void);
+int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags);
+int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags);
+
#endif /* BLOCK_INT_H */
diff --git a/block/io.c b/block/io.c
index ca96b487eb..b7beaeeb9f 100644
--- a/block/io.c
+++ b/block/io.c
@@ -2835,3 +2835,100 @@ void bdrv_unregister_buf(BlockDriverState *bs, void *host)
bdrv_unregister_buf(child->bs, host);
}
}
+
+static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src,
+ uint64_t src_offset,
+ BdrvChild *dst,
+ uint64_t dst_offset,
+ uint64_t bytes,
+ BdrvRequestFlags flags,
+ bool recurse_src)
+{
+ int ret;
+
+ if (!src || !dst || !src->bs || !dst->bs) {
+ return -ENOMEDIUM;
+ }
+ ret = bdrv_check_byte_request(src->bs, src_offset, bytes);
+ if (ret) {
+ return ret;
+ }
+
+ ret = bdrv_check_byte_request(dst->bs, dst_offset, bytes);
+ if (ret) {
+ return ret;
+ }
+ if (flags & BDRV_REQ_ZERO_WRITE) {
+ return bdrv_co_pwrite_zeroes(dst, dst_offset, bytes, flags);
+ }
+
+ if (!src->bs->drv->bdrv_co_copy_range_from
+ || !dst->bs->drv->bdrv_co_copy_range_to
+ || src->bs->encrypted || dst->bs->encrypted) {
+ return -ENOTSUP;
+ }
+ if (recurse_src) {
+ return src->bs->drv->bdrv_co_copy_range_from(src->bs,
+ src, src_offset,
+ dst, dst_offset,
+ bytes, flags);
+ } else {
+ return dst->bs->drv->bdrv_co_copy_range_to(dst->bs,
+ src, src_offset,
+ dst, dst_offset,
+ bytes, flags);
+ }
+}
+
+/* Copy range from @src to @dst.
+ *
+ * See the comment of bdrv_co_copy_range for the parameter and return value
+ * semantics. */
+int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset,
+ bytes, flags, true);
+}
+
+/* Copy range from @src to @dst.
+ *
+ * See the comment of bdrv_co_copy_range for the parameter and return value
+ * semantics. */
+int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset,
+ bytes, flags, false);
+}
+
+int coroutine_fn bdrv_co_copy_range(BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ BdrvTrackedRequest src_req, dst_req;
+ BlockDriverState *src_bs = src->bs;
+ BlockDriverState *dst_bs = dst->bs;
+ int ret;
+
+ bdrv_inc_in_flight(src_bs);
+ bdrv_inc_in_flight(dst_bs);
+ tracked_request_begin(&src_req, src_bs, src_offset,
+ bytes, BDRV_TRACKED_READ);
+ tracked_request_begin(&dst_req, dst_bs, dst_offset,
+ bytes, BDRV_TRACKED_WRITE);
+
+ wait_serialising_requests(&src_req);
+ wait_serialising_requests(&dst_req);
+ ret = bdrv_co_copy_range_from(src, src_offset,
+ dst, dst_offset,
+ bytes, flags);
+
+ tracked_request_end(&src_req);
+ tracked_request_end(&dst_req);
+ bdrv_dec_in_flight(src_bs);
+ bdrv_dec_in_flight(dst_bs);
+ return ret;
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 02/11] raw: Check byte range uniformly
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 01/11] block: Introduce API for copy offloading Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 03/11] raw: Implement copy offloading Stefan Hajnoczi
` (9 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
We don't verify the request range against s->size in the I/O callbacks
except for raw_co_pwritev. This is inconsistent (especially for
raw_co_pwrite_zeroes and raw_co_pdiscard), so fix them, in the meanwhile
make the helper reusable by the coming new callbacks.
Note that in most cases the block layer already verifies the request
byte range against our reported image length, before invoking the driver
callbacks. The exception is during image creating, after
blk_set_allow_write_beyond_eof(blk, true) is called. But in that case,
the requests are not directly from the user or guest. So there is no
visible behavior change in adding the check code.
The int64_t -> uint64_t inconsistency, as shown by the type casting, is
pre-existing due to the interface.
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-id: 20180601092648.24614-3-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
block/raw-format.c | 64 ++++++++++++++++++++++++++++------------------
1 file changed, 39 insertions(+), 25 deletions(-)
diff --git a/block/raw-format.c b/block/raw-format.c
index fe33693a2d..b69a0674b3 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -167,16 +167,37 @@ static void raw_reopen_abort(BDRVReopenState *state)
state->opaque = NULL;
}
+/* Check and adjust the offset, against 'offset' and 'size' options. */
+static inline int raw_adjust_offset(BlockDriverState *bs, uint64_t *offset,
+ uint64_t bytes, bool is_write)
+{
+ BDRVRawState *s = bs->opaque;
+
+ if (s->has_size && (*offset > s->size || bytes > (s->size - *offset))) {
+ /* There's not enough space for the write, or the read request is
+ * out-of-range. Don't read/write anything to prevent leaking out of
+ * the size specified in options. */
+ return is_write ? -ENOSPC : -EINVAL;;
+ }
+
+ if (*offset > INT64_MAX - s->offset) {
+ return -EINVAL;
+ }
+ *offset += s->offset;
+
+ return 0;
+}
+
static int coroutine_fn raw_co_preadv(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov,
int flags)
{
- BDRVRawState *s = bs->opaque;
+ int ret;
- if (offset > UINT64_MAX - s->offset) {
- return -EINVAL;
+ ret = raw_adjust_offset(bs, &offset, bytes, false);
+ if (ret) {
+ return ret;
}
- offset += s->offset;
BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
@@ -186,23 +207,11 @@ static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov,
int flags)
{
- BDRVRawState *s = bs->opaque;
void *buf = NULL;
BlockDriver *drv;
QEMUIOVector local_qiov;
int ret;
- if (s->has_size && (offset > s->size || bytes > (s->size - offset))) {
- /* There's not enough space for the data. Don't write anything and just
- * fail to prevent leaking out of the size specified in options. */
- return -ENOSPC;
- }
-
- if (offset > UINT64_MAX - s->offset) {
- ret = -EINVAL;
- goto fail;
- }
-
if (bs->probed && offset < BLOCK_PROBE_BUF_SIZE && bytes) {
/* Handling partial writes would be a pain - so we just
* require that guests have 512-byte request alignment if
@@ -237,7 +246,10 @@ static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
qiov = &local_qiov;
}
- offset += s->offset;
+ ret = raw_adjust_offset(bs, &offset, bytes, true);
+ if (ret) {
+ goto fail;
+ }
BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
@@ -267,22 +279,24 @@ static int coroutine_fn raw_co_pwrite_zeroes(BlockDriverState *bs,
int64_t offset, int bytes,
BdrvRequestFlags flags)
{
- BDRVRawState *s = bs->opaque;
- if (offset > UINT64_MAX - s->offset) {
- return -EINVAL;
+ int ret;
+
+ ret = raw_adjust_offset(bs, (uint64_t *)&offset, bytes, true);
+ if (ret) {
+ return ret;
}
- offset += s->offset;
return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);
}
static int coroutine_fn raw_co_pdiscard(BlockDriverState *bs,
int64_t offset, int bytes)
{
- BDRVRawState *s = bs->opaque;
- if (offset > UINT64_MAX - s->offset) {
- return -EINVAL;
+ int ret;
+
+ ret = raw_adjust_offset(bs, (uint64_t *)&offset, bytes, true);
+ if (ret) {
+ return ret;
}
- offset += s->offset;
return bdrv_co_pdiscard(bs->file->bs, offset, bytes);
}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 03/11] raw: Implement copy offloading
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 01/11] block: Introduce API for copy offloading Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 02/11] raw: Check byte range uniformly Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 04/11] qcow2: " Stefan Hajnoczi
` (8 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
Just pass down to ->file.
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20180601092648.24614-4-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
block/raw-format.c | 32 ++++++++++++++++++++++++++++++++
1 file changed, 32 insertions(+)
diff --git a/block/raw-format.c b/block/raw-format.c
index b69a0674b3..f2e468df6f 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -497,6 +497,36 @@ static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
return bdrv_probe_geometry(bs->file->bs, geo);
}
+static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
+ BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ int ret;
+
+ ret = raw_adjust_offset(bs, &src_offset, bytes, false);
+ if (ret) {
+ return ret;
+ }
+ return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset,
+ bytes, flags);
+}
+
+static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
+ BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ int ret;
+
+ ret = raw_adjust_offset(bs, &dst_offset, bytes, true);
+ if (ret) {
+ return ret;
+ }
+ return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes,
+ flags);
+}
+
BlockDriver bdrv_raw = {
.format_name = "raw",
.instance_size = sizeof(BDRVRawState),
@@ -513,6 +543,8 @@ BlockDriver bdrv_raw = {
.bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
.bdrv_co_pdiscard = &raw_co_pdiscard,
.bdrv_co_block_status = &raw_co_block_status,
+ .bdrv_co_copy_range_from = &raw_co_copy_range_from,
+ .bdrv_co_copy_range_to = &raw_co_copy_range_to,
.bdrv_truncate = &raw_truncate,
.bdrv_getlength = &raw_getlength,
.has_variable_length = true,
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 04/11] qcow2: Implement copy offloading
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (2 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 03/11] raw: Implement copy offloading Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 05/11] file-posix: Implement bdrv_co_copy_range Stefan Hajnoczi
` (7 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
The two callbacks are implemented quite similarly to the read/write
functions: bdrv_co_copy_range_from maps for read and calls into bs->file
or bs->backing depending on the allocation status; bdrv_co_copy_range_to
maps for write and calls into bs->file.
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-id: 20180601092648.24614-5-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
block/qcow2.c | 229 +++++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 199 insertions(+), 30 deletions(-)
diff --git a/block/qcow2.c b/block/qcow2.c
index a007dc4246..79e5ed7fbb 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -1761,6 +1761,39 @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
return status;
}
+static coroutine_fn int qcow2_handle_l2meta(BlockDriverState *bs,
+ QCowL2Meta **pl2meta,
+ bool link_l2)
+{
+ int ret = 0;
+ QCowL2Meta *l2meta = *pl2meta;
+
+ while (l2meta != NULL) {
+ QCowL2Meta *next;
+
+ if (!ret && link_l2) {
+ ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
+ if (ret) {
+ goto out;
+ }
+ }
+
+ /* Take the request off the list of running requests */
+ if (l2meta->nb_clusters != 0) {
+ QLIST_REMOVE(l2meta, next_in_flight);
+ }
+
+ qemu_co_queue_restart_all(&l2meta->dependent_requests);
+
+ next = l2meta->next;
+ g_free(l2meta);
+ l2meta = next;
+ }
+out:
+ *pl2meta = l2meta;
+ return ret;
+}
+
static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov,
int flags)
@@ -2047,24 +2080,9 @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
}
}
- while (l2meta != NULL) {
- QCowL2Meta *next;
-
- ret = qcow2_alloc_cluster_link_l2(bs, l2meta);
- if (ret < 0) {
- goto fail;
- }
-
- /* Take the request off the list of running requests */
- if (l2meta->nb_clusters != 0) {
- QLIST_REMOVE(l2meta, next_in_flight);
- }
-
- qemu_co_queue_restart_all(&l2meta->dependent_requests);
-
- next = l2meta->next;
- g_free(l2meta);
- l2meta = next;
+ ret = qcow2_handle_l2meta(bs, &l2meta, true);
+ if (ret) {
+ goto fail;
}
bytes -= cur_bytes;
@@ -2075,18 +2093,7 @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
ret = 0;
fail:
- while (l2meta != NULL) {
- QCowL2Meta *next;
-
- if (l2meta->nb_clusters != 0) {
- QLIST_REMOVE(l2meta, next_in_flight);
- }
- qemu_co_queue_restart_all(&l2meta->dependent_requests);
-
- next = l2meta->next;
- g_free(l2meta);
- l2meta = next;
- }
+ qcow2_handle_l2meta(bs, &l2meta, false);
qemu_co_mutex_unlock(&s->lock);
@@ -3273,6 +3280,166 @@ static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs,
return ret;
}
+static int coroutine_fn
+qcow2_co_copy_range_from(BlockDriverState *bs,
+ BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ BDRVQcow2State *s = bs->opaque;
+ int ret;
+ unsigned int cur_bytes; /* number of bytes in current iteration */
+ BdrvChild *child = NULL;
+ BdrvRequestFlags cur_flags;
+
+ assert(!bs->encrypted);
+ qemu_co_mutex_lock(&s->lock);
+
+ while (bytes != 0) {
+ uint64_t copy_offset = 0;
+ /* prepare next request */
+ cur_bytes = MIN(bytes, INT_MAX);
+ cur_flags = flags;
+
+ ret = qcow2_get_cluster_offset(bs, src_offset, &cur_bytes, ©_offset);
+ if (ret < 0) {
+ goto out;
+ }
+
+ switch (ret) {
+ case QCOW2_CLUSTER_UNALLOCATED:
+ if (bs->backing && bs->backing->bs) {
+ int64_t backing_length = bdrv_getlength(bs->backing->bs);
+ if (src_offset >= backing_length) {
+ cur_flags |= BDRV_REQ_ZERO_WRITE;
+ } else {
+ child = bs->backing;
+ cur_bytes = MIN(cur_bytes, backing_length - src_offset);
+ copy_offset = src_offset;
+ }
+ } else {
+ cur_flags |= BDRV_REQ_ZERO_WRITE;
+ }
+ break;
+
+ case QCOW2_CLUSTER_ZERO_PLAIN:
+ case QCOW2_CLUSTER_ZERO_ALLOC:
+ cur_flags |= BDRV_REQ_ZERO_WRITE;
+ break;
+
+ case QCOW2_CLUSTER_COMPRESSED:
+ ret = -ENOTSUP;
+ goto out;
+ break;
+
+ case QCOW2_CLUSTER_NORMAL:
+ child = bs->file;
+ copy_offset += offset_into_cluster(s, src_offset);
+ if ((copy_offset & 511) != 0) {
+ ret = -EIO;
+ goto out;
+ }
+ break;
+
+ default:
+ abort();
+ }
+ qemu_co_mutex_unlock(&s->lock);
+ ret = bdrv_co_copy_range_from(child,
+ copy_offset,
+ dst, dst_offset,
+ cur_bytes, cur_flags);
+ qemu_co_mutex_lock(&s->lock);
+ if (ret < 0) {
+ goto out;
+ }
+
+ bytes -= cur_bytes;
+ src_offset += cur_bytes;
+ dst_offset += cur_bytes;
+ }
+ ret = 0;
+
+out:
+ qemu_co_mutex_unlock(&s->lock);
+ return ret;
+}
+
+static int coroutine_fn
+qcow2_co_copy_range_to(BlockDriverState *bs,
+ BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ BDRVQcow2State *s = bs->opaque;
+ int offset_in_cluster;
+ int ret;
+ unsigned int cur_bytes; /* number of sectors in current iteration */
+ uint64_t cluster_offset;
+ uint8_t *cluster_data = NULL;
+ QCowL2Meta *l2meta = NULL;
+
+ assert(!bs->encrypted);
+ s->cluster_cache_offset = -1; /* disable compressed cache */
+
+ qemu_co_mutex_lock(&s->lock);
+
+ while (bytes != 0) {
+
+ l2meta = NULL;
+
+ offset_in_cluster = offset_into_cluster(s, dst_offset);
+ cur_bytes = MIN(bytes, INT_MAX);
+
+ /* TODO:
+ * If src->bs == dst->bs, we could simply copy by incrementing
+ * the refcnt, without copying user data.
+ * Or if src->bs == dst->bs->backing->bs, we could copy by discarding. */
+ ret = qcow2_alloc_cluster_offset(bs, dst_offset, &cur_bytes,
+ &cluster_offset, &l2meta);
+ if (ret < 0) {
+ goto fail;
+ }
+
+ assert((cluster_offset & 511) == 0);
+
+ ret = qcow2_pre_write_overlap_check(bs, 0,
+ cluster_offset + offset_in_cluster, cur_bytes);
+ if (ret < 0) {
+ goto fail;
+ }
+
+ qemu_co_mutex_unlock(&s->lock);
+ ret = bdrv_co_copy_range_to(src, src_offset,
+ bs->file,
+ cluster_offset + offset_in_cluster,
+ cur_bytes, flags);
+ qemu_co_mutex_lock(&s->lock);
+ if (ret < 0) {
+ goto fail;
+ }
+
+ ret = qcow2_handle_l2meta(bs, &l2meta, true);
+ if (ret) {
+ goto fail;
+ }
+
+ bytes -= cur_bytes;
+ dst_offset += cur_bytes;
+ }
+ ret = 0;
+
+fail:
+ qcow2_handle_l2meta(bs, &l2meta, false);
+
+ qemu_co_mutex_unlock(&s->lock);
+
+ qemu_vfree(cluster_data);
+ trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
+
+ return ret;
+}
+
static int qcow2_truncate(BlockDriverState *bs, int64_t offset,
PreallocMode prealloc, Error **errp)
{
@@ -4521,6 +4688,8 @@ BlockDriver bdrv_qcow2 = {
.bdrv_co_pwrite_zeroes = qcow2_co_pwrite_zeroes,
.bdrv_co_pdiscard = qcow2_co_pdiscard,
+ .bdrv_co_copy_range_from = qcow2_co_copy_range_from,
+ .bdrv_co_copy_range_to = qcow2_co_copy_range_to,
.bdrv_truncate = qcow2_truncate,
.bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed,
.bdrv_make_empty = qcow2_make_empty,
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 05/11] file-posix: Implement bdrv_co_copy_range
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (3 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 04/11] qcow2: " Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 06/11] iscsi: Query and save device designator when opening Stefan Hajnoczi
` (6 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
With copy_file_range(2), we can implement the bdrv_co_copy_range
semantics.
Signed-off-by: Fam Zheng <famz@redhat.com>
Message-id: 20180601092648.24614-6-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
configure | 17 +++++++
include/block/raw-aio.h | 10 ++++-
block/file-posix.c | 98 +++++++++++++++++++++++++++++++++++++++--
3 files changed, 120 insertions(+), 5 deletions(-)
diff --git a/configure b/configure
index be6edc7b81..8c6ea9ba7f 100755
--- a/configure
+++ b/configure
@@ -5183,6 +5183,20 @@ if test "$fortify_source" != "no"; then
fi
fi
+###############################################
+# Check if copy_file_range is provided by glibc
+have_copy_file_range=no
+cat > $TMPC << EOF
+#include <unistd.h>
+int main(void) {
+ copy_file_range(0, NULL, 0, NULL, 0, 0);
+ return 0;
+}
+EOF
+if compile_prog "" "" ; then
+ have_copy_file_range=yes
+fi
+
##########################################
# check if struct fsxattr is available via linux/fs.h
@@ -6286,6 +6300,9 @@ fi
if test "$have_fsxattr" = "yes" ; then
echo "HAVE_FSXATTR=y" >> $config_host_mak
fi
+if test "$have_copy_file_range" = "yes" ; then
+ echo "HAVE_COPY_FILE_RANGE=y" >> $config_host_mak
+fi
if test "$vte" = "yes" ; then
echo "CONFIG_VTE=y" >> $config_host_mak
echo "VTE_CFLAGS=$vte_cflags" >> $config_host_mak
diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
index 9e47b8a629..0e717fd475 100644
--- a/include/block/raw-aio.h
+++ b/include/block/raw-aio.h
@@ -25,9 +25,15 @@
#define QEMU_AIO_FLUSH 0x0008
#define QEMU_AIO_DISCARD 0x0010
#define QEMU_AIO_WRITE_ZEROES 0x0020
+#define QEMU_AIO_COPY_RANGE 0x0040
#define QEMU_AIO_TYPE_MASK \
- (QEMU_AIO_READ|QEMU_AIO_WRITE|QEMU_AIO_IOCTL|QEMU_AIO_FLUSH| \
- QEMU_AIO_DISCARD|QEMU_AIO_WRITE_ZEROES)
+ (QEMU_AIO_READ | \
+ QEMU_AIO_WRITE | \
+ QEMU_AIO_IOCTL | \
+ QEMU_AIO_FLUSH | \
+ QEMU_AIO_DISCARD | \
+ QEMU_AIO_WRITE_ZEROES | \
+ QEMU_AIO_COPY_RANGE)
/* AIO flags */
#define QEMU_AIO_MISALIGNED 0x1000
diff --git a/block/file-posix.c b/block/file-posix.c
index 5a602cfe37..513d371bb1 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -59,6 +59,7 @@
#ifdef __linux__
#include <sys/ioctl.h>
#include <sys/param.h>
+#include <sys/syscall.h>
#include <linux/cdrom.h>
#include <linux/fd.h>
#include <linux/fs.h>
@@ -187,6 +188,8 @@ typedef struct RawPosixAIOData {
#define aio_ioctl_cmd aio_nbytes /* for QEMU_AIO_IOCTL */
off_t aio_offset;
int aio_type;
+ int aio_fd2;
+ off_t aio_offset2;
} RawPosixAIOData;
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
@@ -1446,6 +1449,49 @@ static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb)
return -ENOTSUP;
}
+#ifndef HAVE_COPY_FILE_RANGE
+static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,
+ off_t *out_off, size_t len, unsigned int flags)
+{
+#ifdef __NR_copy_file_range
+ return syscall(__NR_copy_file_range, in_fd, in_off, out_fd,
+ out_off, len, flags);
+#else
+ errno = ENOSYS;
+ return -1;
+#endif
+}
+#endif
+
+static ssize_t handle_aiocb_copy_range(RawPosixAIOData *aiocb)
+{
+ uint64_t bytes = aiocb->aio_nbytes;
+ off_t in_off = aiocb->aio_offset;
+ off_t out_off = aiocb->aio_offset2;
+
+ while (bytes) {
+ ssize_t ret = copy_file_range(aiocb->aio_fildes, &in_off,
+ aiocb->aio_fd2, &out_off,
+ bytes, 0);
+ if (ret == -EINTR) {
+ continue;
+ }
+ if (ret < 0) {
+ if (errno == ENOSYS) {
+ return -ENOTSUP;
+ } else {
+ return -errno;
+ }
+ }
+ if (!ret) {
+ /* No progress (e.g. when beyond EOF), fall back to buffer I/O. */
+ return -ENOTSUP;
+ }
+ bytes -= ret;
+ }
+ return 0;
+}
+
static ssize_t handle_aiocb_discard(RawPosixAIOData *aiocb)
{
int ret = -EOPNOTSUPP;
@@ -1526,6 +1572,9 @@ static int aio_worker(void *arg)
case QEMU_AIO_WRITE_ZEROES:
ret = handle_aiocb_write_zeroes(aiocb);
break;
+ case QEMU_AIO_COPY_RANGE:
+ ret = handle_aiocb_copy_range(aiocb);
+ break;
default:
fprintf(stderr, "invalid aio request (0x%x)\n", aiocb->aio_type);
ret = -EINVAL;
@@ -1536,9 +1585,10 @@ static int aio_worker(void *arg)
return ret;
}
-static int paio_submit_co(BlockDriverState *bs, int fd,
- int64_t offset, QEMUIOVector *qiov,
- int bytes, int type)
+static int paio_submit_co_full(BlockDriverState *bs, int fd,
+ int64_t offset, int fd2, int64_t offset2,
+ QEMUIOVector *qiov,
+ int bytes, int type)
{
RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
ThreadPool *pool;
@@ -1546,6 +1596,8 @@ static int paio_submit_co(BlockDriverState *bs, int fd,
acb->bs = bs;
acb->aio_type = type;
acb->aio_fildes = fd;
+ acb->aio_fd2 = fd2;
+ acb->aio_offset2 = offset2;
acb->aio_nbytes = bytes;
acb->aio_offset = offset;
@@ -1561,6 +1613,13 @@ static int paio_submit_co(BlockDriverState *bs, int fd,
return thread_pool_submit_co(pool, aio_worker, acb);
}
+static inline int paio_submit_co(BlockDriverState *bs, int fd,
+ int64_t offset, QEMUIOVector *qiov,
+ int bytes, int type)
+{
+ return paio_submit_co_full(bs, fd, offset, -1, 0, qiov, bytes, type);
+}
+
static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd,
int64_t offset, QEMUIOVector *qiov, int bytes,
BlockCompletionFunc *cb, void *opaque, int type)
@@ -2451,6 +2510,35 @@ static void raw_abort_perm_update(BlockDriverState *bs)
raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
}
+static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
+ BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes, flags);
+}
+
+static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
+ BdrvChild *src, uint64_t src_offset,
+ BdrvChild *dst, uint64_t dst_offset,
+ uint64_t bytes, BdrvRequestFlags flags)
+{
+ BDRVRawState *s = bs->opaque;
+ BDRVRawState *src_s;
+
+ assert(dst->bs == bs);
+ if (src->bs->drv->bdrv_co_copy_range_to != raw_co_copy_range_to) {
+ return -ENOTSUP;
+ }
+
+ src_s = src->bs->opaque;
+ if (fd_open(bs) < 0 || fd_open(bs) < 0) {
+ return -EIO;
+ }
+ return paio_submit_co_full(bs, src_s->fd, src_offset, s->fd, dst_offset,
+ NULL, bytes, QEMU_AIO_COPY_RANGE);
+}
+
BlockDriver bdrv_file = {
.format_name = "file",
.protocol_name = "file",
@@ -2474,6 +2562,8 @@ BlockDriver bdrv_file = {
.bdrv_co_pwritev = raw_co_pwritev,
.bdrv_aio_flush = raw_aio_flush,
.bdrv_aio_pdiscard = raw_aio_pdiscard,
+ .bdrv_co_copy_range_from = raw_co_copy_range_from,
+ .bdrv_co_copy_range_to = raw_co_copy_range_to,
.bdrv_refresh_limits = raw_refresh_limits,
.bdrv_io_plug = raw_aio_plug,
.bdrv_io_unplug = raw_aio_unplug,
@@ -2952,6 +3042,8 @@ static BlockDriver bdrv_host_device = {
.bdrv_co_pwritev = raw_co_pwritev,
.bdrv_aio_flush = raw_aio_flush,
.bdrv_aio_pdiscard = hdev_aio_pdiscard,
+ .bdrv_co_copy_range_from = raw_co_copy_range_from,
+ .bdrv_co_copy_range_to = raw_co_copy_range_to,
.bdrv_refresh_limits = raw_refresh_limits,
.bdrv_io_plug = raw_aio_plug,
.bdrv_io_unplug = raw_aio_unplug,
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 06/11] iscsi: Query and save device designator when opening
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (4 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 05/11] file-posix: Implement bdrv_co_copy_range Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 07/11] iscsi: Create and use iscsi_co_wait_for_task Stefan Hajnoczi
` (5 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
The device designator data returned in INQUIRY command will be useful to
fill in source/target fields during copy offloading. Do this when
connecting to the target and save the data for later use.
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20180601092648.24614-7-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
block/iscsi.c | 41 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 41 insertions(+)
diff --git a/block/iscsi.c b/block/iscsi.c
index 3fd7203916..6d0035d4b9 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -68,6 +68,7 @@ typedef struct IscsiLun {
QemuMutex mutex;
struct scsi_inquiry_logical_block_provisioning lbp;
struct scsi_inquiry_block_limits bl;
+ struct scsi_inquiry_device_designator *dd;
unsigned char *zeroblock;
/* The allocmap tracks which clusters (pages) on the iSCSI target are
* allocated and which are not. In case a target returns zeros for
@@ -1740,6 +1741,30 @@ static QemuOptsList runtime_opts = {
},
};
+static void iscsi_save_designator(IscsiLun *lun,
+ struct scsi_inquiry_device_identification *inq_di)
+{
+ struct scsi_inquiry_device_designator *desig, *copy = NULL;
+
+ for (desig = inq_di->designators; desig; desig = desig->next) {
+ if (desig->association ||
+ desig->designator_type > SCSI_DESIGNATOR_TYPE_NAA) {
+ continue;
+ }
+ /* NAA works better than T10 vendor ID based designator. */
+ if (!copy || copy->designator_type < desig->designator_type) {
+ copy = desig;
+ }
+ }
+ if (copy) {
+ lun->dd = g_new(struct scsi_inquiry_device_designator, 1);
+ *lun->dd = *copy;
+ lun->dd->next = NULL;
+ lun->dd->designator = g_malloc(copy->designator_length);
+ memcpy(lun->dd->designator, copy->designator, copy->designator_length);
+ }
+}
+
static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
@@ -1922,6 +1947,7 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
struct scsi_task *inq_task;
struct scsi_inquiry_logical_block_provisioning *inq_lbp;
struct scsi_inquiry_block_limits *inq_bl;
+ struct scsi_inquiry_device_identification *inq_di;
switch (inq_vpd->pages[i]) {
case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING:
inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
@@ -1947,6 +1973,17 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
sizeof(struct scsi_inquiry_block_limits));
scsi_free_scsi_task(inq_task);
break;
+ case SCSI_INQUIRY_PAGECODE_DEVICE_IDENTIFICATION:
+ inq_task = iscsi_do_inquiry(iscsilun->iscsi, iscsilun->lun, 1,
+ SCSI_INQUIRY_PAGECODE_DEVICE_IDENTIFICATION,
+ (void **) &inq_di, errp);
+ if (inq_task == NULL) {
+ ret = -EINVAL;
+ goto out;
+ }
+ iscsi_save_designator(iscsilun, inq_di);
+ scsi_free_scsi_task(inq_task);
+ break;
default:
break;
}
@@ -2003,6 +2040,10 @@ static void iscsi_close(BlockDriverState *bs)
iscsi_logout_sync(iscsi);
}
iscsi_destroy_context(iscsi);
+ if (iscsilun->dd) {
+ g_free(iscsilun->dd->designator);
+ g_free(iscsilun->dd);
+ }
g_free(iscsilun->zeroblock);
iscsi_allocmap_free(iscsilun);
qemu_mutex_destroy(&iscsilun->mutex);
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 07/11] iscsi: Create and use iscsi_co_wait_for_task
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (5 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 06/11] iscsi: Query and save device designator when opening Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 08/11] iscsi: Implement copy offloading Stefan Hajnoczi
` (4 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
This loop is repeated a growing number times. Make a helper.
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20180601092648.24614-8-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
block/iscsi.c | 54 ++++++++++++++++-----------------------------------
1 file changed, 17 insertions(+), 37 deletions(-)
diff --git a/block/iscsi.c b/block/iscsi.c
index 6d0035d4b9..6a365cb07b 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -556,6 +556,17 @@ static inline bool iscsi_allocmap_is_valid(IscsiLun *iscsilun,
offset / iscsilun->cluster_size) == size);
}
+static void coroutine_fn iscsi_co_wait_for_task(IscsiTask *iTask,
+ IscsiLun *iscsilun)
+{
+ while (!iTask->complete) {
+ iscsi_set_events(iscsilun);
+ qemu_mutex_unlock(&iscsilun->mutex);
+ qemu_coroutine_yield();
+ qemu_mutex_lock(&iscsilun->mutex);
+ }
+}
+
static int coroutine_fn
iscsi_co_writev(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
QEMUIOVector *iov, int flags)
@@ -617,12 +628,7 @@ retry:
scsi_task_set_iov_out(iTask.task, (struct scsi_iovec *) iov->iov,
iov->niov);
#endif
- while (!iTask.complete) {
- iscsi_set_events(iscsilun);
- qemu_mutex_unlock(&iscsilun->mutex);
- qemu_coroutine_yield();
- qemu_mutex_lock(&iscsilun->mutex);
- }
+ iscsi_co_wait_for_task(&iTask, iscsilun);
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
@@ -693,13 +699,7 @@ retry:
ret = -ENOMEM;
goto out_unlock;
}
-
- while (!iTask.complete) {
- iscsi_set_events(iscsilun);
- qemu_mutex_unlock(&iscsilun->mutex);
- qemu_coroutine_yield();
- qemu_mutex_lock(&iscsilun->mutex);
- }
+ iscsi_co_wait_for_task(&iTask, iscsilun);
if (iTask.do_retry) {
if (iTask.task != NULL) {
@@ -863,13 +863,8 @@ retry:
#if LIBISCSI_API_VERSION < (20160603)
scsi_task_set_iov_in(iTask.task, (struct scsi_iovec *) iov->iov, iov->niov);
#endif
- while (!iTask.complete) {
- iscsi_set_events(iscsilun);
- qemu_mutex_unlock(&iscsilun->mutex);
- qemu_coroutine_yield();
- qemu_mutex_lock(&iscsilun->mutex);
- }
+ iscsi_co_wait_for_task(&iTask, iscsilun);
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
iTask.task = NULL;
@@ -906,12 +901,7 @@ retry:
return -ENOMEM;
}
- while (!iTask.complete) {
- iscsi_set_events(iscsilun);
- qemu_mutex_unlock(&iscsilun->mutex);
- qemu_coroutine_yield();
- qemu_mutex_lock(&iscsilun->mutex);
- }
+ iscsi_co_wait_for_task(&iTask, iscsilun);
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
@@ -1143,12 +1133,7 @@ retry:
goto out_unlock;
}
- while (!iTask.complete) {
- iscsi_set_events(iscsilun);
- qemu_mutex_unlock(&iscsilun->mutex);
- qemu_coroutine_yield();
- qemu_mutex_lock(&iscsilun->mutex);
- }
+ iscsi_co_wait_for_task(&iTask, iscsilun);
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
@@ -1244,12 +1229,7 @@ retry:
return -ENOMEM;
}
- while (!iTask.complete) {
- iscsi_set_events(iscsilun);
- qemu_mutex_unlock(&iscsilun->mutex);
- qemu_coroutine_yield();
- qemu_mutex_lock(&iscsilun->mutex);
- }
+ iscsi_co_wait_for_task(&iTask, iscsilun);
if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&
iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 08/11] iscsi: Implement copy offloading
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (6 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 07/11] iscsi: Create and use iscsi_co_wait_for_task Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 09/11] block-backend: Add blk_co_copy_range Stefan Hajnoczi
` (3 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
Issue EXTENDED COPY (LID1) command to implement the copy_range API.
The parameter data construction code is modified from libiscsi's
iscsi-dd.c.
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20180601092648.24614-9-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
include/scsi/constants.h | 4 +
block/iscsi.c | 219 +++++++++++++++++++++++++++++++++++++++
2 files changed, 223 insertions(+)
diff --git a/include/scsi/constants.h b/include/scsi/constants.h
index a141dd71f8..083a8e887a 100644
--- a/include/scsi/constants.h
+++ b/include/scsi/constants.h
@@ -311,4 +311,8 @@
#define MMC_PROFILE_HDDVD_RW_DL 0x005A
#define MMC_PROFILE_INVALID 0xFFFF
+#define XCOPY_DESC_OFFSET 16
+#define IDENT_DESCR_TGT_DESCR_SIZE 32
+#define XCOPY_BLK2BLK_SEG_DESC_SIZE 28
+
#endif
diff --git a/block/iscsi.c b/block/iscsi.c
index 6a365cb07b..c2fbd8a8aa 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -2205,6 +2205,221 @@ static void coroutine_fn iscsi_co_invalidate_cache(BlockDriverState *bs,
iscsi_allocmap_invalidate(iscsilun);
}
+static int coroutine_fn iscsi_co_copy_range_from(BlockDriverState *bs,
+ BdrvChild *src,
+ uint64_t src_offset,
+ BdrvChild *dst,
+ uint64_t dst_offset,
+ uint64_t bytes,
+ BdrvRequestFlags flags)
+{
+ return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes, flags);
+}
+
+static struct scsi_task *iscsi_xcopy_task(int param_len)
+{
+ struct scsi_task *task;
+
+ task = g_new0(struct scsi_task, 1);
+
+ task->cdb[0] = EXTENDED_COPY;
+ task->cdb[10] = (param_len >> 24) & 0xFF;
+ task->cdb[11] = (param_len >> 16) & 0xFF;
+ task->cdb[12] = (param_len >> 8) & 0xFF;
+ task->cdb[13] = param_len & 0xFF;
+ task->cdb_size = 16;
+ task->xfer_dir = SCSI_XFER_WRITE;
+ task->expxferlen = param_len;
+
+ return task;
+}
+
+static void iscsi_populate_target_desc(unsigned char *desc, IscsiLun *lun)
+{
+ struct scsi_inquiry_device_designator *dd = lun->dd;
+
+ memset(desc, 0, 32);
+ desc[0] = 0xE4; /* IDENT_DESCR_TGT_DESCR */
+ desc[4] = dd->code_set;
+ desc[5] = (dd->designator_type & 0xF)
+ | ((dd->association & 3) << 4);
+ desc[7] = dd->designator_length;
+ memcpy(desc + 8, dd->designator, dd->designator_length);
+
+ desc[28] = 0;
+ desc[29] = (lun->block_size >> 16) & 0xFF;
+ desc[30] = (lun->block_size >> 8) & 0xFF;
+ desc[31] = lun->block_size & 0xFF;
+}
+
+static void iscsi_xcopy_desc_hdr(uint8_t *hdr, int dc, int cat, int src_index,
+ int dst_index)
+{
+ hdr[0] = 0x02; /* BLK_TO_BLK_SEG_DESCR */
+ hdr[1] = ((dc << 1) | cat) & 0xFF;
+ hdr[2] = (XCOPY_BLK2BLK_SEG_DESC_SIZE >> 8) & 0xFF;
+ /* don't account for the first 4 bytes in descriptor header*/
+ hdr[3] = (XCOPY_BLK2BLK_SEG_DESC_SIZE - 4 /* SEG_DESC_SRC_INDEX_OFFSET */) & 0xFF;
+ hdr[4] = (src_index >> 8) & 0xFF;
+ hdr[5] = src_index & 0xFF;
+ hdr[6] = (dst_index >> 8) & 0xFF;
+ hdr[7] = dst_index & 0xFF;
+}
+
+static void iscsi_xcopy_populate_desc(uint8_t *desc, int dc, int cat,
+ int src_index, int dst_index, int num_blks,
+ uint64_t src_lba, uint64_t dst_lba)
+{
+ iscsi_xcopy_desc_hdr(desc, dc, cat, src_index, dst_index);
+
+ /* The caller should verify the request size */
+ assert(num_blks < 65536);
+ desc[10] = (num_blks >> 8) & 0xFF;
+ desc[11] = num_blks & 0xFF;
+ desc[12] = (src_lba >> 56) & 0xFF;
+ desc[13] = (src_lba >> 48) & 0xFF;
+ desc[14] = (src_lba >> 40) & 0xFF;
+ desc[15] = (src_lba >> 32) & 0xFF;
+ desc[16] = (src_lba >> 24) & 0xFF;
+ desc[17] = (src_lba >> 16) & 0xFF;
+ desc[18] = (src_lba >> 8) & 0xFF;
+ desc[19] = src_lba & 0xFF;
+ desc[20] = (dst_lba >> 56) & 0xFF;
+ desc[21] = (dst_lba >> 48) & 0xFF;
+ desc[22] = (dst_lba >> 40) & 0xFF;
+ desc[23] = (dst_lba >> 32) & 0xFF;
+ desc[24] = (dst_lba >> 24) & 0xFF;
+ desc[25] = (dst_lba >> 16) & 0xFF;
+ desc[26] = (dst_lba >> 8) & 0xFF;
+ desc[27] = dst_lba & 0xFF;
+}
+
+static void iscsi_xcopy_populate_header(unsigned char *buf, int list_id, int str,
+ int list_id_usage, int prio,
+ int tgt_desc_len,
+ int seg_desc_len, int inline_data_len)
+{
+ buf[0] = list_id;
+ buf[1] = ((str & 1) << 5) | ((list_id_usage & 3) << 3) | (prio & 7);
+ buf[2] = (tgt_desc_len >> 8) & 0xFF;
+ buf[3] = tgt_desc_len & 0xFF;
+ buf[8] = (seg_desc_len >> 24) & 0xFF;
+ buf[9] = (seg_desc_len >> 16) & 0xFF;
+ buf[10] = (seg_desc_len >> 8) & 0xFF;
+ buf[11] = seg_desc_len & 0xFF;
+ buf[12] = (inline_data_len >> 24) & 0xFF;
+ buf[13] = (inline_data_len >> 16) & 0xFF;
+ buf[14] = (inline_data_len >> 8) & 0xFF;
+ buf[15] = inline_data_len & 0xFF;
+}
+
+static void iscsi_xcopy_data(struct iscsi_data *data,
+ IscsiLun *src, int64_t src_lba,
+ IscsiLun *dst, int64_t dst_lba,
+ uint16_t num_blocks)
+{
+ uint8_t *buf;
+ const int src_offset = XCOPY_DESC_OFFSET;
+ const int dst_offset = XCOPY_DESC_OFFSET + IDENT_DESCR_TGT_DESCR_SIZE;
+ const int seg_offset = dst_offset + IDENT_DESCR_TGT_DESCR_SIZE;
+
+ data->size = XCOPY_DESC_OFFSET +
+ IDENT_DESCR_TGT_DESCR_SIZE * 2 +
+ XCOPY_BLK2BLK_SEG_DESC_SIZE;
+ data->data = g_malloc0(data->size);
+ buf = data->data;
+
+ /* Initialise the parameter list header */
+ iscsi_xcopy_populate_header(buf, 1, 0, 2 /* LIST_ID_USAGE_DISCARD */,
+ 0, 2 * IDENT_DESCR_TGT_DESCR_SIZE,
+ XCOPY_BLK2BLK_SEG_DESC_SIZE,
+ 0);
+
+ /* Initialise CSCD list with one src + one dst descriptor */
+ iscsi_populate_target_desc(&buf[src_offset], src);
+ iscsi_populate_target_desc(&buf[dst_offset], dst);
+
+ /* Initialise one segment descriptor */
+ iscsi_xcopy_populate_desc(&buf[seg_offset], 0, 0, 0, 1, num_blocks,
+ src_lba, dst_lba);
+}
+
+static int coroutine_fn iscsi_co_copy_range_to(BlockDriverState *bs,
+ BdrvChild *src,
+ uint64_t src_offset,
+ BdrvChild *dst,
+ uint64_t dst_offset,
+ uint64_t bytes,
+ BdrvRequestFlags flags)
+{
+ IscsiLun *dst_lun = dst->bs->opaque;
+ IscsiLun *src_lun;
+ struct IscsiTask iscsi_task;
+ struct iscsi_data data;
+ int r = 0;
+ int block_size;
+
+ if (src->bs->drv->bdrv_co_copy_range_to != iscsi_co_copy_range_to) {
+ return -ENOTSUP;
+ }
+ src_lun = src->bs->opaque;
+
+ if (!src_lun->dd || !dst_lun->dd) {
+ return -ENOTSUP;
+ }
+ if (!is_byte_request_lun_aligned(dst_offset, bytes, dst_lun)) {
+ return -ENOTSUP;
+ }
+ if (!is_byte_request_lun_aligned(src_offset, bytes, src_lun)) {
+ return -ENOTSUP;
+ }
+ if (dst_lun->block_size != src_lun->block_size ||
+ !dst_lun->block_size) {
+ return -ENOTSUP;
+ }
+
+ block_size = dst_lun->block_size;
+ if (bytes / block_size > 65535) {
+ return -ENOTSUP;
+ }
+
+ iscsi_xcopy_data(&data,
+ src_lun, src_offset / block_size,
+ dst_lun, dst_offset / block_size,
+ bytes / block_size);
+
+ iscsi_co_init_iscsitask(dst_lun, &iscsi_task);
+
+ qemu_mutex_lock(&dst_lun->mutex);
+ iscsi_task.task = iscsi_xcopy_task(data.size);
+retry:
+ if (iscsi_scsi_command_async(dst_lun->iscsi, dst_lun->lun,
+ iscsi_task.task, iscsi_co_generic_cb,
+ &data,
+ &iscsi_task) != 0) {
+ r = -EIO;
+ goto out_unlock;
+ }
+
+ iscsi_co_wait_for_task(&iscsi_task, dst_lun);
+
+ if (iscsi_task.do_retry) {
+ iscsi_task.complete = 0;
+ goto retry;
+ }
+
+ if (iscsi_task.status != SCSI_STATUS_GOOD) {
+ r = iscsi_task.err_code;
+ goto out_unlock;
+ }
+
+out_unlock:
+ g_free(iscsi_task.task);
+ qemu_mutex_unlock(&dst_lun->mutex);
+ g_free(iscsi_task.err_str);
+ return r;
+}
+
static QemuOptsList iscsi_create_opts = {
.name = "iscsi-create-opts",
.head = QTAILQ_HEAD_INITIALIZER(iscsi_create_opts.head),
@@ -2239,6 +2454,8 @@ static BlockDriver bdrv_iscsi = {
.bdrv_co_block_status = iscsi_co_block_status,
.bdrv_co_pdiscard = iscsi_co_pdiscard,
+ .bdrv_co_copy_range_from = iscsi_co_copy_range_from,
+ .bdrv_co_copy_range_to = iscsi_co_copy_range_to,
.bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes,
.bdrv_co_readv = iscsi_co_readv,
.bdrv_co_writev = iscsi_co_writev,
@@ -2274,6 +2491,8 @@ static BlockDriver bdrv_iser = {
.bdrv_co_block_status = iscsi_co_block_status,
.bdrv_co_pdiscard = iscsi_co_pdiscard,
+ .bdrv_co_copy_range_from = iscsi_co_copy_range_from,
+ .bdrv_co_copy_range_to = iscsi_co_copy_range_to,
.bdrv_co_pwrite_zeroes = iscsi_co_pwrite_zeroes,
.bdrv_co_readv = iscsi_co_readv,
.bdrv_co_writev = iscsi_co_writev,
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 09/11] block-backend: Add blk_co_copy_range
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (7 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 08/11] iscsi: Implement copy offloading Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 10/11] qemu-img: Convert with copy offloading Stefan Hajnoczi
` (2 subsequent siblings)
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
It's a BlockBackend wrapper of the BDS interface.
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20180601092648.24614-10-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
include/sysemu/block-backend.h | 4 ++++
block/block-backend.c | 18 ++++++++++++++++++
2 files changed, 22 insertions(+)
diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
index 92ab624fac..8d03d493c2 100644
--- a/include/sysemu/block-backend.h
+++ b/include/sysemu/block-backend.h
@@ -232,4 +232,8 @@ void blk_set_force_allow_inactivate(BlockBackend *blk);
void blk_register_buf(BlockBackend *blk, void *host, size_t size);
void blk_unregister_buf(BlockBackend *blk, void *host);
+int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
+ BlockBackend *blk_out, int64_t off_out,
+ int bytes, BdrvRequestFlags flags);
+
#endif
diff --git a/block/block-backend.c b/block/block-backend.c
index 89f47b00ea..d55c328736 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -2211,3 +2211,21 @@ void blk_unregister_buf(BlockBackend *blk, void *host)
{
bdrv_unregister_buf(blk_bs(blk), host);
}
+
+int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
+ BlockBackend *blk_out, int64_t off_out,
+ int bytes, BdrvRequestFlags flags)
+{
+ int r;
+ r = blk_check_byte_request(blk_in, off_in, bytes);
+ if (r) {
+ return r;
+ }
+ r = blk_check_byte_request(blk_out, off_out, bytes);
+ if (r) {
+ return r;
+ }
+ return bdrv_co_copy_range(blk_in->root, off_in,
+ blk_out->root, off_out,
+ bytes, flags);
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 10/11] qemu-img: Convert with copy offloading
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (8 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 09/11] block-backend: Add blk_co_copy_range Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 11/11] main-loop: drop spin_counter Stefan Hajnoczi
2018-06-05 9:38 ` [Qemu-devel] [PULL 00/11] Block patches Peter Maydell
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
From: Fam Zheng <famz@redhat.com>
The new blk_co_copy_range interface offers a more efficient way in the
case of network based storage. Make use of it to allow faster convert
operation.
Since copy offloading cannot do zero detection ('-S') and compression
(-c), only try it when these options are not used.
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20180601092648.24614-11-famz@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
qemu-img.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 48 insertions(+), 2 deletions(-)
diff --git a/qemu-img.c b/qemu-img.c
index 976b437da0..75f1610aa0 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -1547,6 +1547,7 @@ typedef struct ImgConvertState {
bool compressed;
bool target_has_backing;
bool wr_in_order;
+ bool copy_range;
int min_sparse;
size_t cluster_sectors;
size_t buf_sectors;
@@ -1740,6 +1741,37 @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
return 0;
}
+static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector_num,
+ int nb_sectors)
+{
+ int n, ret;
+
+ while (nb_sectors > 0) {
+ BlockBackend *blk;
+ int src_cur;
+ int64_t bs_sectors, src_cur_offset;
+ int64_t offset;
+
+ convert_select_part(s, sector_num, &src_cur, &src_cur_offset);
+ offset = (sector_num - src_cur_offset) << BDRV_SECTOR_BITS;
+ blk = s->src[src_cur];
+ bs_sectors = s->src_sectors[src_cur];
+
+ n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
+
+ ret = blk_co_copy_range(blk, offset, s->target,
+ sector_num << BDRV_SECTOR_BITS,
+ n << BDRV_SECTOR_BITS, 0);
+ if (ret < 0) {
+ return ret;
+ }
+
+ sector_num += n;
+ nb_sectors -= n;
+ }
+ return 0;
+}
+
static void coroutine_fn convert_co_do_copy(void *opaque)
{
ImgConvertState *s = opaque;
@@ -1762,6 +1794,7 @@ static void coroutine_fn convert_co_do_copy(void *opaque)
int n;
int64_t sector_num;
enum ImgConvertBlockStatus status;
+ bool copy_range;
qemu_co_mutex_lock(&s->lock);
if (s->ret != -EINPROGRESS || s->sector_num >= s->total_sectors) {
@@ -1791,7 +1824,9 @@ static void coroutine_fn convert_co_do_copy(void *opaque)
s->allocated_sectors, 0);
}
- if (status == BLK_DATA) {
+retry:
+ copy_range = s->copy_range && s->status == BLK_DATA;
+ if (status == BLK_DATA && !copy_range) {
ret = convert_co_read(s, sector_num, n, buf);
if (ret < 0) {
error_report("error while reading sector %" PRId64
@@ -1813,7 +1848,15 @@ static void coroutine_fn convert_co_do_copy(void *opaque)
}
if (s->ret == -EINPROGRESS) {
- ret = convert_co_write(s, sector_num, n, buf, status);
+ if (copy_range) {
+ ret = convert_co_copy_range(s, sector_num, n);
+ if (ret) {
+ s->copy_range = false;
+ goto retry;
+ }
+ } else {
+ ret = convert_co_write(s, sector_num, n, buf, status);
+ }
if (ret < 0) {
error_report("error while writing sector %" PRId64
": %s", sector_num, strerror(-ret));
@@ -1936,6 +1979,7 @@ static int img_convert(int argc, char **argv)
ImgConvertState s = (ImgConvertState) {
/* Need at least 4k of zeros for sparse detection */
.min_sparse = 8,
+ .copy_range = true,
.buf_sectors = IO_BUF_SIZE / BDRV_SECTOR_SIZE,
.wr_in_order = true,
.num_coroutines = 8,
@@ -1976,6 +2020,7 @@ static int img_convert(int argc, char **argv)
break;
case 'c':
s.compressed = true;
+ s.copy_range = false;
break;
case 'o':
if (!is_valid_option_list(optarg)) {
@@ -2017,6 +2062,7 @@ static int img_convert(int argc, char **argv)
}
s.min_sparse = sval / BDRV_SECTOR_SIZE;
+ s.copy_range = false;
break;
}
case 'p':
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 11/11] main-loop: drop spin_counter
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (9 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 10/11] qemu-img: Convert with copy offloading Stefan Hajnoczi
@ 2018-06-04 11:20 ` Stefan Hajnoczi
2018-06-05 9:38 ` [Qemu-devel] [PULL 00/11] Block patches Peter Maydell
11 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2018-06-04 11:20 UTC (permalink / raw)
To: qemu-devel
Cc: Ronnie Sahlberg, Peter Maydell, qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng, Stefan Hajnoczi
Commit d759c951f3287fad04210a52f2dc93f94cf58c7f ("replay: push
replay_mutex_lock up the call tree") removed the !timeout lock
optimization in the main loop.
The idea of the optimization was to avoid ping-pongs between threads by
keeping the Big QEMU Lock held across non-blocking (!timeout) main loop
iterations.
A warning is printed when the main loop spins without releasing BQL for
long periods of time. These warnings were supposed to aid debugging but
in practice they just alarm users. They are considered noise because
the cause of spinning is not shown and is hard to find.
Now that the lock optimization has been removed, there is no danger of
hogging the BQL. Drop the spin counter and the infamous warning.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
---
util/main-loop.c | 25 -------------------------
tests/qemu-iotests/common.filter | 1 -
2 files changed, 26 deletions(-)
diff --git a/util/main-loop.c b/util/main-loop.c
index 992f9b0f34..affe0403c5 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -222,36 +222,11 @@ static int os_host_main_loop_wait(int64_t timeout)
{
GMainContext *context = g_main_context_default();
int ret;
- static int spin_counter;
g_main_context_acquire(context);
glib_pollfds_fill(&timeout);
- /* If the I/O thread is very busy or we are incorrectly busy waiting in
- * the I/O thread, this can lead to starvation of the BQL such that the
- * VCPU threads never run. To make sure we can detect the later case,
- * print a message to the screen. If we run into this condition, create
- * a fake timeout in order to give the VCPU threads a chance to run.
- */
- if (!timeout && (spin_counter > MAX_MAIN_LOOP_SPIN)) {
- static bool notified;
-
- if (!notified && !qtest_enabled() && !qtest_driver()) {
- warn_report("I/O thread spun for %d iterations",
- MAX_MAIN_LOOP_SPIN);
- notified = true;
- }
-
- timeout = SCALE_MS;
- }
-
-
- if (timeout) {
- spin_counter = 0;
- } else {
- spin_counter++;
- }
qemu_mutex_unlock_iothread();
replay_mutex_unlock();
diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
index f08ee55046..2031e353a5 100644
--- a/tests/qemu-iotests/common.filter
+++ b/tests/qemu-iotests/common.filter
@@ -77,7 +77,6 @@ _filter_qemu()
{
sed -e "s#\\(^\\|(qemu) \\)$(basename $QEMU_PROG):#\1QEMU_PROG:#" \
-e 's#^QEMU [0-9]\+\.[0-9]\+\.[0-9]\+ monitor#QEMU X.Y.Z monitor#' \
- -e '/main-loop: WARNING: I\/O thread spun for [0-9]\+ iterations/d' \
-e $'s#\r##' # QEMU monitor uses \r\n line endings
}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
` (10 preceding siblings ...)
2018-06-04 11:20 ` [Qemu-devel] [PULL 11/11] main-loop: drop spin_counter Stefan Hajnoczi
@ 2018-06-05 9:38 ` Peter Maydell
11 siblings, 0 replies; 40+ messages in thread
From: Peter Maydell @ 2018-06-05 9:38 UTC (permalink / raw)
To: Stefan Hajnoczi
Cc: QEMU Developers, Ronnie Sahlberg, Qemu-block, Peter Lieven,
Max Reitz, Paolo Bonzini, Kevin Wolf, Fam Zheng
On 4 June 2018 at 12:20, Stefan Hajnoczi <stefanha@redhat.com> wrote:
> The following changes since commit c25e8bba1f546ea72744ccfab77f8a9e8a323be8:
>
> Merge remote-tracking branch 'remotes/otubo/tags/pull-seccomp-20180601' into staging (2018-06-01 13:11:30 +0100)
>
> are available in the Git repository at:
>
> git://github.com/stefanha/qemu.git tags/block-pull-request
>
> for you to fetch changes up to 21891a5a3011608845b5d7f1f9cce60cdc2bcc62:
>
> main-loop: drop spin_counter (2018-06-01 16:01:29 +0100)
>
> ----------------------------------------------------------------
> Pull request
>
> * Copy offloading for qemu-img convert (iSCSI, raw, and qcow2)
>
> If the underlying storage supports copy offloading, qemu-img convert will
> use it instead of performing reads and writes. This avoids data transfers
> and thus frees up storage bandwidth for other purposes. SCSI EXTENDED COPY
> and Linux copy_file_range(2) are used to implement this optimization.
>
> * Drop spurious "WARNING: I\/O thread spun for 1000 iterations" warning
>
> ----------------------------------------------------------------
Applied, thanks.
-- PMM
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2019-05-09 13:27 ` Max Reitz
@ 2019-05-09 16:17 ` Peter Maydell
0 siblings, 0 replies; 40+ messages in thread
From: Peter Maydell @ 2019-05-09 16:17 UTC (permalink / raw)
To: Max Reitz; +Cc: Kevin Wolf, QEMU Developers, Qemu-block
On Thu, 9 May 2019 at 14:27, Max Reitz <mreitz@redhat.com> wrote:
>
> On 09.05.19 10:49, Peter Maydell wrote:
> > On Tue, 7 May 2019 at 16:18, Max Reitz <mreitz@redhat.com> wrote:
> >>
> >> The following changes since commit 19eb2d4e736dc895f31fbd6b520e514f10cc08e0:
> >>
> >> Merge remote-tracking branch 'remotes/thibault/tags/samuel-thibault' into staging (2019-05-07 10:43:32 +0100)
> >>
> >> are available in the Git repository at:
> >>
> >> https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2019-05-07
> >>
> >> for you to fetch changes up to 1278dce7927301bf3d004a40061dbd2c1e0846a8:
> >>
> >> iotests: Fix iotests 110 and 126 (2019-05-07 17:14:21 +0200)
> >
> > Attempting to fetch from this remote hangs:
> >
> > $ git fetch -v xanclic
> > POST git-upload-pack (gzip 1798 to 966 bytes)
> > POST git-upload-pack (gzip 1798 to 965 bytes)
> > POST git-upload-pack (gzip 2648 to 1393 bytes)
> > POST git-upload-pack (gzip 4248 to 2201 bytes)
> > POST git-upload-pack (gzip 7498 to 3833 bytes)
> > POST git-upload-pack (gzip 13998 to 7092 bytes)
> > POST git-upload-pack (gzip 27648 to 13930 bytes)
> > POST git-upload-pack (gzip 55148 to 27782 bytes)
> > POST git-upload-pack (gzip 108948 to 54371 bytes)
> > POST git-upload-pack (gzip 215798 to 107233 bytes)
> > [no further output]
>
> Hm, that's unfortunate. It works for me. (At least now.)
>
> I've pushed the tag to Github:
>
> https://github.com/XanClic/qemu.git tags/pull-block-2019-05-07
>
> I hope that works better.
Yep, that worked fine: I've applied that.
Please update the changelog at https://wiki.qemu.org/ChangeLog/4.1
for any user-visible changes.
(Strace says that we seem to successfully connect to
the git.xanclic.moe server and do some talking to it,
but the first time the client issues a "fetch" command
the server never replies and the client is just blocked
in read().)
thanks
-- PMM
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2019-05-09 8:49 ` Peter Maydell
@ 2019-05-09 13:27 ` Max Reitz
2019-05-09 16:17 ` Peter Maydell
0 siblings, 1 reply; 40+ messages in thread
From: Max Reitz @ 2019-05-09 13:27 UTC (permalink / raw)
To: Peter Maydell; +Cc: Kevin Wolf, QEMU Developers, Qemu-block
[-- Attachment #1: Type: text/plain, Size: 1441 bytes --]
On 09.05.19 10:49, Peter Maydell wrote:
> On Tue, 7 May 2019 at 16:18, Max Reitz <mreitz@redhat.com> wrote:
>>
>> The following changes since commit 19eb2d4e736dc895f31fbd6b520e514f10cc08e0:
>>
>> Merge remote-tracking branch 'remotes/thibault/tags/samuel-thibault' into staging (2019-05-07 10:43:32 +0100)
>>
>> are available in the Git repository at:
>>
>> https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2019-05-07
>>
>> for you to fetch changes up to 1278dce7927301bf3d004a40061dbd2c1e0846a8:
>>
>> iotests: Fix iotests 110 and 126 (2019-05-07 17:14:21 +0200)
>
> Attempting to fetch from this remote hangs:
>
> $ git fetch -v xanclic
> POST git-upload-pack (gzip 1798 to 966 bytes)
> POST git-upload-pack (gzip 1798 to 965 bytes)
> POST git-upload-pack (gzip 2648 to 1393 bytes)
> POST git-upload-pack (gzip 4248 to 2201 bytes)
> POST git-upload-pack (gzip 7498 to 3833 bytes)
> POST git-upload-pack (gzip 13998 to 7092 bytes)
> POST git-upload-pack (gzip 27648 to 13930 bytes)
> POST git-upload-pack (gzip 55148 to 27782 bytes)
> POST git-upload-pack (gzip 108948 to 54371 bytes)
> POST git-upload-pack (gzip 215798 to 107233 bytes)
> [no further output]
Hm, that's unfortunate. It works for me. (At least now.)
I've pushed the tag to Github:
https://github.com/XanClic/qemu.git tags/pull-block-2019-05-07
I hope that works better.
Sorry for the inconvenience,
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2019-05-07 15:18 Max Reitz
@ 2019-05-09 8:49 ` Peter Maydell
2019-05-09 13:27 ` Max Reitz
0 siblings, 1 reply; 40+ messages in thread
From: Peter Maydell @ 2019-05-09 8:49 UTC (permalink / raw)
To: Max Reitz; +Cc: Kevin Wolf, QEMU Developers, Qemu-block
On Tue, 7 May 2019 at 16:18, Max Reitz <mreitz@redhat.com> wrote:
>
> The following changes since commit 19eb2d4e736dc895f31fbd6b520e514f10cc08e0:
>
> Merge remote-tracking branch 'remotes/thibault/tags/samuel-thibault' into staging (2019-05-07 10:43:32 +0100)
>
> are available in the Git repository at:
>
> https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2019-05-07
>
> for you to fetch changes up to 1278dce7927301bf3d004a40061dbd2c1e0846a8:
>
> iotests: Fix iotests 110 and 126 (2019-05-07 17:14:21 +0200)
Attempting to fetch from this remote hangs:
$ git fetch -v xanclic
POST git-upload-pack (gzip 1798 to 966 bytes)
POST git-upload-pack (gzip 1798 to 965 bytes)
POST git-upload-pack (gzip 2648 to 1393 bytes)
POST git-upload-pack (gzip 4248 to 2201 bytes)
POST git-upload-pack (gzip 7498 to 3833 bytes)
POST git-upload-pack (gzip 13998 to 7092 bytes)
POST git-upload-pack (gzip 27648 to 13930 bytes)
POST git-upload-pack (gzip 55148 to 27782 bytes)
POST git-upload-pack (gzip 108948 to 54371 bytes)
POST git-upload-pack (gzip 215798 to 107233 bytes)
[no further output]
thanks
-- PMM
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2019-05-07 15:18 Max Reitz
2019-05-09 8:49 ` Peter Maydell
0 siblings, 1 reply; 40+ messages in thread
From: Max Reitz @ 2019-05-07 15:18 UTC (permalink / raw)
To: qemu-block; +Cc: Kevin Wolf, Peter Maydell, qemu-devel, Max Reitz
The following changes since commit 19eb2d4e736dc895f31fbd6b520e514f10cc08e0:
Merge remote-tracking branch 'remotes/thibault/tags/samuel-thibault' into staging (2019-05-07 10:43:32 +0100)
are available in the Git repository at:
https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2019-05-07
for you to fetch changes up to 1278dce7927301bf3d004a40061dbd2c1e0846a8:
iotests: Fix iotests 110 and 126 (2019-05-07 17:14:21 +0200)
----------------------------------------------------------------
Block patches:
- Fixes to qcow2's implementation of qemu-img check
- Our SSH driver now supports bdrv_refresh_filename()
- Miscellaneous fixes
----------------------------------------------------------------
Alberto Garcia (2):
block: Assert that drv->bdrv_child_perm is set in bdrv_child_perm()
commit: Use bdrv_append() in commit_start()
Andrey Shinkevich (1):
qcow2: discard bitmap when removed
Max Reitz (3):
block/ssh: Implement .bdrv_refresh_filename()
block/ssh: Implement .bdrv_dirname()
iotests: Fix iotests 110 and 126
Vladimir Sementsov-Ogievskiy (5):
qcow2-refcount: fix check_oflag_copied
qcow2-refcount: avoid eating RAM
qcow2-refcount: check_refcounts_l2: reduce ignored overlaps
qcow2-refcount: check_refcounts_l2: don't count fixed cluster as
allocated
qcow2-refcount: don't mask corruptions under internal errors
block.c | 9 ++--
block/commit.c | 11 +----
block/qcow2-bitmap.c | 2 +-
block/qcow2-refcount.c | 80 ++++++++++++++++++++++-------------
block/ssh.c | 73 +++++++++++++++++++++++++++++---
tests/qemu-iotests/110 | 10 +++--
tests/qemu-iotests/126 | 10 +++--
tests/qemu-iotests/138 | 12 +++---
tests/qemu-iotests/138.out | 5 ++-
tests/qemu-iotests/207 | 10 ++---
tests/qemu-iotests/207.out | 10 ++---
tests/qemu-iotests/common.rc | 2 +-
tests/qemu-iotests/iotests.py | 2 +-
13 files changed, 159 insertions(+), 77 deletions(-)
--
2.20.1
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2018-08-31 14:24 Max Reitz
@ 2018-08-31 14:27 ` Max Reitz
0 siblings, 0 replies; 40+ messages in thread
From: Max Reitz @ 2018-08-31 14:27 UTC (permalink / raw)
To: qemu-block; +Cc: qemu-devel, Peter Maydell, Kevin Wolf
[-- Attachment #1: Type: text/plain, Size: 961 bytes --]
On 2018-08-31 16:24, Max Reitz wrote:
> The following changes since commit 19b599f7664b2ebfd0f405fb79c14dd241557452:
>
> Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2018-08-27-v2' into staging (2018-08-27 16:44:20 +0100)
>
> are available in the Git repository at:
>
> https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2018-08-31
>
> for you to fetch changes up to 40954cc7831c4f95f9ce6402ae3d6761f44f31ff:
>
> jobs: remove job_defer_to_main_loop (2018-08-31 16:11:27 +0200)
>
> ----------------------------------------------------------------
> Block patches:
> - (Block) job exit refactoring, part 1
> (removing job_defer_to_main_loop())
> - Locking fix for the file-posix block driver
> - test-bdrv-drain leak fix
>
> ----------------------------------------------------------------
Self-NACK. Sorry, I don't quite know how the locking fix slipped in
there, but it shouldn't be here.
Max
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2018-08-31 14:24 Max Reitz
2018-08-31 14:27 ` Max Reitz
0 siblings, 1 reply; 40+ messages in thread
From: Max Reitz @ 2018-08-31 14:24 UTC (permalink / raw)
To: qemu-block; +Cc: qemu-devel, Max Reitz, Peter Maydell, Kevin Wolf
The following changes since commit 19b599f7664b2ebfd0f405fb79c14dd241557452:
Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2018-08-27-v2' into staging (2018-08-27 16:44:20 +0100)
are available in the Git repository at:
https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2018-08-31
for you to fetch changes up to 40954cc7831c4f95f9ce6402ae3d6761f44f31ff:
jobs: remove job_defer_to_main_loop (2018-08-31 16:11:27 +0200)
----------------------------------------------------------------
Block patches:
- (Block) job exit refactoring, part 1
(removing job_defer_to_main_loop())
- Locking fix for the file-posix block driver
- test-bdrv-drain leak fix
----------------------------------------------------------------
Fam Zheng (1):
file-posix: Skip effectiveless OFD lock operations
John Snow (9):
jobs: change start callback to run callback
jobs: canonize Error object
jobs: add exit shim
block/commit: utilize job_exit shim
block/mirror: utilize job_exit shim
jobs: utilize job_exit shim
block/backup: make function variables consistently named
jobs: remove ret argument to job_completed; privatize it
jobs: remove job_defer_to_main_loop
Marc-André Lureau (1):
tests: fix bdrv-drain leak
include/qemu/job.h | 70 ++++++++++++++++-----------------
block/backup.c | 81 ++++++++++++++++-----------------------
block/commit.c | 29 +++++---------
block/create.c | 19 +++------
block/file-posix.c | 41 +++++++++++++++-----
block/mirror.c | 39 ++++++++-----------
block/stream.c | 29 ++++++--------
job-qmp.c | 5 ++-
job.c | 73 ++++++++++++-----------------------
tests/test-bdrv-drain.c | 14 +++----
tests/test-blockjob-txn.c | 25 +++++-------
tests/test-blockjob.c | 17 ++++----
trace-events | 2 +-
13 files changed, 192 insertions(+), 252 deletions(-)
--
2.17.1
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2017-01-16 13:39 Stefan Hajnoczi
@ 2017-01-17 13:53 ` Peter Maydell
0 siblings, 0 replies; 40+ messages in thread
From: Peter Maydell @ 2017-01-17 13:53 UTC (permalink / raw)
To: Stefan Hajnoczi; +Cc: QEMU Developers
On 16 January 2017 at 13:39, Stefan Hajnoczi <stefanha@redhat.com> wrote:
> The following changes since commit 2ccede18bd24fce5db83fef3674563a1f256717b:
>
> Merge remote-tracking branch 'remotes/vivier/tags/m68k-for-2.9-pull-request' into staging (2017-01-16 12:41:35 +0000)
>
> are available in the git repository at:
>
> git://github.com/stefanha/qemu.git tags/block-pull-request
>
> for you to fetch changes up to 7d506c90afa47facdb993bc19c15863eef584f1d:
>
> async: optimize aio_bh_poll (2017-01-16 13:25:18 +0000)
>
> ----------------------------------------------------------------
>
> ----------------------------------------------------------------
Applied, thanks.
-- PMM
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2017-01-16 13:39 Stefan Hajnoczi
2017-01-17 13:53 ` Peter Maydell
0 siblings, 1 reply; 40+ messages in thread
From: Stefan Hajnoczi @ 2017-01-16 13:39 UTC (permalink / raw)
To: qemu-devel; +Cc: Peter Maydell, Stefan Hajnoczi
The following changes since commit 2ccede18bd24fce5db83fef3674563a1f256717b:
Merge remote-tracking branch 'remotes/vivier/tags/m68k-for-2.9-pull-request' into staging (2017-01-16 12:41:35 +0000)
are available in the git repository at:
git://github.com/stefanha/qemu.git tags/block-pull-request
for you to fetch changes up to 7d506c90afa47facdb993bc19c15863eef584f1d:
async: optimize aio_bh_poll (2017-01-16 13:25:18 +0000)
----------------------------------------------------------------
----------------------------------------------------------------
Paolo Bonzini (11):
block: get rid of bdrv_io_unplugged_begin/end
aio: rename bh_lock to list_lock
qemu-thread: introduce QemuLockCnt
aio: make ctx->list_lock a QemuLockCnt, subsuming ctx->walking_bh
qemu-thread: optimize QemuLockCnt with futexes on Linux
aio-posix: split aio_dispatch_handlers out of aio_dispatch
aio: tweak walking in dispatch phase
aio-posix: remove walking_handlers, protecting AioHandler list with
list_lock
aio-win32: remove walking_handlers, protecting AioHandler list with
list_lock
aio: document locking
async: optimize aio_bh_poll
docs/lockcnt.txt | 277 +++++++++++++++++++++++++++++++
docs/multiple-iothreads.txt | 13 +-
util/Makefile.objs | 1 +
include/block/aio.h | 38 ++---
include/block/block.h | 2 -
include/block/block_int.h | 3 +-
include/qemu/futex.h | 36 ++++
include/qemu/thread.h | 112 +++++++++++++
aio-posix.c | 118 +++++++------
aio-win32.c | 83 +++++----
async.c | 45 ++---
block/io.c | 41 +----
util/lockcnt.c | 397 ++++++++++++++++++++++++++++++++++++++++++++
util/qemu-thread-posix.c | 35 +---
util/qemu-thread-win32.c | 2 +-
util/trace-events | 10 ++
16 files changed, 1010 insertions(+), 203 deletions(-)
create mode 100644 docs/lockcnt.txt
create mode 100644 include/qemu/futex.h
create mode 100644 util/lockcnt.c
--
2.9.3
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2014-09-26 18:58 Kevin Wolf
@ 2014-09-29 13:03 ` Peter Maydell
0 siblings, 0 replies; 40+ messages in thread
From: Peter Maydell @ 2014-09-29 13:03 UTC (permalink / raw)
To: Kevin Wolf; +Cc: QEMU Developers
On 26 September 2014 19:58, Kevin Wolf <kwolf@redhat.com> wrote:
> The following changes since commit 4f2280b2190e39aa6761cc8188626ed9aad350c1:
>
> Merge remote-tracking branch 'remotes/mcayland/tags/qemu-sparc-signed' into staging (2014-09-24 13:45:13 +0100)
>
> are available in the git repository at:
>
>
> git://repo.or.cz/qemu/kevin.git tags/for-upstream
>
> for you to fetch changes up to c9d17ad0dd3f04cdef44d58db97ea9864fbcdee7:
>
> qemu-iotests: Fail test if explicit test case number is unknown (2014-09-25 15:25:20 +0200)
>
> ----------------------------------------------------------------
> Block patches
>
> ----------------------------------------------------------------
Applied, thanks.
-- PMM
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2014-09-26 18:58 Kevin Wolf
2014-09-29 13:03 ` Peter Maydell
0 siblings, 1 reply; 40+ messages in thread
From: Kevin Wolf @ 2014-09-26 18:58 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf
The following changes since commit 4f2280b2190e39aa6761cc8188626ed9aad350c1:
Merge remote-tracking branch 'remotes/mcayland/tags/qemu-sparc-signed' into staging (2014-09-24 13:45:13 +0100)
are available in the git repository at:
git://repo.or.cz/qemu/kevin.git tags/for-upstream
for you to fetch changes up to c9d17ad0dd3f04cdef44d58db97ea9864fbcdee7:
qemu-iotests: Fail test if explicit test case number is unknown (2014-09-25 15:25:20 +0200)
----------------------------------------------------------------
Block patches
----------------------------------------------------------------
Fam Zheng (1):
qemu-iotests: Fail test if explicit test case number is unknown
Kevin Wolf (3):
block: Specify -drive legacy option aliases in array
block: Catch simultaneous usage of options and their aliases
block: Validate node-name
Markus Armbruster (4):
blockdev: Disentangle BlockDriverState and DriveInfo creation
block: Keep DriveInfo alive until BlockDriverState dies
qemu-nbd: Destroy the BlockDriverState properly
block: Improve message for device name clashing with node name
Stefan Hajnoczi (3):
blkdebug: show an error for invalid event names
docs: add blkdebug block driver documentation
vpc: fix beX_to_cpu() and cpu_to_beX() confusion
block.c | 21 ++++--
block/blkdebug.c | 22 ++++++-
block/vpc.c | 44 ++++++-------
blockdev.c | 103 ++++++++++++++++++-----------
docs/blkdebug.txt | 161 +++++++++++++++++++++++++++++++++++++++++++++
include/qemu/option.h | 1 +
include/sysemu/blockdev.h | 1 +
qemu-img.c | 6 +-
qemu-nbd.c | 2 +-
stubs/Makefile.objs | 1 +
stubs/blockdev.c | 12 ++++
tests/qemu-iotests/051 | 23 +++++++
tests/qemu-iotests/051.out | 45 +++++++++++++
tests/qemu-iotests/087.out | 2 +-
tests/qemu-iotests/common | 10 ++-
util/qemu-option.c | 4 +-
16 files changed, 382 insertions(+), 76 deletions(-)
create mode 100644 docs/blkdebug.txt
create mode 100644 stubs/blockdev.c
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2014-02-14 17:29 Stefan Hajnoczi
@ 2014-02-15 16:37 ` Peter Maydell
0 siblings, 0 replies; 40+ messages in thread
From: Peter Maydell @ 2014-02-15 16:37 UTC (permalink / raw)
To: Stefan Hajnoczi; +Cc: QEMU Developers, Anthony Liguori
On 14 February 2014 17:29, Stefan Hajnoczi <stefanha@redhat.com> wrote:
> The following changes since commit 0888a29caac6e1b668e498a0ad4d1fea15de012b:
>
> Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging (2014-02-13 15:02:04 +0000)
>
> are available in the git repository at:
>
>
> git://github.com/stefanha/qemu.git tags/block-pull-request
>
> for you to fetch changes up to 0c5e94ee8339e1aa49020466eba232e6f7c31a0a:
>
> block: Open by reference will try device then node_name. (2014-02-14 18:05:39 +0100)
Applied, thanks.
-- PMM
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2014-02-14 17:29 Stefan Hajnoczi
2014-02-15 16:37 ` Peter Maydell
0 siblings, 1 reply; 40+ messages in thread
From: Stefan Hajnoczi @ 2014-02-14 17:29 UTC (permalink / raw)
To: qemu-devel; +Cc: Peter Maydell, Anthony Liguori
The following changes since commit 0888a29caac6e1b668e498a0ad4d1fea15de012b:
Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging (2014-02-13 15:02:04 +0000)
are available in the git repository at:
git://github.com/stefanha/qemu.git tags/block-pull-request
for you to fetch changes up to 0c5e94ee8339e1aa49020466eba232e6f7c31a0a:
block: Open by reference will try device then node_name. (2014-02-14 18:05:39 +0100)
----------------------------------------------------------------
Block pull request
----------------------------------------------------------------
Benoît Canet (3):
blockdev: Fix wrong usage of QDECREF causing snapshoted quorum to crash on close.
block: Relax bdrv_lookup_bs constraints.
block: Open by reference will try device then node_name.
Fam Zheng (1):
qemu-iotests: Don't run 005 on vmdk split formats
Jeff Cody (5):
block: Add notes to iSCSI's .bdrv_open and .bdrv_reopen_prepare
block: Don't throw away errno via error_setg
block: qemu-iotests - fix test 070 (vhdx)
block: qemu-iotests - add vhdx log replay tests for qemu-img
block: mirror - use local_err to avoid NULL errp
Kevin Wolf (2):
sdhci: Drop unnecessary #include
blockdev: Remove 'type' parameter from blockdev_init()
block.c | 36 ++++++++++++++++--------------
block/iscsi.c | 10 +++++++--
block/mirror.c | 19 +++++++++++-----
block/qcow2-snapshot.c | 8 ++++---
block/vmdk.c | 6 ++---
blockdev.c | 55 ++++++++++++++++++++++++++++++++--------------
hw/sd/sdhci.c | 1 -
tests/qemu-iotests/005 | 2 ++
tests/qemu-iotests/070 | 13 ++++++++++-
tests/qemu-iotests/070.out | 15 ++++++++++++-
10 files changed, 115 insertions(+), 50 deletions(-)
--
1.8.5.3
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2013-09-20 17:42 Stefan Hajnoczi
0 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2013-09-20 17:42 UTC (permalink / raw)
To: qemu-devel; +Cc: Stefan Hajnoczi, Anthony Liguori
The following changes since commit 6c2679fc19560699679200fb42ab4659bcbe7f79:
Merge remote-tracking branch 'kiszka/queues/slirp' into staging (2013-09-17 10:01:24 -0500)
are available in the git repository at:
git://github.com/stefanha/qemu.git block
for you to fetch changes up to ef5bc96268ceec64769617dc53b0ac3a20ff351c:
virtio-blk: do not relay a previous driver's WCE configuration to the current (2013-09-20 19:27:48 +0200)
----------------------------------------------------------------
Fam Zheng (1):
block: don't lose data from last incomplete sector
Gabriel Kerneis (2):
coroutine: add qemu_coroutine_yield benchmark
coroutine: fix /perf/nesting coroutine benchmark
Max Reitz (1):
qcow2: Correct snapshots size for overlap check
Paolo Bonzini (3):
qemu-timer: do not take the lock in timer_pending
blockdev: do not default cache.no-flush to true
virtio-blk: do not relay a previous driver's WCE configuration to the current
Stefan Hajnoczi (4):
libcacard: link against qemu-error.o for error_report()
osdep: warn if open(O_DIRECT) on fails with EINVAL
qemu-timer: drop outdated signal safety comments
qemu-timer: make qemu_timer_mod_ns() and qemu_timer_del() thread-safe
block.c | 2 +-
block/qcow2-snapshot.c | 2 +-
blockdev.c | 2 +-
hw/block/virtio-blk.c | 24 ++++++++++-
include/hw/virtio/virtio-blk.h | 1 +
include/qemu/timer.h | 17 ++++++++
libcacard/Makefile | 3 +-
qemu-timer.c | 92 +++++++++++++++++++++++++++++-------------
tests/test-coroutine.c | 45 ++++++++++++++++++---
util/osdep.c | 7 ++++
10 files changed, 155 insertions(+), 40 deletions(-)
--
1.8.3.1
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2013-05-24 14:32 Stefan Hajnoczi
@ 2013-06-17 21:18 ` Anthony Liguori
0 siblings, 0 replies; 40+ messages in thread
From: Anthony Liguori @ 2013-06-17 21:18 UTC (permalink / raw)
To: Stefan Hajnoczi, qemu-devel; +Cc: Anthony Liguori
Pulled. Thanks.
Regards,
Anthony Liguori
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2013-05-24 14:32 Stefan Hajnoczi
2013-06-17 21:18 ` Anthony Liguori
0 siblings, 1 reply; 40+ messages in thread
From: Stefan Hajnoczi @ 2013-05-24 14:32 UTC (permalink / raw)
To: qemu-devel; +Cc: Anthony Liguori, Stefan Hajnoczi
The following changes since commit 64afc2b4d48fb21e085517c38a59a3f61a11283c:
Merge remote-tracking branch 'luiz/queue/qmp' into staging (2013-05-23 14:16:35 -0500)
are available in the git repository at:
git://github.com/stefanha/qemu.git block
for you to fetch changes up to 02ffb504485f0920cfc75a0982a602f824a9a4f4:
coroutine: stop using AioContext in CoQueue (2013-05-24 16:17:56 +0200)
----------------------------------------------------------------
Kevin Wolf (4):
blockdev: Rename BlockdevAction -> TransactionAction
qemu-io: Fix 'map' output
qcow2.py: Subcommand for changing header fields
qemu-iotests: Try creating huge qcow2 image
Stefan Hajnoczi (2):
coroutine: protect global pool with a mutex
coroutine: stop using AioContext in CoQueue
Wenchao Xia (5):
block: package preparation code in qmp_transaction()
block: move input parsing code in qmp_transaction()
block: package committing code in qmp_transaction()
block: package rollback code in qmp_transaction()
block: make all steps in qmp_transaction() as callback
blockdev.c | 280 ++++++++++++++++++++++++++----------------
include/block/coroutine_int.h | 4 +
qapi-schema.json | 21 ++--
qemu-coroutine-lock.c | 56 ++++-----
qemu-coroutine.c | 23 +++-
qemu-io.c | 46 ++++++-
tests/qemu-iotests/054 | 58 +++++++++
tests/qemu-iotests/054.out | 10 ++
tests/qemu-iotests/common.rc | 2 +-
tests/qemu-iotests/group | 1 +
tests/qemu-iotests/qcow2.py | 17 +++
trace-events | 2 +-
12 files changed, 361 insertions(+), 159 deletions(-)
create mode 100755 tests/qemu-iotests/054
create mode 100644 tests/qemu-iotests/054.out
--
1.8.1.4
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2013-04-26 11:44 Stefan Hajnoczi
0 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2013-04-26 11:44 UTC (permalink / raw)
To: qemu-devel; +Cc: Anthony Liguori, Stefan Hajnoczi
The following changes since commit e3351000cd682200835763caca87adf708ed1c65:
Makefile: Use QEMU_FLAGS for DTC compilation (2013-04-26 02:48:10 +0200)
are available in the git repository at:
git://github.com/stefanha/qemu.git block
for you to fetch changes up to 859e5553a428225de6b8ef302cdcfd68d140b926:
sheepdog: fix loadvm operation (2013-04-26 13:37:51 +0200)
----------------------------------------------------------------
Kevin Wolf (2):
block: Disable driver-specific options for 1.5
rbd: Fix use after free in rbd_open()
Liu Yuan (4):
sheepdog: add discard/trim support for sheepdog
sheepdog: use BDRV_SECTOR_SIZE
sheepdog: implement .bdrv_co_is_allocated()
sheepdog: fix loadvm operation
MORITA Kazutaka (4):
sheepdog: cleanup find_vdi_name
sheepdog: add SD_RES_READONLY result code
sheepdog: add helper function to reload inode
sheepdog: resend write requests when SD_RES_READONLY is received
Richard W.M. Jones (1):
block/ssh: Require libssh2 >= 1.2.8.
block/rbd.c | 9 +-
block/sheepdog.c | 308 ++++++++++++++++++++++++++++++++++++++++-------
blockdev.c | 118 +++++++++++++++++-
configure | 24 +---
tests/qemu-iotests/group | 2 +-
5 files changed, 390 insertions(+), 71 deletions(-)
--
1.8.1.4
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2013-04-15 8:22 Stefan Hajnoczi
0 siblings, 0 replies; 40+ messages in thread
From: Stefan Hajnoczi @ 2013-04-15 8:22 UTC (permalink / raw)
To: qemu-devel; +Cc: Anthony Liguori
The following changes since commit e2ec3f976803b360c70d9ae2ba13852fa5d11665:
qjson: to_json() case QTYPE_QSTRING is buggy, rewrite (2013-04-13 19:40:25 +0000)
are available in the git repository at:
git://github.com/stefanha/qemu.git block
for you to fetch changes up to dc7588c1eb3008bda53dde1d6b890cd299758155:
rbd: add an asynchronous flush (2013-04-15 10:18:05 +0200)
----------------------------------------------------------------
Josh Durgin (1):
rbd: add an asynchronous flush
Kevin Wolf (5):
block: Introduce bdrv_writev_vmstate
savevm: Implement block_writev_buffer()
block: Introduce bdrv_pwritev() for qcow2_save_vmstate
qemu-iotests: A few more bdrv_pread/pwrite tests
qemu-iotests: Add test for -drive options
Richard W.M. Jones (3):
block: Add support for Secure Shell (ssh) block device.
block: ssh: Use libssh2_sftp_fsync (if supported by libssh2) to flush to disk.
iotests: Add 'check -ssh' option to test Secure Shell block device.
Stefan Hajnoczi (2):
qemu-iotests: filter QEMU_PROG in 051.out
ide: refuse WIN_READ_NATIVE_MAX on empty device
block.c | 105 +++-
block/Makefile.objs | 1 +
block/qcow2.c | 6 +-
block/rbd.c | 37 +-
block/sheepdog.c | 13 +-
block/ssh.c | 1063 ++++++++++++++++++++++++++++++++++++++
configure | 73 +++
hw/ide/core.c | 4 +
include/block/block.h | 3 +
include/block/block_int.h | 4 +-
include/migration/qemu-file.h | 2 +-
qemu-doc.texi | 54 ++
qemu-options.hx | 12 +
savevm.c | 25 +-
tests/qemu-iotests/002 | 13 +
tests/qemu-iotests/002.out | 26 +
tests/qemu-iotests/051 | 148 ++++++
tests/qemu-iotests/051.out | 162 ++++++
tests/qemu-iotests/common | 5 +
tests/qemu-iotests/common.filter | 6 +
tests/qemu-iotests/common.rc | 3 +
tests/qemu-iotests/group | 1 +
22 files changed, 1722 insertions(+), 44 deletions(-)
create mode 100644 block/ssh.c
create mode 100755 tests/qemu-iotests/051
create mode 100644 tests/qemu-iotests/051.out
--
1.8.1.4
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2012-09-18 17:49 ` Michael Tokarev
@ 2012-09-19 8:42 ` Kevin Wolf
0 siblings, 0 replies; 40+ messages in thread
From: Kevin Wolf @ 2012-09-19 8:42 UTC (permalink / raw)
To: Michael Tokarev; +Cc: Jason Baron, qemu-devel, Ronnie Sahlberg, qemu-stable
Am 18.09.2012 19:49, schrieb Michael Tokarev:
> On 14.09.2012 16:39, Kevin Wolf wrote:
>> The following changes since commit e0a1e32dbc41e6b2aabb436a9417dfd32177a3dc:
>>
>> Merge branch 'usb.64' of git://git.kraxel.org/qemu (2012-09-11 18:06:56 +0200)
>>
>> are available in the git repository at:
>>
>> git://repo.or.cz/qemu/kevin.git for-anthony
>
> Are any of these appropriate for -stable? I think some are, below:
I think all of your suggestions would be appropriate, even though most
of them fix rather theoretical cases.
>> Jason Baron (1):
>> ahci: properly reset PxCMD on HBA reset
>
> Most likely this. Jason?
Yes, this fixes a real visible bug with AHCI CD-ROMs.
Kevin
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2012-09-14 12:39 Kevin Wolf
2012-09-17 18:19 ` Anthony Liguori
@ 2012-09-18 17:49 ` Michael Tokarev
2012-09-19 8:42 ` Kevin Wolf
1 sibling, 1 reply; 40+ messages in thread
From: Michael Tokarev @ 2012-09-18 17:49 UTC (permalink / raw)
To: Kevin Wolf; +Cc: Jason Baron, qemu-devel, Ronnie Sahlberg, qemu-stable
On 14.09.2012 16:39, Kevin Wolf wrote:
> The following changes since commit e0a1e32dbc41e6b2aabb436a9417dfd32177a3dc:
>
> Merge branch 'usb.64' of git://git.kraxel.org/qemu (2012-09-11 18:06:56 +0200)
>
> are available in the git repository at:
>
> git://repo.or.cz/qemu/kevin.git for-anthony
Are any of these appropriate for -stable? I think some are, below:
> Benoît Canet (2):
> qapi: Add SnapshotInfo and ImageInfo.
> qemu-img: Add json output option to the info command.
>
> Daniel P. Berrange (1):
> Don't require encryption password for 'qemu-img info' command
>
> Dunrong Huang (1):
> block: Don't forget to delete temporary file
This? Appears to be a minor case.
> Jason Baron (1):
> ahci: properly reset PxCMD on HBA reset
Most likely this. Jason?
> MORITA Kazutaka (1):
> sheepdog: fix savevm and loadvm
This, but does anyone really use sheepdog with savevm/loadvm?
Probably a very minor issue too, not worth -stable.
> Pavel Hrdina (1):
> block: fix block tray status
And this,
> Ronnie Sahlberg (1):
> ATAPI: STARTSTOPUNIT only eject/load media if powercondition is 0
And probably this too? I'm not sure about this one.
Ronnie?
> Stefan Weil (3):
> ide: Fix error messages from static code analysis (no real error)
> block/curl: Fix wrong free statement
> vdi: Fix warning from clang
Thanks,
/mjt
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2012-09-14 12:39 Kevin Wolf
@ 2012-09-17 18:19 ` Anthony Liguori
2012-09-18 17:49 ` Michael Tokarev
1 sibling, 0 replies; 40+ messages in thread
From: Anthony Liguori @ 2012-09-17 18:19 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel
Kevin Wolf <kwolf@redhat.com> writes:
> The following changes since commit e0a1e32dbc41e6b2aabb436a9417dfd32177a3dc:
>
> Merge branch 'usb.64' of git://git.kraxel.org/qemu (2012-09-11 18:06:56 +0200)
>
> are available in the git repository at:
>
> git://repo.or.cz/qemu/kevin.git for-anthony
>
Pulled. Thanks.
Regards,
Anthony Liguori
> Benoît Canet (2):
> qapi: Add SnapshotInfo and ImageInfo.
> qemu-img: Add json output option to the info command.
>
> Daniel P. Berrange (1):
> Don't require encryption password for 'qemu-img info' command
>
> Dunrong Huang (1):
> block: Don't forget to delete temporary file
>
> Jason Baron (1):
> ahci: properly reset PxCMD on HBA reset
>
> MORITA Kazutaka (1):
> sheepdog: fix savevm and loadvm
>
> Pavel Hrdina (1):
> block: fix block tray status
>
> Ronnie Sahlberg (1):
> ATAPI: STARTSTOPUNIT only eject/load media if powercondition is 0
>
> Stefan Weil (3):
> ide: Fix error messages from static code analysis (no real error)
> block/curl: Fix wrong free statement
> vdi: Fix warning from clang
>
> Makefile | 3 +-
> block.c | 10 ++-
> block/curl.c | 3 +-
> block/sheepdog.c | 3 +-
> block/vdi.c | 25 +++---
> hw/ide/ahci.c | 2 +-
> hw/ide/atapi.c | 6 ++
> hw/ide/core.c | 11 +--
> qapi-schema.json | 64 ++++++++++++++
> qemu-img-cmds.hx | 4 +-
> qemu-img.c | 257 ++++++++++++++++++++++++++++++++++++++++++-----------
> qemu-img.texi | 5 +-
> 12 files changed, 305 insertions(+), 88 deletions(-)
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2012-09-14 12:39 Kevin Wolf
2012-09-17 18:19 ` Anthony Liguori
2012-09-18 17:49 ` Michael Tokarev
0 siblings, 2 replies; 40+ messages in thread
From: Kevin Wolf @ 2012-09-14 12:39 UTC (permalink / raw)
To: anthony; +Cc: kwolf, qemu-devel
The following changes since commit e0a1e32dbc41e6b2aabb436a9417dfd32177a3dc:
Merge branch 'usb.64' of git://git.kraxel.org/qemu (2012-09-11 18:06:56 +0200)
are available in the git repository at:
git://repo.or.cz/qemu/kevin.git for-anthony
Benoît Canet (2):
qapi: Add SnapshotInfo and ImageInfo.
qemu-img: Add json output option to the info command.
Daniel P. Berrange (1):
Don't require encryption password for 'qemu-img info' command
Dunrong Huang (1):
block: Don't forget to delete temporary file
Jason Baron (1):
ahci: properly reset PxCMD on HBA reset
MORITA Kazutaka (1):
sheepdog: fix savevm and loadvm
Pavel Hrdina (1):
block: fix block tray status
Ronnie Sahlberg (1):
ATAPI: STARTSTOPUNIT only eject/load media if powercondition is 0
Stefan Weil (3):
ide: Fix error messages from static code analysis (no real error)
block/curl: Fix wrong free statement
vdi: Fix warning from clang
Makefile | 3 +-
block.c | 10 ++-
block/curl.c | 3 +-
block/sheepdog.c | 3 +-
block/vdi.c | 25 +++---
hw/ide/ahci.c | 2 +-
hw/ide/atapi.c | 6 ++
hw/ide/core.c | 11 +--
qapi-schema.json | 64 ++++++++++++++
qemu-img-cmds.hx | 4 +-
qemu-img.c | 257 ++++++++++++++++++++++++++++++++++++++++++-----------
qemu-img.texi | 5 +-
12 files changed, 305 insertions(+), 88 deletions(-)
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2012-08-10 16:47 Kevin Wolf
@ 2012-08-12 18:14 ` Anthony Liguori
0 siblings, 0 replies; 40+ messages in thread
From: Anthony Liguori @ 2012-08-12 18:14 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel
Kevin Wolf <kwolf@redhat.com> writes:
> The following changes since commit 3d1d9652978ac5a32a0beb4bdf6065ca39440d89:
>
> handle device help before accelerator set up (2012-08-09 19:53:01 +0000)
>
> are available in the git repository at:
> http://repo.or.cz/r/qemu/kevin.git for-anthony
Pulled. Thanks.
Regards,
Anthony Liguori
>
> Avi Kivity (1):
> virtio-blk: fix use-after-free while handling scsi commands
>
> Jason Baron (2):
> ahci: Fix ahci cdrom read corruptions for reads > 128k
> ahci: Fix sglist memleak in ahci_dma_rw_buf()
>
> Kevin Wolf (1):
> qemu-iotests: Save some sed processes
>
> Paolo Bonzini (3):
> virtio-blk: support VIRTIO_BLK_F_CONFIG_WCE
> virtio-blk: disable write cache if not negotiated
> blockdev: flip default cache mode from writethrough to writeback
>
> Stefan Hajnoczi (4):
> qed: mark image clean after repair succeeds
> qcow2: mark image clean after repair succeeds
> block: add BLOCK_O_CHECK for qemu-img check
> qemu-iotests: skip 039 with ./check -nocache
>
> block.h | 1 +
> block/qcow2.c | 32 ++++++++++++++++--------------
> block/qed-check.c | 26 ++++++++++++++++++++++++
> block/qed.c | 11 +--------
> block/qed.h | 5 ++++
> blockdev.c | 1 +
> dma-helpers.c | 1 +
> hw/ide/ahci.c | 44 +++++++++++++++++++++++++++++++++++------
> hw/ide/internal.h | 1 +
> hw/virtio-blk.c | 31 +++++++++++++++++++++++++++-
> hw/virtio-blk.h | 4 ++-
> qemu-img.c | 2 +-
> tests/qemu-iotests/039 | 1 +
> tests/qemu-iotests/039.out | 6 +++++
> tests/qemu-iotests/common.rc | 34 ++++++++++++++++++++++---------
> 15 files changed, 155 insertions(+), 45 deletions(-)
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2012-08-10 16:47 Kevin Wolf
2012-08-12 18:14 ` Anthony Liguori
0 siblings, 1 reply; 40+ messages in thread
From: Kevin Wolf @ 2012-08-10 16:47 UTC (permalink / raw)
To: anthony; +Cc: kwolf, qemu-devel
The following changes since commit 3d1d9652978ac5a32a0beb4bdf6065ca39440d89:
handle device help before accelerator set up (2012-08-09 19:53:01 +0000)
are available in the git repository at:
http://repo.or.cz/r/qemu/kevin.git for-anthony
Avi Kivity (1):
virtio-blk: fix use-after-free while handling scsi commands
Jason Baron (2):
ahci: Fix ahci cdrom read corruptions for reads > 128k
ahci: Fix sglist memleak in ahci_dma_rw_buf()
Kevin Wolf (1):
qemu-iotests: Save some sed processes
Paolo Bonzini (3):
virtio-blk: support VIRTIO_BLK_F_CONFIG_WCE
virtio-blk: disable write cache if not negotiated
blockdev: flip default cache mode from writethrough to writeback
Stefan Hajnoczi (4):
qed: mark image clean after repair succeeds
qcow2: mark image clean after repair succeeds
block: add BLOCK_O_CHECK for qemu-img check
qemu-iotests: skip 039 with ./check -nocache
block.h | 1 +
block/qcow2.c | 32 ++++++++++++++++--------------
block/qed-check.c | 26 ++++++++++++++++++++++++
block/qed.c | 11 +--------
block/qed.h | 5 ++++
blockdev.c | 1 +
dma-helpers.c | 1 +
hw/ide/ahci.c | 44 +++++++++++++++++++++++++++++++++++------
hw/ide/internal.h | 1 +
hw/virtio-blk.c | 31 +++++++++++++++++++++++++++-
hw/virtio-blk.h | 4 ++-
qemu-img.c | 2 +-
tests/qemu-iotests/039 | 1 +
tests/qemu-iotests/039.out | 6 +++++
tests/qemu-iotests/common.rc | 34 ++++++++++++++++++++++---------
15 files changed, 155 insertions(+), 45 deletions(-)
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [Qemu-devel] [PULL 00/11] Block patches
2011-04-27 13:42 Kevin Wolf
@ 2011-04-27 14:26 ` Aurelien Jarno
0 siblings, 0 replies; 40+ messages in thread
From: Aurelien Jarno @ 2011-04-27 14:26 UTC (permalink / raw)
To: Kevin Wolf; +Cc: qemu-devel
On Wed, Apr 27, 2011 at 03:42:59PM +0200, Kevin Wolf wrote:
> The following changes since commit 430a3c18064fd3c007048d757e8bd0fff45fcc99:
>
> configure: reenable opengl by default (2011-04-26 23:26:49 +0200)
>
> are available in the git repository at:
> git://repo.or.cz/qemu/kevin.git for-anthony
>
> Amit Shah (1):
> atapi: Add 'medium ready' to 'medium not ready' transition on cd change
>
> Anthony Liguori (1):
> qemu-img: allow rebase to a NULL backing file when unsafe
>
> Avishay Traeger (1):
> Improve accuracy of block migration bandwidth calculation
>
> Jes Sorensen (2):
> Add dd-style SIGUSR1 progress reporting
> Remove obsolete 'enabled' variable from progress state
>
> Kevin Wolf (5):
> ide: Split atapi.c out
> ide/atapi: Factor commands out
> ide/atapi: Use table instead of switch for commands
> ide/atapi: Replace bdrv_get_geometry calls by s->nb_sectors
> ide/atapi: Introduce CHECK_READY flag for commands
>
> Stefan Hajnoczi (1):
> qed: Fix consistency check on 32-bit hosts
>
> Makefile.objs | 2 +-
> block-migration.c | 23 +-
> block/qed-check.c | 4 +-
> block/qed.h | 2 +-
> hw/ide/atapi.c | 1134 +++++++++++++++++++++++++++++++++++++++++++++++++++++
> hw/ide/core.c | 1067 +-------------------------------------------------
> hw/ide/internal.h | 14 +-
> qemu-img.c | 2 +-
> qemu-progress.c | 61 +++-
> 9 files changed, 1221 insertions(+), 1088 deletions(-)
> create mode 100644 hw/ide/atapi.c
>
Thanks, pulled.
--
Aurelien Jarno GPG: 1024D/F1BCDB73
aurelien@aurel32.net http://www.aurel32.net
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2011-04-27 13:42 Kevin Wolf
2011-04-27 14:26 ` Aurelien Jarno
0 siblings, 1 reply; 40+ messages in thread
From: Kevin Wolf @ 2011-04-27 13:42 UTC (permalink / raw)
To: anthony; +Cc: kwolf, qemu-devel
The following changes since commit 430a3c18064fd3c007048d757e8bd0fff45fcc99:
configure: reenable opengl by default (2011-04-26 23:26:49 +0200)
are available in the git repository at:
git://repo.or.cz/qemu/kevin.git for-anthony
Amit Shah (1):
atapi: Add 'medium ready' to 'medium not ready' transition on cd change
Anthony Liguori (1):
qemu-img: allow rebase to a NULL backing file when unsafe
Avishay Traeger (1):
Improve accuracy of block migration bandwidth calculation
Jes Sorensen (2):
Add dd-style SIGUSR1 progress reporting
Remove obsolete 'enabled' variable from progress state
Kevin Wolf (5):
ide: Split atapi.c out
ide/atapi: Factor commands out
ide/atapi: Use table instead of switch for commands
ide/atapi: Replace bdrv_get_geometry calls by s->nb_sectors
ide/atapi: Introduce CHECK_READY flag for commands
Stefan Hajnoczi (1):
qed: Fix consistency check on 32-bit hosts
Makefile.objs | 2 +-
block-migration.c | 23 +-
block/qed-check.c | 4 +-
block/qed.h | 2 +-
hw/ide/atapi.c | 1134 +++++++++++++++++++++++++++++++++++++++++++++++++++++
hw/ide/core.c | 1067 +-------------------------------------------------
hw/ide/internal.h | 14 +-
qemu-img.c | 2 +-
qemu-progress.c | 61 +++-
9 files changed, 1221 insertions(+), 1088 deletions(-)
create mode 100644 hw/ide/atapi.c
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2010-10-22 13:43 Kevin Wolf
0 siblings, 0 replies; 40+ messages in thread
From: Kevin Wolf @ 2010-10-22 13:43 UTC (permalink / raw)
To: anthony; +Cc: kwolf, qemu-devel
The following changes since commit d03703c81a202cea156811e5dbc8e88627c19986:
curses: Fix control-{@[\]^_} and ESC (2010-10-21 18:31:28 +0200)
are available in the git repository at:
git://repo.or.cz/qemu/kevin.git for-anthony
Christoph Hellwig (1):
ide: set WCACHE supported in IDENTIFY data
Kevin Wolf (7):
qcow2: Simplify image creation
qcow2: Remove old image creation function
qemu-io: New command map
qemu-img: Fix qemu-img convert -obacking_file
ide: Factor ide_flush_cache out
ide: Handle flush failure
virtio-blk: Respect werror option for flushes
Stefan Hajnoczi (1):
qcow2: Support exact L1 table growth
Stefan Weil (1):
block: Use GCC_FMT_ATTR and fix a format error
edison (1):
Copy snapshots out of QCOW2 disk
block.c | 16 +++
block.h | 2 +
block/blkverify.c | 5 +-
block/qcow2-cluster.c | 25 +++--
block/qcow2-snapshot.c | 33 ++++++-
block/qcow2.c | 278 ++++++++++++++++--------------------------------
block/qcow2.h | 3 +-
block_int.h | 2 +
hw/ide/core.c | 28 ++++--
hw/ide/internal.h | 3 +-
hw/virtio-blk.c | 8 ++-
qemu-img-cmds.hx | 4 +-
qemu-img.c | 26 +++++-
qemu-img.texi | 4 +-
qemu-io.c | 39 +++++++
15 files changed, 264 insertions(+), 212 deletions(-)
^ permalink raw reply [flat|nested] 40+ messages in thread
* [Qemu-devel] [PULL 00/11] Block patches
@ 2010-05-07 15:13 Kevin Wolf
0 siblings, 0 replies; 40+ messages in thread
From: Kevin Wolf @ 2010-05-07 15:13 UTC (permalink / raw)
To: aliguori; +Cc: kwolf, qemu-devel
The following changes since commit 2065061ede22d401aae2ce995c3af54db9d28639:
Igor V. Kovalenko (1):
sparc64: handle asi referencing nucleus and secondary MMU contexts
are available in the git repository at:
git://repo.or.cz/qemu/kevin.git for-anthony
Christoph Hellwig (4):
cloop: use pread
cloop: use qemu block API
bochs: use pread
bochs: use qemu block API
Kevin Wolf (4):
ide: Fix ide_dma_cancel
block: Avoid unchecked casts for AIOCBs
block: Fix protocol detection for Windows devices
block: Fix bdrv_commit
Ryota Ozaki (1):
qemu-nbd: Improve error reporting
Stefan Hajnoczi (1):
block: Remove semicolon in BDRV_SECTOR_MASK macro
Stefan Weil (1):
block/vdi: Allow disk images of size 0
block.c | 19 +++++++-----
block.h | 2 +-
block/blkdebug.c | 4 +-
block/bochs.c | 81 +++++++++++++++--------------------------------------
block/cloop.c | 48 ++++++++++++++++----------------
block/qcow.c | 2 +-
block/qcow2.c | 2 +-
block/vdi.c | 11 +++++--
hw/ide/core.c | 8 ++--
qemu-nbd.c | 34 ++++++++++++++++------
10 files changed, 99 insertions(+), 112 deletions(-)
^ permalink raw reply [flat|nested] 40+ messages in thread
end of thread, other threads:[~2019-05-09 16:18 UTC | newest]
Thread overview: 40+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-06-04 11:20 [Qemu-devel] [PULL 00/11] Block patches Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 01/11] block: Introduce API for copy offloading Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 02/11] raw: Check byte range uniformly Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 03/11] raw: Implement copy offloading Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 04/11] qcow2: " Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 05/11] file-posix: Implement bdrv_co_copy_range Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 06/11] iscsi: Query and save device designator when opening Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 07/11] iscsi: Create and use iscsi_co_wait_for_task Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 08/11] iscsi: Implement copy offloading Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 09/11] block-backend: Add blk_co_copy_range Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 10/11] qemu-img: Convert with copy offloading Stefan Hajnoczi
2018-06-04 11:20 ` [Qemu-devel] [PULL 11/11] main-loop: drop spin_counter Stefan Hajnoczi
2018-06-05 9:38 ` [Qemu-devel] [PULL 00/11] Block patches Peter Maydell
-- strict thread matches above, loose matches on Subject: below --
2019-05-07 15:18 Max Reitz
2019-05-09 8:49 ` Peter Maydell
2019-05-09 13:27 ` Max Reitz
2019-05-09 16:17 ` Peter Maydell
2018-08-31 14:24 Max Reitz
2018-08-31 14:27 ` Max Reitz
2017-01-16 13:39 Stefan Hajnoczi
2017-01-17 13:53 ` Peter Maydell
2014-09-26 18:58 Kevin Wolf
2014-09-29 13:03 ` Peter Maydell
2014-02-14 17:29 Stefan Hajnoczi
2014-02-15 16:37 ` Peter Maydell
2013-09-20 17:42 Stefan Hajnoczi
2013-05-24 14:32 Stefan Hajnoczi
2013-06-17 21:18 ` Anthony Liguori
2013-04-26 11:44 Stefan Hajnoczi
2013-04-15 8:22 Stefan Hajnoczi
2012-09-14 12:39 Kevin Wolf
2012-09-17 18:19 ` Anthony Liguori
2012-09-18 17:49 ` Michael Tokarev
2012-09-19 8:42 ` Kevin Wolf
2012-08-10 16:47 Kevin Wolf
2012-08-12 18:14 ` Anthony Liguori
2011-04-27 13:42 Kevin Wolf
2011-04-27 14:26 ` Aurelien Jarno
2010-10-22 13:43 Kevin Wolf
2010-05-07 15:13 Kevin Wolf
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.