ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

block: split flags in copy_range 

Pass read flags and write flags separately. This is needed to handle
coming BDRV_REQ_NO_SERIALISING clearly in following patches.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2018-07-09 19:37:17 +03:00 committed by Kevin Wolf
parent 999658a05e
commit 67b51fb998
11 changed files with 90 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
block/backup.c
View File

@ -163,7 +163,7 @@ static int coroutine_fn backup_cow_with_offload(BackupBlockJob *job,
hbitmap_reset(job->copy_bitmap, start / job->cluster_size, hbitmap_reset(job->copy_bitmap, start / job->cluster_size,
nr_clusters); nr_clusters);
ret = blk_co_copy_range(blk, start, job->target, start, nbytes, ret = blk_co_copy_range(blk, start, job->target, start, nbytes,
is_write_notifier ? BDRV_REQ_NO_SERIALISING : 0); is_write_notifier ? BDRV_REQ_NO_SERIALISING : 0, 0);
if (ret < 0) { if (ret < 0) {
trace_backup_do_cow_copy_range_fail(job, start, ret); trace_backup_do_cow_copy_range_fail(job, start, ret);
hbitmap_set(job->copy_bitmap, start / job->cluster_size, hbitmap_set(job->copy_bitmap, start / job->cluster_size,

5
block/block-backend.c
View File

@ -2218,7 +2218,8 @@ void blk_unregister_buf(BlockBackend *blk, void *host)
int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in, int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
BlockBackend *blk_out, int64_t off_out, BlockBackend *blk_out, int64_t off_out,
int bytes, BdrvRequestFlags flags) int bytes, BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
int r; int r;
r = blk_check_byte_request(blk_in, off_in, bytes); r = blk_check_byte_request(blk_in, off_in, bytes);
@ -2231,5 +2232,5 @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
} }
return bdrv_co_copy_range(blk_in->root, off_in, return bdrv_co_copy_range(blk_in->root, off_in,
blk_out->root, off_out, blk_out->root, off_out,
bytes, flags); bytes, read_flags, write_flags);
} }

21
block/file-posix.c
View File

@ -2589,18 +2589,23 @@ static void raw_abort_perm_update(BlockDriverState *bs)
raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL); raw_handle_perm_lock(bs, RAW_PL_ABORT, 0, 0, NULL);
} }
static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs, static int coroutine_fn raw_co_copy_range_from(
BdrvChild *src, uint64_t src_offset, BlockDriverState *bs, BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset, uint64_t bytes,
uint64_t bytes, BdrvRequestFlags flags) BdrvRequestFlags read_flags, BdrvRequestFlags write_flags)
{ {
return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes, flags); return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
read_flags, write_flags);
} }
static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs, static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
BdrvChild *src, uint64_t src_offset, BdrvChild *src,
BdrvChild *dst, uint64_t dst_offset, uint64_t src_offset,
uint64_t bytes, BdrvRequestFlags flags) BdrvChild *dst,
uint64_t dst_offset,
uint64_t bytes,
BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
BDRVRawState *s = bs->opaque; BDRVRawState *s = bs->opaque;
BDRVRawState *src_s; BDRVRawState *src_s;

44
block/io.c
View File

@ -2910,12 +2910,10 @@ void bdrv_unregister_buf(BlockDriverState *bs, void *host)
} }
} }
static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src, static int coroutine_fn bdrv_co_copy_range_internal(
uint64_t src_offset, BdrvChild *src, uint64_t src_offset, BdrvChild *dst,
BdrvChild *dst, uint64_t dst_offset, uint64_t bytes,
uint64_t dst_offset, BdrvRequestFlags read_flags, BdrvRequestFlags write_flags,
uint64_t bytes,
BdrvRequestFlags flags,
bool recurse_src) bool recurse_src)
{ {
BdrvTrackedRequest req; BdrvTrackedRequest req;
@ -2928,8 +2926,8 @@ static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src,
if (ret) { if (ret) {
return ret; return ret;
} }
if (flags & BDRV_REQ_ZERO_WRITE) { if (write_flags & BDRV_REQ_ZERO_WRITE) {
return bdrv_co_pwrite_zeroes(dst, dst_offset, bytes, flags); return bdrv_co_pwrite_zeroes(dst, dst_offset, bytes, write_flags);
} }
if (!src || !src->bs) { if (!src || !src->bs) {
@ -2951,14 +2949,15 @@ static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src,
tracked_request_begin(&req, src->bs, src_offset, bytes, tracked_request_begin(&req, src->bs, src_offset, bytes,
BDRV_TRACKED_READ); BDRV_TRACKED_READ);
if (!(flags & BDRV_REQ_NO_SERIALISING)) { if (!(read_flags & BDRV_REQ_NO_SERIALISING)) {
wait_serialising_requests(&req); wait_serialising_requests(&req);
} }
ret = src->bs->drv->bdrv_co_copy_range_from(src->bs, ret = src->bs->drv->bdrv_co_copy_range_from(src->bs,
src, src_offset, src, src_offset,
dst, dst_offset, dst, dst_offset,
bytes, flags); bytes,
read_flags, write_flags);
tracked_request_end(&req); tracked_request_end(&req);
bdrv_dec_in_flight(src->bs); bdrv_dec_in_flight(src->bs);
@ -2967,15 +2966,15 @@ static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src,
tracked_request_begin(&req, dst->bs, dst_offset, bytes, tracked_request_begin(&req, dst->bs, dst_offset, bytes,
BDRV_TRACKED_WRITE); BDRV_TRACKED_WRITE);
/* BDRV_REQ_NO_SERIALISING is only for read operation, /* BDRV_REQ_NO_SERIALISING is only for read operation */
* so we ignore it in flags. assert(!(write_flags & BDRV_REQ_NO_SERIALISING));
*/
wait_serialising_requests(&req); wait_serialising_requests(&req);
ret = dst->bs->drv->bdrv_co_copy_range_to(dst->bs, ret = dst->bs->drv->bdrv_co_copy_range_to(dst->bs,
src, src_offset, src, src_offset,
dst, dst_offset, dst, dst_offset,
bytes, flags); bytes,
read_flags, write_flags);
tracked_request_end(&req); tracked_request_end(&req);
bdrv_dec_in_flight(dst->bs); bdrv_dec_in_flight(dst->bs);
@ -2990,10 +2989,12 @@ static int coroutine_fn bdrv_co_copy_range_internal(BdrvChild *src,
* semantics. */ * semantics. */
int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset, int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags) uint64_t bytes,
BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset, return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset,
bytes, flags, true); bytes, read_flags, write_flags, true);
} }
/* Copy range from @src to @dst. /* Copy range from @src to @dst.
@ -3002,19 +3003,22 @@ int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset,
* semantics. */ * semantics. */
int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, uint64_t src_offset, int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags) uint64_t bytes,
BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset, return bdrv_co_copy_range_internal(src, src_offset, dst, dst_offset,
bytes, flags, false); bytes, read_flags, write_flags, false);
} }
int coroutine_fn bdrv_co_copy_range(BdrvChild *src, uint64_t src_offset, int coroutine_fn bdrv_co_copy_range(BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags) uint64_t bytes, BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
return bdrv_co_copy_range_from(src, src_offset, return bdrv_co_copy_range_from(src, src_offset,
dst, dst_offset, dst, dst_offset,
bytes, flags); bytes, read_flags, write_flags);
} }
static void bdrv_parent_cb_resize(BlockDriverState *bs) static void bdrv_parent_cb_resize(BlockDriverState *bs)

9
block/iscsi.c
View File

@ -2193,9 +2193,11 @@ static int coroutine_fn iscsi_co_copy_range_from(BlockDriverState *bs,
BdrvChild *dst, BdrvChild *dst,
uint64_t dst_offset, uint64_t dst_offset,
uint64_t bytes, uint64_t bytes,
BdrvRequestFlags flags) BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes, flags); return bdrv_co_copy_range_to(src, src_offset, dst, dst_offset, bytes,
read_flags, write_flags);
} }
static struct scsi_task *iscsi_xcopy_task(int param_len) static struct scsi_task *iscsi_xcopy_task(int param_len)
@ -2332,7 +2334,8 @@ static int coroutine_fn iscsi_co_copy_range_to(BlockDriverState *bs,
BdrvChild *dst, BdrvChild *dst,
uint64_t dst_offset, uint64_t dst_offset,
uint64_t bytes, uint64_t bytes,
BdrvRequestFlags flags) BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
IscsiLun *dst_lun = dst->bs->opaque; IscsiLun *dst_lun = dst->bs->opaque;
IscsiLun *src_lun; IscsiLun *src_lun;

20
block/qcow2.c
View File

@ -3253,13 +3253,14 @@ static int coroutine_fn
qcow2_co_copy_range_from(BlockDriverState *bs, qcow2_co_copy_range_from(BlockDriverState *bs,
BdrvChild *src, uint64_t src_offset, BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags) uint64_t bytes, BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
int ret; int ret;
unsigned int cur_bytes; /* number of bytes in current iteration */ unsigned int cur_bytes; /* number of bytes in current iteration */
BdrvChild *child = NULL; BdrvChild *child = NULL;
BdrvRequestFlags cur_flags; BdrvRequestFlags cur_write_flags;
assert(!bs->encrypted); assert(!bs->encrypted);
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
@ -3268,7 +3269,7 @@ qcow2_co_copy_range_from(BlockDriverState *bs,
uint64_t copy_offset = 0; uint64_t copy_offset = 0;
/* prepare next request */ /* prepare next request */
cur_bytes = MIN(bytes, INT_MAX); cur_bytes = MIN(bytes, INT_MAX);
cur_flags = flags; cur_write_flags = write_flags;
ret = qcow2_get_cluster_offset(bs, src_offset, &cur_bytes, &copy_offset); ret = qcow2_get_cluster_offset(bs, src_offset, &cur_bytes, &copy_offset);
if (ret < 0) { if (ret < 0) {
@ -3280,20 +3281,20 @@ qcow2_co_copy_range_from(BlockDriverState *bs,
if (bs->backing && bs->backing->bs) { if (bs->backing && bs->backing->bs) {
int64_t backing_length = bdrv_getlength(bs->backing->bs); int64_t backing_length = bdrv_getlength(bs->backing->bs);
if (src_offset >= backing_length) { if (src_offset >= backing_length) {
cur_flags |= BDRV_REQ_ZERO_WRITE; cur_write_flags |= BDRV_REQ_ZERO_WRITE;
} else { } else {
child = bs->backing; child = bs->backing;
cur_bytes = MIN(cur_bytes, backing_length - src_offset); cur_bytes = MIN(cur_bytes, backing_length - src_offset);
copy_offset = src_offset; copy_offset = src_offset;
} }
} else { } else {
cur_flags |= BDRV_REQ_ZERO_WRITE; cur_write_flags |= BDRV_REQ_ZERO_WRITE;
} }
break; break;
case QCOW2_CLUSTER_ZERO_PLAIN: case QCOW2_CLUSTER_ZERO_PLAIN:
case QCOW2_CLUSTER_ZERO_ALLOC: case QCOW2_CLUSTER_ZERO_ALLOC:
cur_flags |= BDRV_REQ_ZERO_WRITE; cur_write_flags |= BDRV_REQ_ZERO_WRITE;
break; break;
case QCOW2_CLUSTER_COMPRESSED: case QCOW2_CLUSTER_COMPRESSED:
@ -3317,7 +3318,7 @@ qcow2_co_copy_range_from(BlockDriverState *bs,
ret = bdrv_co_copy_range_from(child, ret = bdrv_co_copy_range_from(child,
copy_offset, copy_offset,
dst, dst_offset, dst, dst_offset,
cur_bytes, cur_flags); cur_bytes, read_flags, cur_write_flags);
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
@ -3338,7 +3339,8 @@ static int coroutine_fn
qcow2_co_copy_range_to(BlockDriverState *bs, qcow2_co_copy_range_to(BlockDriverState *bs,
BdrvChild *src, uint64_t src_offset, BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags) uint64_t bytes, BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
int offset_in_cluster; int offset_in_cluster;
@ -3382,7 +3384,7 @@ qcow2_co_copy_range_to(BlockDriverState *bs,
ret = bdrv_co_copy_range_to(src, src_offset, ret = bdrv_co_copy_range_to(src, src_offset,
bs->file, bs->file,
cluster_offset + offset_in_cluster, cluster_offset + offset_in_cluster,
cur_bytes, flags); cur_bytes, read_flags, write_flags);
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
if (ret < 0) { if (ret < 0) {
goto fail; goto fail;

24
block/raw-format.c
View File

@ -498,9 +498,13 @@ static int raw_probe_geometry(BlockDriverState *bs, HDGeometry *geo)
} }
static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs, static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
BdrvChild *src, uint64_t src_offset, BdrvChild *src,
BdrvChild *dst, uint64_t dst_offset, uint64_t src_offset,
uint64_t bytes, BdrvRequestFlags flags) BdrvChild *dst,
uint64_t dst_offset,
uint64_t bytes,
BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
int ret; int ret;
@ -509,13 +513,17 @@ static int coroutine_fn raw_co_copy_range_from(BlockDriverState *bs,
return ret; return ret;
} }
return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset, return bdrv_co_copy_range_from(bs->file, src_offset, dst, dst_offset,
bytes, flags); bytes, read_flags, write_flags);
} }
static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs, static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
BdrvChild *src, uint64_t src_offset, BdrvChild *src,
BdrvChild *dst, uint64_t dst_offset, uint64_t src_offset,
uint64_t bytes, BdrvRequestFlags flags) BdrvChild *dst,
uint64_t dst_offset,
uint64_t bytes,
BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags)
{ {
int ret; int ret;
@ -524,7 +532,7 @@ static int coroutine_fn raw_co_copy_range_to(BlockDriverState *bs,
return ret; return ret;
} }
return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes, return bdrv_co_copy_range_to(src, src_offset, bs->file, dst_offset, bytes,
flags); read_flags, write_flags);
} }
BlockDriver bdrv_raw = { BlockDriver bdrv_raw = {

3
include/block/block.h
View File

@ -699,5 +699,6 @@ void bdrv_unregister_buf(BlockDriverState *bs, void *host);
**/ **/
int coroutine_fn bdrv_co_copy_range(BdrvChild *src, uint64_t src_offset, int coroutine_fn bdrv_co_copy_range(BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags); uint64_t bytes, BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags);
#endif #endif

14
include/block/block_int.h
View File

@ -218,7 +218,8 @@ struct BlockDriver {
BdrvChild *dst, BdrvChild *dst,
uint64_t dst_offset, uint64_t dst_offset,
uint64_t bytes, uint64_t bytes,
BdrvRequestFlags flags); BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags);
/* Map [offset, offset + nbytes) range onto a child of bs to copy data to, /* 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 * and invoke bdrv_co_copy_range_to(child, src, ...), or perform the copy
@ -234,7 +235,8 @@ struct BlockDriver {
BdrvChild *dst, BdrvChild *dst,
uint64_t dst_offset, uint64_t dst_offset,
uint64_t bytes, uint64_t bytes,
BdrvRequestFlags flags); BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags);
/* /*
* Building block for bdrv_block_status[_above] and * Building block for bdrv_block_status[_above] and
@ -1156,10 +1158,14 @@ void blockdev_close_all_bdrv_states(void);
int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset, int coroutine_fn bdrv_co_copy_range_from(BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags); uint64_t bytes,
BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags);
int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, uint64_t src_offset, int coroutine_fn bdrv_co_copy_range_to(BdrvChild *src, uint64_t src_offset,
BdrvChild *dst, uint64_t dst_offset, BdrvChild *dst, uint64_t dst_offset,
uint64_t bytes, BdrvRequestFlags flags); uint64_t bytes,
BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags);
int refresh_total_sectors(BlockDriverState *bs, int64_t hint); int refresh_total_sectors(BlockDriverState *bs, int64_t hint);

3
include/sysemu/block-backend.h
View File

@ -234,6 +234,7 @@ void blk_unregister_buf(BlockBackend *blk, void *host);
int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in, int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
BlockBackend *blk_out, int64_t off_out, BlockBackend *blk_out, int64_t off_out,
int bytes, BdrvRequestFlags flags); int bytes, BdrvRequestFlags read_flags,
BdrvRequestFlags write_flags);
#endif #endif

2
qemu-img.c
View File

@ -1783,7 +1783,7 @@ static int coroutine_fn convert_co_copy_range(ImgConvertState *s, int64_t sector
ret = blk_co_copy_range(blk, offset, s->target, ret = blk_co_copy_range(blk, offset, s->target,
sector_num << BDRV_SECTOR_BITS, sector_num << BDRV_SECTOR_BITS,
n << BDRV_SECTOR_BITS, 0); n << BDRV_SECTOR_BITS, 0, 0);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }