2012-01-18 15:40:44 +01:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-01-18 19:01:42 +01:00
|
|
|
#include "qemu/osdep.h"
|
2012-01-18 15:40:44 +01:00
|
|
|
#include "trace.h"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block_int.h"
|
2016-10-27 18:07:00 +02:00
|
|
|
#include "block/blockjob_int.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2015-03-17 17:22:46 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2012-05-09 16:09:46 +02:00
|
|
|
#include "qemu/ratelimit.h"
|
2015-10-19 17:53:22 +02:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-01-18 15:40:44 +01:00
|
|
|
|
|
|
|
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 */
|
|
|
|
};
|
|
|
|
|
2012-01-18 15:40:45 +01:00
|
|
|
#define SLICE_TIME 100000000ULL /* ns */
|
|
|
|
|
2012-01-18 15:40:44 +01:00
|
|
|
typedef struct StreamBlockJob {
|
|
|
|
BlockJob common;
|
2012-01-18 15:40:45 +01:00
|
|
|
RateLimit limit;
|
2012-01-18 15:40:44 +01:00
|
|
|
BlockDriverState *base;
|
2012-09-28 17:22:59 +02:00
|
|
|
BlockdevOnError on_error;
|
block: add backing-file option to block-stream
On some image chains, QEMU may not always be able to resolve the
filenames properly, when updating the backing file of an image
after a block job.
For instance, certain relative pathnames may fail, or drives may
have been specified originally by file descriptor (e.g. /dev/fd/???),
or a relative protocol pathname may have been used.
In these instances, QEMU may lack the information to be able to make
the correct choice, but the user or management layer most likely does
have that knowledge.
With this extension to the block-stream api, the user is able to change
the backing file of the active layer as part of the block-stream
operation.
This allows the change to be 'safe', in the sense that if the attempt
to write the active image metadata fails, then the block-stream
operation returns failure, without disrupting the guest.
If a backing file string is not specified in the command, the backing
file string to use is determined in the same manner as it was
previously.
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-25 21:40:11 +02:00
|
|
|
char *backing_file_str;
|
2016-10-28 09:08:10 +02:00
|
|
|
int bs_flags;
|
2012-01-18 15:40:44 +01:00
|
|
|
} StreamBlockJob;
|
|
|
|
|
2016-04-12 15:15:49 +02:00
|
|
|
static int coroutine_fn stream_populate(BlockBackend *blk,
|
2017-07-07 14:44:41 +02:00
|
|
|
int64_t offset, uint64_t bytes,
|
2012-01-18 15:40:44 +01:00
|
|
|
void *buf)
|
|
|
|
{
|
|
|
|
struct iovec iov = {
|
|
|
|
.iov_base = buf,
|
2017-07-07 14:44:41 +02:00
|
|
|
.iov_len = bytes,
|
2012-01-18 15:40:44 +01:00
|
|
|
};
|
|
|
|
QEMUIOVector qiov;
|
|
|
|
|
2017-07-07 14:44:41 +02:00
|
|
|
assert(bytes < SIZE_MAX);
|
2012-01-18 15:40:44 +01:00
|
|
|
qemu_iovec_init_external(&qiov, &iov, 1);
|
|
|
|
|
|
|
|
/* Copy-on-read the unallocated clusters */
|
2017-07-07 14:44:41 +02:00
|
|
|
return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);
|
2012-01-18 15:40:44 +01:00
|
|
|
}
|
|
|
|
|
2014-10-21 13:03:57 +02:00
|
|
|
typedef struct {
|
|
|
|
int ret;
|
|
|
|
} StreamCompleteData;
|
|
|
|
|
|
|
|
static void stream_complete(BlockJob *job, void *opaque)
|
|
|
|
{
|
|
|
|
StreamBlockJob *s = container_of(job, StreamBlockJob, common);
|
|
|
|
StreamCompleteData *data = opaque;
|
2016-04-12 15:15:49 +02:00
|
|
|
BlockDriverState *bs = blk_bs(job->blk);
|
2014-10-21 13:03:57 +02:00
|
|
|
BlockDriverState *base = s->base;
|
2017-02-17 20:42:32 +01:00
|
|
|
Error *local_err = NULL;
|
2014-10-21 13:03:57 +02:00
|
|
|
|
stream: Drop reached_end for stream_complete()
stream_complete() skips the work of rewriting the backing file if
the job was cancelled, if data->reached_end is false, or if there
was an error detected (non-zero data->ret) during the streaming.
But note that in stream_run(), data->reached_end is only set if the
loop ran to completion, and data->ret is only 0 in two cases:
either the loop ran to completion (possibly by cancellation, but
stream_complete checks for that), or we took an early goto out
because there is no bs->backing. Thus, we can preserve the same
semantics without the use of reached_end, by merely checking for
bs->backing (and logically, if there was no backing file, streaming
is a no-op, so there is no backing file to rewrite).
Suggested-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:42 +02:00
|
|
|
if (!block_job_is_cancelled(&s->common) && bs->backing &&
|
2014-10-21 13:03:57 +02:00
|
|
|
data->ret == 0) {
|
|
|
|
const char *base_id = NULL, *base_fmt = NULL;
|
|
|
|
if (base) {
|
|
|
|
base_id = s->backing_file_str;
|
|
|
|
if (base->drv) {
|
|
|
|
base_fmt = base->drv->format_name;
|
|
|
|
}
|
|
|
|
}
|
2016-04-12 15:15:49 +02:00
|
|
|
data->ret = bdrv_change_backing_file(bs, base_id, base_fmt);
|
2017-02-17 20:42:32 +01:00
|
|
|
bdrv_set_backing_hd(bs, base, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_report_err(local_err);
|
|
|
|
data->ret = -EPERM;
|
|
|
|
goto out;
|
|
|
|
}
|
2014-10-21 13:03:57 +02:00
|
|
|
}
|
|
|
|
|
2017-02-17 20:42:32 +01:00
|
|
|
out:
|
2016-10-28 09:08:10 +02:00
|
|
|
/* Reopen the image back in read-only mode if necessary */
|
|
|
|
if (s->bs_flags != bdrv_get_flags(bs)) {
|
2017-02-09 13:34:18 +01:00
|
|
|
/* Give up write permissions before making it read-only */
|
|
|
|
blk_set_perm(job->blk, 0, BLK_PERM_ALL, &error_abort);
|
2016-10-28 09:08:10 +02:00
|
|
|
bdrv_reopen(bs, s->bs_flags, NULL);
|
|
|
|
}
|
|
|
|
|
2014-10-21 13:03:57 +02:00
|
|
|
g_free(s->backing_file_str);
|
|
|
|
block_job_completed(&s->common, data->ret);
|
|
|
|
g_free(data);
|
|
|
|
}
|
|
|
|
|
2012-01-18 15:40:44 +01:00
|
|
|
static void coroutine_fn stream_run(void *opaque)
|
|
|
|
{
|
|
|
|
StreamBlockJob *s = opaque;
|
2014-10-21 13:03:57 +02:00
|
|
|
StreamCompleteData *data;
|
2016-04-12 15:15:49 +02:00
|
|
|
BlockBackend *blk = s->common.blk;
|
|
|
|
BlockDriverState *bs = blk_bs(blk);
|
2012-01-18 15:40:53 +01:00
|
|
|
BlockDriverState *base = s->base;
|
2017-07-07 14:44:43 +02:00
|
|
|
int64_t offset = 0;
|
Improve block job rate limiting for small bandwidth values
ratelimit_calculate_delay() previously reset the accounting every time
slice, no matter how much data had been processed before. This had (at
least) two consequences:
1. The minimum speed is rather large, e.g. 5 MiB/s for commit and stream.
Not sure if there are real-world use cases where this would be a
problem. Mirroring and backup over a slow link (e.g. DSL) would
come to mind, though.
2. Tests for block job operations (e.g. cancel) were rather racy
All block jobs currently use a time slice of 100ms. That's a
reasonable value to get smooth output during regular
operation. However this also meant that the state of block jobs
changed every 100ms, no matter how low the configured limit was. On
busy hosts, qemu often transferred additional chunks until the test
case had a chance to cancel the job.
Fix the block job rate limit code to delay for more than one time
slice to address the above issues. To make it easier to handle
oversized chunks we switch the semantics from returning a delay
_before_ the current request to a delay _after_ the current
request. If necessary, this delay consists of multiple time slice
units.
Since the mirror job sends multiple chunks in one go even if the rate
limit was exceeded in between, we need to keep track of the start of
the current time slice so we can correctly re-compute the delay for
the updated amount of data.
The minimum bandwidth now is 1 data unit per time slice. The block
jobs are currently passing the amount of data transferred in sectors
and using 100ms time slices, so this translates to 5120
bytes/second. With chunk sizes usually being O(512KiB), tests have
plenty of time (O(100s)) to operate on block jobs. The chance of a
race condition now is fairly remote, except possibly on insanely
loaded systems.
Signed-off-by: Sascha Silbe <silbe@linux.vnet.ibm.com>
Message-id: 1467127721-9564-2-git-send-email-silbe@linux.vnet.ibm.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-06-28 17:28:41 +02:00
|
|
|
uint64_t delay_ns = 0;
|
2012-09-28 17:22:59 +02:00
|
|
|
int error = 0;
|
2012-01-18 15:40:44 +01:00
|
|
|
int ret = 0;
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
int64_t n = 0; /* bytes */
|
2012-01-18 15:40:44 +01:00
|
|
|
void *buf;
|
|
|
|
|
2015-06-17 14:55:21 +02:00
|
|
|
if (!bs->backing) {
|
2016-03-21 14:47:25 +01:00
|
|
|
goto out;
|
2013-11-13 20:37:58 +01:00
|
|
|
}
|
|
|
|
|
2012-01-18 15:40:44 +01:00
|
|
|
s->common.len = bdrv_getlength(bs);
|
|
|
|
if (s->common.len < 0) {
|
2016-03-21 14:47:25 +01:00
|
|
|
ret = s->common.len;
|
|
|
|
goto out;
|
2012-01-18 15:40:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE);
|
|
|
|
|
|
|
|
/* Turn on copy-on-read for the whole block device so that guest read
|
|
|
|
* requests help us make progress. Only do this when copying the entire
|
|
|
|
* backing chain since the copy-on-read operation does not take base into
|
|
|
|
* account.
|
|
|
|
*/
|
|
|
|
if (!base) {
|
|
|
|
bdrv_enable_copy_on_read(bs);
|
|
|
|
}
|
|
|
|
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
for ( ; offset < s->common.len; offset += n) {
|
2012-05-08 16:52:00 +02:00
|
|
|
bool copy;
|
2012-05-08 16:51:45 +02:00
|
|
|
|
|
|
|
/* Note that even when no rate limit is applied we need to yield
|
2012-11-13 16:35:13 +01:00
|
|
|
* with no pending I/O here so that bdrv_drain_all() returns.
|
2012-05-08 16:51:45 +02:00
|
|
|
*/
|
2017-11-29 11:25:11 +01:00
|
|
|
block_job_sleep_ns(&s->common, delay_ns);
|
2012-01-18 15:40:44 +01:00
|
|
|
if (block_job_is_cancelled(&s->common)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-09-22 08:19:10 +02:00
|
|
|
copy = false;
|
|
|
|
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
ret = bdrv_is_allocated(bs, offset, STREAM_BUFFER_SIZE, &n);
|
2012-05-08 16:52:00 +02:00
|
|
|
if (ret == 1) {
|
|
|
|
/* Allocated in the top, no need to copy. */
|
2013-09-04 19:00:25 +02:00
|
|
|
} else if (ret >= 0) {
|
2012-05-08 16:52:00 +02:00
|
|
|
/* Copy if allocated in the intermediate images. Limit to the
|
2017-07-07 14:44:43 +02:00
|
|
|
* known-unallocated area [offset, offset+n*BDRV_SECTOR_SIZE). */
|
2015-06-17 14:55:21 +02:00
|
|
|
ret = bdrv_is_allocated_above(backing_bs(bs), base,
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
offset, n, &n);
|
2012-08-28 16:26:48 +02:00
|
|
|
|
|
|
|
/* Finish early if end of backing file has been reached */
|
|
|
|
if (ret == 0 && n == 0) {
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
n = s->common.len - offset;
|
2012-08-28 16:26:48 +02:00
|
|
|
}
|
|
|
|
|
2012-05-08 16:52:00 +02:00
|
|
|
copy = (ret == 1);
|
|
|
|
}
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
trace_stream_one_iteration(s, offset, n, ret);
|
2013-09-22 08:19:10 +02:00
|
|
|
if (copy) {
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
ret = stream_populate(blk, offset, n, buf);
|
2012-01-18 15:40:44 +01:00
|
|
|
}
|
|
|
|
if (ret < 0) {
|
2012-09-28 17:22:59 +02:00
|
|
|
BlockErrorAction action =
|
2016-04-18 11:36:38 +02:00
|
|
|
block_job_error_action(&s->common, s->on_error, true, -ret);
|
2014-06-18 08:43:30 +02:00
|
|
|
if (action == BLOCK_ERROR_ACTION_STOP) {
|
2012-09-28 17:22:59 +02:00
|
|
|
n = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
error = ret;
|
|
|
|
}
|
2014-06-18 08:43:30 +02:00
|
|
|
if (action == BLOCK_ERROR_ACTION_REPORT) {
|
2012-09-28 17:22:59 +02:00
|
|
|
break;
|
|
|
|
}
|
2012-01-18 15:40:44 +01:00
|
|
|
}
|
2012-01-18 15:40:53 +01:00
|
|
|
ret = 0;
|
2012-01-18 15:40:44 +01:00
|
|
|
|
|
|
|
/* Publish progress */
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
s->common.offset += n;
|
Improve block job rate limiting for small bandwidth values
ratelimit_calculate_delay() previously reset the accounting every time
slice, no matter how much data had been processed before. This had (at
least) two consequences:
1. The minimum speed is rather large, e.g. 5 MiB/s for commit and stream.
Not sure if there are real-world use cases where this would be a
problem. Mirroring and backup over a slow link (e.g. DSL) would
come to mind, though.
2. Tests for block job operations (e.g. cancel) were rather racy
All block jobs currently use a time slice of 100ms. That's a
reasonable value to get smooth output during regular
operation. However this also meant that the state of block jobs
changed every 100ms, no matter how low the configured limit was. On
busy hosts, qemu often transferred additional chunks until the test
case had a chance to cancel the job.
Fix the block job rate limit code to delay for more than one time
slice to address the above issues. To make it easier to handle
oversized chunks we switch the semantics from returning a delay
_before_ the current request to a delay _after_ the current
request. If necessary, this delay consists of multiple time slice
units.
Since the mirror job sends multiple chunks in one go even if the rate
limit was exceeded in between, we need to keep track of the start of
the current time slice so we can correctly re-compute the delay for
the updated amount of data.
The minimum bandwidth now is 1 data unit per time slice. The block
jobs are currently passing the amount of data transferred in sectors
and using 100ms time slices, so this translates to 5120
bytes/second. With chunk sizes usually being O(512KiB), tests have
plenty of time (O(100s)) to operate on block jobs. The chance of a
race condition now is fairly remote, except possibly on insanely
loaded systems.
Signed-off-by: Sascha Silbe <silbe@linux.vnet.ibm.com>
Message-id: 1467127721-9564-2-git-send-email-silbe@linux.vnet.ibm.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-06-28 17:28:41 +02:00
|
|
|
if (copy && s->common.speed) {
|
block: Make bdrv_is_allocated_above() byte-based
We are gradually moving away from sector-based interfaces, towards
byte-based. In the common case, allocation is unlikely to ever use
values that are not naturally sector-aligned, but it is possible
that byte-based values will let us be more precise about allocation
at the end of an unaligned file that can do byte-based access.
Changing the signature of the function to use int64_t *pnum ensures
that the compiler enforces that all callers are updated. For now,
the io.c layer still assert()s that all callers are sector-aligned,
but that can be relaxed when a later patch implements byte-based
block status. Therefore, for the most part this patch is just the
addition of scaling at the callers followed by inverse scaling at
bdrv_is_allocated(). But some code, particularly stream_run(),
gets a lot simpler because it no longer has to mess with sectors.
Leave comments where we can further simplify by switching to
byte-based iterations, once later patches eliminate the need for
sector-aligned operations.
For ease of review, bdrv_is_allocated() was tackled separately.
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
2017-07-07 14:44:59 +02:00
|
|
|
delay_ns = ratelimit_calculate_delay(&s->limit, n);
|
Improve block job rate limiting for small bandwidth values
ratelimit_calculate_delay() previously reset the accounting every time
slice, no matter how much data had been processed before. This had (at
least) two consequences:
1. The minimum speed is rather large, e.g. 5 MiB/s for commit and stream.
Not sure if there are real-world use cases where this would be a
problem. Mirroring and backup over a slow link (e.g. DSL) would
come to mind, though.
2. Tests for block job operations (e.g. cancel) were rather racy
All block jobs currently use a time slice of 100ms. That's a
reasonable value to get smooth output during regular
operation. However this also meant that the state of block jobs
changed every 100ms, no matter how low the configured limit was. On
busy hosts, qemu often transferred additional chunks until the test
case had a chance to cancel the job.
Fix the block job rate limit code to delay for more than one time
slice to address the above issues. To make it easier to handle
oversized chunks we switch the semantics from returning a delay
_before_ the current request to a delay _after_ the current
request. If necessary, this delay consists of multiple time slice
units.
Since the mirror job sends multiple chunks in one go even if the rate
limit was exceeded in between, we need to keep track of the start of
the current time slice so we can correctly re-compute the delay for
the updated amount of data.
The minimum bandwidth now is 1 data unit per time slice. The block
jobs are currently passing the amount of data transferred in sectors
and using 100ms time slices, so this translates to 5120
bytes/second. With chunk sizes usually being O(512KiB), tests have
plenty of time (O(100s)) to operate on block jobs. The chance of a
race condition now is fairly remote, except possibly on insanely
loaded systems.
Signed-off-by: Sascha Silbe <silbe@linux.vnet.ibm.com>
Message-id: 1467127721-9564-2-git-send-email-silbe@linux.vnet.ibm.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
2016-06-28 17:28:41 +02:00
|
|
|
}
|
2012-01-18 15:40:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!base) {
|
|
|
|
bdrv_disable_copy_on_read(bs);
|
|
|
|
}
|
|
|
|
|
2012-09-28 17:22:59 +02:00
|
|
|
/* Do not remove the backing file if an error was there but ignored. */
|
|
|
|
ret = error;
|
|
|
|
|
2012-01-18 15:40:44 +01:00
|
|
|
qemu_vfree(buf);
|
2014-10-21 13:03:57 +02:00
|
|
|
|
2016-03-21 14:47:25 +01:00
|
|
|
out:
|
2014-10-21 13:03:57 +02:00
|
|
|
/* Modify backing chain and close BDSes in main loop */
|
|
|
|
data = g_malloc(sizeof(*data));
|
|
|
|
data->ret = ret;
|
|
|
|
block_job_defer_to_main_loop(&s->common, stream_complete, data);
|
2012-01-18 15:40:44 +01:00
|
|
|
}
|
|
|
|
|
2012-04-25 17:51:02 +02:00
|
|
|
static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)
|
2012-01-18 15:40:45 +01:00
|
|
|
{
|
|
|
|
StreamBlockJob *s = container_of(job, StreamBlockJob, common);
|
|
|
|
|
2012-04-25 17:51:02 +02:00
|
|
|
if (speed < 0) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, "speed");
|
2012-04-25 17:51:01 +02:00
|
|
|
return;
|
2012-01-18 15:40:45 +01:00
|
|
|
}
|
2017-07-07 14:44:39 +02:00
|
|
|
ratelimit_set_speed(&s->limit, speed, SLICE_TIME);
|
2012-01-18 15:40:45 +01:00
|
|
|
}
|
|
|
|
|
2013-10-08 11:29:38 +02:00
|
|
|
static const BlockJobDriver stream_job_driver = {
|
2012-01-18 15:40:44 +01:00
|
|
|
.instance_size = sizeof(StreamBlockJob),
|
2013-10-08 11:29:40 +02:00
|
|
|
.job_type = BLOCK_JOB_TYPE_STREAM,
|
2012-01-18 15:40:45 +01:00
|
|
|
.set_speed = stream_set_speed,
|
2016-11-08 07:50:36 +01:00
|
|
|
.start = stream_run,
|
2012-01-18 15:40:44 +01:00
|
|
|
};
|
|
|
|
|
2016-07-05 16:28:59 +02:00
|
|
|
void stream_start(const char *job_id, BlockDriverState *bs,
|
|
|
|
BlockDriverState *base, const char *backing_file_str,
|
2016-10-27 18:06:58 +02:00
|
|
|
int64_t speed, BlockdevOnError on_error, Error **errp)
|
2012-01-18 15:40:44 +01:00
|
|
|
{
|
|
|
|
StreamBlockJob *s;
|
2016-10-28 09:08:10 +02:00
|
|
|
BlockDriverState *iter;
|
|
|
|
int orig_bs_flags;
|
2012-01-18 15:40:44 +01:00
|
|
|
|
2016-10-28 09:08:10 +02:00
|
|
|
/* Make sure that the image is opened in read-write mode */
|
|
|
|
orig_bs_flags = bdrv_get_flags(bs);
|
|
|
|
if (!(orig_bs_flags & BDRV_O_RDWR)) {
|
|
|
|
if (bdrv_reopen(bs, orig_bs_flags | BDRV_O_RDWR, errp) != 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-09 13:34:18 +01:00
|
|
|
/* Prevent concurrent jobs trying to modify the graph structure here, we
|
|
|
|
* already have our own plans. Also don't allow resize as the image size is
|
|
|
|
* queried only at the job start and then cached. */
|
2018-03-10 09:27:27 +01:00
|
|
|
s = block_job_create(job_id, &stream_job_driver, NULL, bs,
|
2017-02-09 13:34:18 +01:00
|
|
|
BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
|
|
|
|
BLK_PERM_GRAPH_MOD,
|
|
|
|
BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
|
|
|
|
BLK_PERM_WRITE,
|
|
|
|
speed, BLOCK_JOB_DEFAULT, NULL, NULL, errp);
|
|
|
|
if (!s) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Block all intermediate nodes between bs and base, because they will
|
|
|
|
* disappear from the chain after this operation. The streaming job reads
|
|
|
|
* every block only once, assuming that it doesn't change, so block writes
|
|
|
|
* and resizes. */
|
2016-10-28 09:08:10 +02:00
|
|
|
for (iter = backing_bs(bs); iter && iter != base; iter = backing_bs(iter)) {
|
2017-01-17 11:56:42 +01:00
|
|
|
block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
|
2017-02-09 13:34:18 +01:00
|
|
|
BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED,
|
|
|
|
&error_abort);
|
2016-10-28 09:08:10 +02:00
|
|
|
}
|
|
|
|
|
2012-01-18 15:40:44 +01:00
|
|
|
s->base = base;
|
block: add backing-file option to block-stream
On some image chains, QEMU may not always be able to resolve the
filenames properly, when updating the backing file of an image
after a block job.
For instance, certain relative pathnames may fail, or drives may
have been specified originally by file descriptor (e.g. /dev/fd/???),
or a relative protocol pathname may have been used.
In these instances, QEMU may lack the information to be able to make
the correct choice, but the user or management layer most likely does
have that knowledge.
With this extension to the block-stream api, the user is able to change
the backing file of the active layer as part of the block-stream
operation.
This allows the change to be 'safe', in the sense that if the attempt
to write the active image metadata fails, then the block-stream
operation returns failure, without disrupting the guest.
If a backing file string is not specified in the command, the backing
file string to use is determined in the same manner as it was
previously.
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-25 21:40:11 +02:00
|
|
|
s->backing_file_str = g_strdup(backing_file_str);
|
2016-10-28 09:08:10 +02:00
|
|
|
s->bs_flags = orig_bs_flags;
|
2012-01-18 15:40:44 +01:00
|
|
|
|
2012-09-28 17:22:59 +02:00
|
|
|
s->on_error = on_error;
|
2016-11-08 07:50:37 +01:00
|
|
|
trace_stream_start(bs, base, s);
|
|
|
|
block_job_start(&s->common);
|
2017-02-09 13:34:18 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (orig_bs_flags != bdrv_get_flags(bs)) {
|
2017-05-15 11:34:24 +02:00
|
|
|
bdrv_reopen(bs, orig_bs_flags, NULL);
|
2017-02-09 13:34:18 +01:00
|
|
|
}
|
2012-01-18 15:40:44 +01:00
|
|
|
}
|