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

stream: Switch stream_run() to byte-based 

We are gradually converting to byte-based interfaces, as they are
easier to reason about than sector-based.  Change the internal
loop iteration of streaming to track by bytes instead of sectors
(although we are still guaranteed that we iterate by steps that
are sector-aligned).

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Eric Blake 2017-07-07 07:44:43 -05:00 committed by Kevin Wolf
parent 158c649257
commit d535435f4a
1 changed files with 9 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
block/stream.c
View File

@ -107,12 +107,11 @@ static void coroutine_fn stream_run(void *opaque)
BlockBackend *blk = s->common.blk; BlockBackend *blk = s->common.blk;
BlockDriverState *bs = blk_bs(blk); BlockDriverState *bs = blk_bs(blk);
BlockDriverState *base = s->base; BlockDriverState *base = s->base;
int64_t sector_num = 0; int64_t offset = 0;
int64_t end = -1;
uint64_t delay_ns = 0; uint64_t delay_ns = 0;
int error = 0; int error = 0;
int ret = 0; int ret = 0;
int n = 0; int n = 0; /* sectors */
void *buf; void *buf;
if (!bs->backing) { if (!bs->backing) {
@ -125,7 +124,6 @@ static void coroutine_fn stream_run(void *opaque)
goto out; goto out;
} }
end = s->common.len >> BDRV_SECTOR_BITS;
buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE); buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE);
/* Turn on copy-on-read for the whole block device so that guest read /* Turn on copy-on-read for the whole block device so that guest read
@ -137,7 +135,7 @@ static void coroutine_fn stream_run(void *opaque)
bdrv_enable_copy_on_read(bs); bdrv_enable_copy_on_read(bs);
} }
for (sector_num = 0; sector_num < end; sector_num += n) { for ( ; offset < s->common.len; offset += n * BDRV_SECTOR_SIZE) {
bool copy; bool copy;
/* Note that even when no rate limit is applied we need to yield /* Note that even when no rate limit is applied we need to yield
@ -150,28 +148,26 @@ static void coroutine_fn stream_run(void *opaque)
copy = false; copy = false;
ret = bdrv_is_allocated(bs, sector_num, ret = bdrv_is_allocated(bs, offset / BDRV_SECTOR_SIZE,
STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n);
if (ret == 1) { if (ret == 1) {
/* Allocated in the top, no need to copy. */ /* Allocated in the top, no need to copy. */
} else if (ret >= 0) { } else if (ret >= 0) {
/* Copy if allocated in the intermediate images. Limit to the /* Copy if allocated in the intermediate images. Limit to the
* known-unallocated area [sector_num, sector_num+n). */ * known-unallocated area [offset, offset+n*BDRV_SECTOR_SIZE). */
ret = bdrv_is_allocated_above(backing_bs(bs), base, ret = bdrv_is_allocated_above(backing_bs(bs), base,
sector_num, n, &n); offset / BDRV_SECTOR_SIZE, n, &n);
/* Finish early if end of backing file has been reached */ /* Finish early if end of backing file has been reached */
if (ret == 0 && n == 0) { if (ret == 0 && n == 0) {
n = end - sector_num; n = (s->common.len - offset) / BDRV_SECTOR_SIZE;
} }
copy = (ret == 1); copy = (ret == 1);
} }
trace_stream_one_iteration(s, sector_num * BDRV_SECTOR_SIZE, trace_stream_one_iteration(s, offset, n * BDRV_SECTOR_SIZE, ret);
n * BDRV_SECTOR_SIZE, ret);
if (copy) { if (copy) {
ret = stream_populate(blk, sector_num * BDRV_SECTOR_SIZE, ret = stream_populate(blk, offset, n * BDRV_SECTOR_SIZE, buf);
n * BDRV_SECTOR_SIZE, buf);
} }
if (ret < 0) { if (ret < 0) {
BlockErrorAction action = BlockErrorAction action =