Message ID | 1323784351-25531-4-git-send-email-stefanha@linux.vnet.ibm.com |
---|---|
State | New |
Headers | show |
On Tue, Dec 13, 2011 at 01:52:25PM +0000, Stefan Hajnoczi wrote: > Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> > --- > Makefile.objs | 1 + > block/stream.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > block_int.h | 3 + > trace-events | 4 ++ > 4 files changed, 129 insertions(+), 0 deletions(-) > create mode 100644 block/stream.c > > diff --git a/Makefile.objs b/Makefile.objs > index d737d81..025cc08 100644 > --- a/Makefile.objs > +++ b/Makefile.objs > @@ -34,6 +34,7 @@ block-nested-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow > block-nested-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o > block-nested-y += qed-check.o > block-nested-y += parallels.o nbd.o blkdebug.o sheepdog.o blkverify.o > +block-nested-y += stream.o > block-nested-$(CONFIG_WIN32) += raw-win32.o > block-nested-$(CONFIG_POSIX) += raw-posix.o > block-nested-$(CONFIG_LIBISCSI) += iscsi.o > diff --git a/block/stream.c b/block/stream.c > new file mode 100644 > index 0000000..7d362ab > --- /dev/null > +++ b/block/stream.c > @@ -0,0 +1,121 @@ > +/* > + * Image streaming > + * > + * Copyright IBM, Corp. 2011 > + * > + * Authors: > + * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> > + * > + * This work is licensed under the terms of the GNU LGPL, version 2 or later. > + * See the COPYING.LIB file in the top-level directory. > + * > + */ > + > +#include "trace.h" > +#include "block_int.h" > + > +enum { > + /* > + * Size of data buffer for populating the image file. This should be large > + * enough to process multiple clusters in a single call, so that populating > + * contiguous regions of the image is efficient. > + */ > + STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */ > +}; > + > +typedef struct StreamBlockJob { > + BlockJob common; > + BlockDriverState *base; > +} StreamBlockJob; > + > +static int coroutine_fn stream_populate(BlockDriverState *bs, > + int64_t sector_num, int nb_sectors, > + void *buf) > +{ > + struct iovec iov = { > + .iov_base = buf, > + .iov_len = nb_sectors * BDRV_SECTOR_SIZE, > + }; > + QEMUIOVector qiov; > + > + qemu_iovec_init_external(&qiov, &iov, 1); > + > + /* Copy-on-read the unallocated clusters */ > + return bdrv_co_readv(bs, sector_num, nb_sectors, &qiov); > +} > + > +static void coroutine_fn stream_run(void *opaque) > +{ > + StreamBlockJob *s = opaque; > + BlockDriverState *bs = s->common.bs; > + int64_t sector_num, end; > + int ret = 0; > + int n; > + void *buf; > + > + buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE); > + s->common.len = bdrv_getlength(bs); > + bdrv_get_geometry(bs, (uint64_t *)&end); > + > + bdrv_enable_zero_detection(bs); > + bdrv_enable_copy_on_read(bs); > + > + for (sector_num = 0; sector_num < end; sector_num += n) { > + if (block_job_is_cancelled(&s->common)) { > + break; > + } > + > + /* TODO rate-limit */ > + /* Note that even when no rate limit is applied we need to yield with > + * no pending I/O here so that qemu_aio_flush() is able to return. > + */ > + co_sleep_ns(rt_clock, 0); > + > + ret = bdrv_co_is_allocated(bs, sector_num, > + STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); > + trace_stream_one_iteration(s, sector_num, n, ret); > + if (ret == 0) { > + ret = stream_populate(bs, sector_num, n, buf); > + } > + if (ret < 0) { > + break; > + } > + > + /* Publish progress */ > + s->common.offset += n * BDRV_SECTOR_SIZE; > + } > + > + bdrv_disable_copy_on_read(bs); > + bdrv_disable_zero_detection(bs); > + > + if (sector_num == end && ret == 0) { > + bdrv_change_backing_file(bs, NULL, NULL); > + } In fact there is no need for a new command to switch backing file, it can be done here for the shared base case also.
On Tue, Dec 13, 2011 at 2:14 PM, Marcelo Tosatti <mtosatti@redhat.com> wrote: > On Tue, Dec 13, 2011 at 01:52:25PM +0000, Stefan Hajnoczi wrote: >> Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> >> --- >> Makefile.objs | 1 + >> block/stream.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ >> block_int.h | 3 + >> trace-events | 4 ++ >> 4 files changed, 129 insertions(+), 0 deletions(-) >> create mode 100644 block/stream.c >> >> diff --git a/Makefile.objs b/Makefile.objs >> index d737d81..025cc08 100644 >> --- a/Makefile.objs >> +++ b/Makefile.objs >> @@ -34,6 +34,7 @@ block-nested-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow >> block-nested-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o >> block-nested-y += qed-check.o >> block-nested-y += parallels.o nbd.o blkdebug.o sheepdog.o blkverify.o >> +block-nested-y += stream.o >> block-nested-$(CONFIG_WIN32) += raw-win32.o >> block-nested-$(CONFIG_POSIX) += raw-posix.o >> block-nested-$(CONFIG_LIBISCSI) += iscsi.o >> diff --git a/block/stream.c b/block/stream.c >> new file mode 100644 >> index 0000000..7d362ab >> --- /dev/null >> +++ b/block/stream.c >> @@ -0,0 +1,121 @@ >> +/* >> + * Image streaming >> + * >> + * Copyright IBM, Corp. 2011 >> + * >> + * Authors: >> + * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> >> + * >> + * This work is licensed under the terms of the GNU LGPL, version 2 or later. >> + * See the COPYING.LIB file in the top-level directory. >> + * >> + */ >> + >> +#include "trace.h" >> +#include "block_int.h" >> + >> +enum { >> + /* >> + * Size of data buffer for populating the image file. This should be large >> + * enough to process multiple clusters in a single call, so that populating >> + * contiguous regions of the image is efficient. >> + */ >> + STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */ >> +}; >> + >> +typedef struct StreamBlockJob { >> + BlockJob common; >> + BlockDriverState *base; >> +} StreamBlockJob; >> + >> +static int coroutine_fn stream_populate(BlockDriverState *bs, >> + int64_t sector_num, int nb_sectors, >> + void *buf) >> +{ >> + struct iovec iov = { >> + .iov_base = buf, >> + .iov_len = nb_sectors * BDRV_SECTOR_SIZE, >> + }; >> + QEMUIOVector qiov; >> + >> + qemu_iovec_init_external(&qiov, &iov, 1); >> + >> + /* Copy-on-read the unallocated clusters */ >> + return bdrv_co_readv(bs, sector_num, nb_sectors, &qiov); >> +} >> + >> +static void coroutine_fn stream_run(void *opaque) >> +{ >> + StreamBlockJob *s = opaque; >> + BlockDriverState *bs = s->common.bs; >> + int64_t sector_num, end; >> + int ret = 0; >> + int n; >> + void *buf; >> + >> + buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE); >> + s->common.len = bdrv_getlength(bs); >> + bdrv_get_geometry(bs, (uint64_t *)&end); >> + >> + bdrv_enable_zero_detection(bs); >> + bdrv_enable_copy_on_read(bs); >> + >> + for (sector_num = 0; sector_num < end; sector_num += n) { >> + if (block_job_is_cancelled(&s->common)) { >> + break; >> + } >> + >> + /* TODO rate-limit */ >> + /* Note that even when no rate limit is applied we need to yield with >> + * no pending I/O here so that qemu_aio_flush() is able to return. >> + */ >> + co_sleep_ns(rt_clock, 0); >> + >> + ret = bdrv_co_is_allocated(bs, sector_num, >> + STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); >> + trace_stream_one_iteration(s, sector_num, n, ret); >> + if (ret == 0) { >> + ret = stream_populate(bs, sector_num, n, buf); >> + } >> + if (ret < 0) { >> + break; >> + } >> + >> + /* Publish progress */ >> + s->common.offset += n * BDRV_SECTOR_SIZE; >> + } >> + >> + bdrv_disable_copy_on_read(bs); >> + bdrv_disable_zero_detection(bs); >> + >> + if (sector_num == end && ret == 0) { >> + bdrv_change_backing_file(bs, NULL, NULL); >> + } > > In fact there is no need for a new command to switch backing file, > it can be done here for the shared base case also. Agreed. Stefan
Am 13.12.2011 14:52, schrieb Stefan Hajnoczi: > Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> > --- > Makefile.objs | 1 + > block/stream.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > block_int.h | 3 + > trace-events | 4 ++ > 4 files changed, 129 insertions(+), 0 deletions(-) > create mode 100644 block/stream.c > > diff --git a/Makefile.objs b/Makefile.objs > index d737d81..025cc08 100644 > --- a/Makefile.objs > +++ b/Makefile.objs > @@ -34,6 +34,7 @@ block-nested-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow > block-nested-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o > block-nested-y += qed-check.o > block-nested-y += parallels.o nbd.o blkdebug.o sheepdog.o blkverify.o > +block-nested-y += stream.o > block-nested-$(CONFIG_WIN32) += raw-win32.o > block-nested-$(CONFIG_POSIX) += raw-posix.o > block-nested-$(CONFIG_LIBISCSI) += iscsi.o > diff --git a/block/stream.c b/block/stream.c > new file mode 100644 > index 0000000..7d362ab > --- /dev/null > +++ b/block/stream.c > @@ -0,0 +1,121 @@ > +/* > + * Image streaming > + * > + * Copyright IBM, Corp. 2011 > + * > + * Authors: > + * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> > + * > + * This work is licensed under the terms of the GNU LGPL, version 2 or later. > + * See the COPYING.LIB file in the top-level directory. > + * > + */ > + > +#include "trace.h" > +#include "block_int.h" > + > +enum { > + /* > + * Size of data buffer for populating the image file. This should be large > + * enough to process multiple clusters in a single call, so that populating > + * contiguous regions of the image is efficient. > + */ > + STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */ > +}; > + > +typedef struct StreamBlockJob { > + BlockJob common; > + BlockDriverState *base; > +} StreamBlockJob; > + > +static int coroutine_fn stream_populate(BlockDriverState *bs, > + int64_t sector_num, int nb_sectors, > + void *buf) > +{ > + struct iovec iov = { > + .iov_base = buf, > + .iov_len = nb_sectors * BDRV_SECTOR_SIZE, > + }; > + QEMUIOVector qiov; > + > + qemu_iovec_init_external(&qiov, &iov, 1); > + > + /* Copy-on-read the unallocated clusters */ > + return bdrv_co_readv(bs, sector_num, nb_sectors, &qiov); > +} > + > +static void coroutine_fn stream_run(void *opaque) > +{ > + StreamBlockJob *s = opaque; > + BlockDriverState *bs = s->common.bs; > + int64_t sector_num, end; > + int ret = 0; > + int n; > + void *buf; > + > + buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE); > + s->common.len = bdrv_getlength(bs); > + bdrv_get_geometry(bs, (uint64_t *)&end); > + > + bdrv_enable_zero_detection(bs); I still don't agree with this all-or-nothing switch. The default that you want to have is zero detection on COR, but no additional overhead for guest-initiated writes. > + bdrv_enable_copy_on_read(bs); > + > + for (sector_num = 0; sector_num < end; sector_num += n) { > + if (block_job_is_cancelled(&s->common)) { > + break; > + } > + > + /* TODO rate-limit */ > + /* Note that even when no rate limit is applied we need to yield with > + * no pending I/O here so that qemu_aio_flush() is able to return. > + */ > + co_sleep_ns(rt_clock, 0); > + > + ret = bdrv_co_is_allocated(bs, sector_num, > + STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); > + trace_stream_one_iteration(s, sector_num, n, ret); > + if (ret == 0) { > + ret = stream_populate(bs, sector_num, n, buf); > + } > + if (ret < 0) { > + break; > + } > + > + /* Publish progress */ > + s->common.offset += n * BDRV_SECTOR_SIZE; > + } > + > + bdrv_disable_copy_on_read(bs); > + bdrv_disable_zero_detection(bs); > + > + if (sector_num == end && ret == 0) { > + bdrv_change_backing_file(bs, NULL, NULL); Need to check the return value. Kevin
diff --git a/Makefile.objs b/Makefile.objs index d737d81..025cc08 100644 --- a/Makefile.objs +++ b/Makefile.objs @@ -34,6 +34,7 @@ block-nested-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow block-nested-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o block-nested-y += qed-check.o block-nested-y += parallels.o nbd.o blkdebug.o sheepdog.o blkverify.o +block-nested-y += stream.o block-nested-$(CONFIG_WIN32) += raw-win32.o block-nested-$(CONFIG_POSIX) += raw-posix.o block-nested-$(CONFIG_LIBISCSI) += iscsi.o diff --git a/block/stream.c b/block/stream.c new file mode 100644 index 0000000..7d362ab --- /dev/null +++ b/block/stream.c @@ -0,0 +1,121 @@ +/* + * Image streaming + * + * Copyright IBM, Corp. 2011 + * + * Authors: + * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> + * + * This work is licensed under the terms of the GNU LGPL, version 2 or later. + * See the COPYING.LIB file in the top-level directory. + * + */ + +#include "trace.h" +#include "block_int.h" + +enum { + /* + * Size of data buffer for populating the image file. This should be large + * enough to process multiple clusters in a single call, so that populating + * contiguous regions of the image is efficient. + */ + STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */ +}; + +typedef struct StreamBlockJob { + BlockJob common; + BlockDriverState *base; +} StreamBlockJob; + +static int coroutine_fn stream_populate(BlockDriverState *bs, + int64_t sector_num, int nb_sectors, + void *buf) +{ + struct iovec iov = { + .iov_base = buf, + .iov_len = nb_sectors * BDRV_SECTOR_SIZE, + }; + QEMUIOVector qiov; + + qemu_iovec_init_external(&qiov, &iov, 1); + + /* Copy-on-read the unallocated clusters */ + return bdrv_co_readv(bs, sector_num, nb_sectors, &qiov); +} + +static void coroutine_fn stream_run(void *opaque) +{ + StreamBlockJob *s = opaque; + BlockDriverState *bs = s->common.bs; + int64_t sector_num, end; + int ret = 0; + int n; + void *buf; + + buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE); + s->common.len = bdrv_getlength(bs); + bdrv_get_geometry(bs, (uint64_t *)&end); + + bdrv_enable_zero_detection(bs); + bdrv_enable_copy_on_read(bs); + + for (sector_num = 0; sector_num < end; sector_num += n) { + if (block_job_is_cancelled(&s->common)) { + break; + } + + /* TODO rate-limit */ + /* Note that even when no rate limit is applied we need to yield with + * no pending I/O here so that qemu_aio_flush() is able to return. + */ + co_sleep_ns(rt_clock, 0); + + ret = bdrv_co_is_allocated(bs, sector_num, + STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); + trace_stream_one_iteration(s, sector_num, n, ret); + if (ret == 0) { + ret = stream_populate(bs, sector_num, n, buf); + } + if (ret < 0) { + break; + } + + /* Publish progress */ + s->common.offset += n * BDRV_SECTOR_SIZE; + } + + bdrv_disable_copy_on_read(bs); + bdrv_disable_zero_detection(bs); + + if (sector_num == end && ret == 0) { + bdrv_change_backing_file(bs, NULL, NULL); + } + + qemu_vfree(buf); + block_job_complete(&s->common, ret); +} + +static BlockJobType stream_job_type = { + .instance_size = sizeof(StreamBlockJob), + .job_type = "stream", +}; + +int stream_start(BlockDriverState *bs, BlockDriverState *base, + BlockDriverCompletionFunc *cb, void *opaque) +{ + StreamBlockJob *s; + Coroutine *co; + + if (bs->job) { + return -EBUSY; + } + + s = block_job_create(&stream_job_type, bs, cb, opaque); + s->base = base; + + co = qemu_coroutine_create(stream_run); + trace_stream_start(bs, base, s, co, opaque); + qemu_coroutine_enter(co, s); + return 0; +} diff --git a/block_int.h b/block_int.h index bc397c4..614e4e2 100644 --- a/block_int.h +++ b/block_int.h @@ -376,4 +376,7 @@ static inline bool block_job_is_cancelled(BlockJob *job) return job->cancelled; } +int stream_start(BlockDriverState *bs, BlockDriverState *base, + BlockDriverCompletionFunc *cb, void *opaque); + #endif /* BLOCK_INT_H */ diff --git a/trace-events b/trace-events index 514849a..4efcd95 100644 --- a/trace-events +++ b/trace-events @@ -69,6 +69,10 @@ bdrv_co_writev(void *bs, int64_t sector_num, int nb_sector) "bs %p sector_num %" bdrv_co_io_em(void *bs, int64_t sector_num, int nb_sectors, int is_write, void *acb) "bs %p sector_num %"PRId64" nb_sectors %d is_write %d acb %p" bdrv_co_copy_on_readv(void *bs, int64_t sector_num, int nb_sectors, int64_t cluster_sector_num, int cluster_nb_sectors) "bs %p sector_num %"PRId64" nb_sectors %d cluster_sector_num %"PRId64" cluster_nb_sectors %d" +# block/stream.c +stream_one_iteration(void *s, int64_t sector_num, int nb_sectors, int is_allocated) "s %p sector_num %"PRId64" nb_sectors %d is_allocated %d" +stream_start(void *bs, void *base, void *s, void *co, void *opaque) "bs %p base %p s %p co %p opaque %p" + # hw/virtio-blk.c virtio_blk_req_complete(void *req, int status) "req %p status %d" virtio_blk_rw_complete(void *req, int ret) "req %p ret %d"
Signed-off-by: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> --- Makefile.objs | 1 + block/stream.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ block_int.h | 3 + trace-events | 4 ++ 4 files changed, 129 insertions(+), 0 deletions(-) create mode 100644 block/stream.c