2012-09-27 19:29:13 +02:00
|
|
|
/*
|
|
|
|
* Live block commit
|
|
|
|
*
|
|
|
|
* Copyright Red Hat, Inc. 2012
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Jeff Cody <jcody@redhat.com>
|
|
|
|
* Based on stream.c by Stefan Hajnoczi
|
|
|
|
*
|
|
|
|
* 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"
|
2012-12-17 18:19:44 +01:00
|
|
|
#include "block/block_int.h"
|
|
|
|
#include "block/blockjob.h"
|
2015-03-17 17:22:46 +01:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2012-09-27 19:29:13 +02:00
|
|
|
#include "qemu/ratelimit.h"
|
2015-10-19 17:53:22 +02:00
|
|
|
#include "sysemu/block-backend.h"
|
2012-09-27 19:29:13 +02: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.
|
|
|
|
*/
|
|
|
|
COMMIT_BUFFER_SIZE = 512 * 1024, /* in bytes */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define SLICE_TIME 100000000ULL /* ns */
|
|
|
|
|
|
|
|
typedef struct CommitBlockJob {
|
|
|
|
BlockJob common;
|
|
|
|
RateLimit limit;
|
|
|
|
BlockDriverState *active;
|
|
|
|
BlockDriverState *top;
|
|
|
|
BlockDriverState *base;
|
2012-09-28 17:22:55 +02:00
|
|
|
BlockdevOnError on_error;
|
2012-09-27 19:29:13 +02:00
|
|
|
int base_flags;
|
|
|
|
int orig_overlay_flags;
|
block: extend block-commit to accept a string for the backing file
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 commit.
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-commit api, the user is able to change
the backing file of the overlay image as part of the block-commit
operation.
This allows the change to be 'safe', in the sense that if the attempt
to write the overlay image metadata fails, then the block-commit
operation returns failure, without disrupting the guest.
If the commit top is the active layer, then specifying the backing
file string will be treated as an error (there is no overlay image
to modify in that case).
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>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-25 21:40:10 +02:00
|
|
|
char *backing_file_str;
|
2012-09-27 19:29:13 +02:00
|
|
|
} CommitBlockJob;
|
|
|
|
|
|
|
|
static int coroutine_fn commit_populate(BlockDriverState *bs,
|
|
|
|
BlockDriverState *base,
|
|
|
|
int64_t sector_num, int nb_sectors,
|
|
|
|
void *buf)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
ret = bdrv_read(bs, sector_num, buf, nb_sectors);
|
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = bdrv_write(base, sector_num, buf, nb_sectors);
|
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-21 13:03:59 +02:00
|
|
|
typedef struct {
|
|
|
|
int ret;
|
|
|
|
} CommitCompleteData;
|
|
|
|
|
|
|
|
static void commit_complete(BlockJob *job, void *opaque)
|
2012-09-27 19:29:13 +02:00
|
|
|
{
|
2014-10-21 13:03:59 +02:00
|
|
|
CommitBlockJob *s = container_of(job, CommitBlockJob, common);
|
|
|
|
CommitCompleteData *data = opaque;
|
2012-09-27 19:29:13 +02:00
|
|
|
BlockDriverState *active = s->active;
|
|
|
|
BlockDriverState *top = s->top;
|
|
|
|
BlockDriverState *base = s->base;
|
2013-01-15 16:47:24 +01:00
|
|
|
BlockDriverState *overlay_bs;
|
2014-10-21 13:03:59 +02:00
|
|
|
int ret = data->ret;
|
|
|
|
|
|
|
|
if (!block_job_is_cancelled(&s->common) && ret == 0) {
|
|
|
|
/* success */
|
|
|
|
ret = bdrv_drop_intermediate(active, top, base, s->backing_file_str);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* restore base open flags here if appropriate (e.g., change the base back
|
|
|
|
* to r/o). These reopens do not need to be atomic, since we won't abort
|
|
|
|
* even on failure here */
|
|
|
|
if (s->base_flags != bdrv_get_flags(base)) {
|
|
|
|
bdrv_reopen(base, s->base_flags, NULL);
|
|
|
|
}
|
|
|
|
overlay_bs = bdrv_find_overlay(active, top);
|
|
|
|
if (overlay_bs && s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {
|
|
|
|
bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);
|
|
|
|
}
|
|
|
|
g_free(s->backing_file_str);
|
|
|
|
block_job_completed(&s->common, ret);
|
|
|
|
g_free(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void coroutine_fn commit_run(void *opaque)
|
|
|
|
{
|
|
|
|
CommitBlockJob *s = opaque;
|
|
|
|
CommitCompleteData *data;
|
|
|
|
BlockDriverState *top = s->top;
|
|
|
|
BlockDriverState *base = s->base;
|
2012-09-27 19:29:13 +02:00
|
|
|
int64_t sector_num, end;
|
|
|
|
int ret = 0;
|
|
|
|
int n = 0;
|
2014-10-21 13:03:59 +02:00
|
|
|
void *buf = NULL;
|
2012-09-27 19:29:13 +02:00
|
|
|
int bytes_written = 0;
|
|
|
|
int64_t base_len;
|
|
|
|
|
|
|
|
ret = s->common.len = bdrv_getlength(top);
|
|
|
|
|
|
|
|
|
|
|
|
if (s->common.len < 0) {
|
2014-10-21 13:03:59 +02:00
|
|
|
goto out;
|
2012-09-27 19:29:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = base_len = bdrv_getlength(base);
|
|
|
|
if (base_len < 0) {
|
2014-10-21 13:03:59 +02:00
|
|
|
goto out;
|
2012-09-27 19:29:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (base_len < s->common.len) {
|
|
|
|
ret = bdrv_truncate(base, s->common.len);
|
|
|
|
if (ret) {
|
2014-10-21 13:03:59 +02:00
|
|
|
goto out;
|
2012-09-27 19:29:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
end = s->common.len >> BDRV_SECTOR_BITS;
|
|
|
|
buf = qemu_blockalign(top, COMMIT_BUFFER_SIZE);
|
|
|
|
|
|
|
|
for (sector_num = 0; sector_num < end; sector_num += n) {
|
|
|
|
uint64_t delay_ns = 0;
|
|
|
|
bool copy;
|
|
|
|
|
|
|
|
wait:
|
|
|
|
/* 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-09-27 19:29:13 +02:00
|
|
|
*/
|
2013-08-21 17:03:05 +02:00
|
|
|
block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
|
2012-09-27 19:29:13 +02:00
|
|
|
if (block_job_is_cancelled(&s->common)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Copy if allocated above the base */
|
2013-09-04 19:00:24 +02:00
|
|
|
ret = bdrv_is_allocated_above(top, base, sector_num,
|
|
|
|
COMMIT_BUFFER_SIZE / BDRV_SECTOR_SIZE,
|
|
|
|
&n);
|
2012-09-27 19:29:13 +02:00
|
|
|
copy = (ret == 1);
|
|
|
|
trace_commit_one_iteration(s, sector_num, n, ret);
|
|
|
|
if (copy) {
|
|
|
|
if (s->common.speed) {
|
|
|
|
delay_ns = ratelimit_calculate_delay(&s->limit, n);
|
|
|
|
if (delay_ns > 0) {
|
|
|
|
goto wait;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = commit_populate(top, base, sector_num, n, buf);
|
|
|
|
bytes_written += n * BDRV_SECTOR_SIZE;
|
|
|
|
}
|
|
|
|
if (ret < 0) {
|
2012-09-28 17:22:55 +02:00
|
|
|
if (s->on_error == BLOCKDEV_ON_ERROR_STOP ||
|
|
|
|
s->on_error == BLOCKDEV_ON_ERROR_REPORT||
|
|
|
|
(s->on_error == BLOCKDEV_ON_ERROR_ENOSPC && ret == -ENOSPC)) {
|
2014-10-21 13:03:59 +02:00
|
|
|
goto out;
|
2012-09-27 19:29:13 +02:00
|
|
|
} else {
|
|
|
|
n = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Publish progress */
|
|
|
|
s->common.offset += n * BDRV_SECTOR_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2014-10-21 13:03:59 +02:00
|
|
|
out:
|
2012-09-27 19:29:13 +02:00
|
|
|
qemu_vfree(buf);
|
|
|
|
|
2014-10-21 13:03:59 +02:00
|
|
|
data = g_malloc(sizeof(*data));
|
|
|
|
data->ret = ret;
|
|
|
|
block_job_defer_to_main_loop(&s->common, commit_complete, data);
|
2012-09-27 19:29:13 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp)
|
|
|
|
{
|
|
|
|
CommitBlockJob *s = container_of(job, CommitBlockJob, common);
|
|
|
|
|
|
|
|
if (speed < 0) {
|
2015-03-17 11:54:50 +01:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, "speed");
|
2012-09-27 19:29:13 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
|
|
|
|
}
|
|
|
|
|
2013-10-08 11:29:38 +02:00
|
|
|
static const BlockJobDriver commit_job_driver = {
|
2012-09-27 19:29:13 +02:00
|
|
|
.instance_size = sizeof(CommitBlockJob),
|
2013-10-08 11:29:40 +02:00
|
|
|
.job_type = BLOCK_JOB_TYPE_COMMIT,
|
2012-09-27 19:29:13 +02:00
|
|
|
.set_speed = commit_set_speed,
|
|
|
|
};
|
|
|
|
|
|
|
|
void commit_start(BlockDriverState *bs, BlockDriverState *base,
|
|
|
|
BlockDriverState *top, int64_t speed,
|
2014-10-07 13:59:15 +02:00
|
|
|
BlockdevOnError on_error, BlockCompletionFunc *cb,
|
block: extend block-commit to accept a string for the backing file
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 commit.
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-commit api, the user is able to change
the backing file of the overlay image as part of the block-commit
operation.
This allows the change to be 'safe', in the sense that if the attempt
to write the overlay image metadata fails, then the block-commit
operation returns failure, without disrupting the guest.
If the commit top is the active layer, then specifying the backing
file string will be treated as an error (there is no overlay image
to modify in that case).
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>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-25 21:40:10 +02:00
|
|
|
void *opaque, const char *backing_file_str, Error **errp)
|
2012-09-27 19:29:13 +02:00
|
|
|
{
|
|
|
|
CommitBlockJob *s;
|
|
|
|
BlockReopenQueue *reopen_queue = NULL;
|
|
|
|
int orig_overlay_flags;
|
|
|
|
int orig_base_flags;
|
|
|
|
BlockDriverState *overlay_bs;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
2012-09-28 17:22:55 +02:00
|
|
|
if ((on_error == BLOCKDEV_ON_ERROR_STOP ||
|
|
|
|
on_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
|
2015-10-19 17:53:22 +02:00
|
|
|
(!bs->blk || !blk_iostatus_is_enabled(bs->blk))) {
|
2014-03-22 00:42:26 +01:00
|
|
|
error_setg(errp, "Invalid parameter combination");
|
2012-09-27 19:29:13 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-12-16 07:45:33 +01:00
|
|
|
assert(top != bs);
|
2012-09-27 19:29:13 +02:00
|
|
|
if (top == base) {
|
|
|
|
error_setg(errp, "Invalid files for merge: top and base are the same");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
overlay_bs = bdrv_find_overlay(bs, top);
|
|
|
|
|
|
|
|
if (overlay_bs == NULL) {
|
|
|
|
error_setg(errp, "Could not find overlay image for %s:", top->filename);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
orig_base_flags = bdrv_get_flags(base);
|
|
|
|
orig_overlay_flags = bdrv_get_flags(overlay_bs);
|
|
|
|
|
|
|
|
/* convert base & overlay_bs to r/w, if necessary */
|
|
|
|
if (!(orig_overlay_flags & BDRV_O_RDWR)) {
|
2015-04-10 17:50:50 +02:00
|
|
|
reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs, NULL,
|
2012-09-27 19:29:13 +02:00
|
|
|
orig_overlay_flags | BDRV_O_RDWR);
|
|
|
|
}
|
2015-10-28 14:43:49 +01:00
|
|
|
if (!(orig_base_flags & BDRV_O_RDWR)) {
|
|
|
|
reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,
|
|
|
|
orig_base_flags | BDRV_O_RDWR);
|
|
|
|
}
|
2012-09-27 19:29:13 +02:00
|
|
|
if (reopen_queue) {
|
|
|
|
bdrv_reopen_multiple(reopen_queue, &local_err);
|
|
|
|
if (local_err != NULL) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-10-08 11:29:38 +02:00
|
|
|
s = block_job_create(&commit_job_driver, bs, speed, cb, opaque, errp);
|
2012-09-27 19:29:13 +02:00
|
|
|
if (!s) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->base = base;
|
|
|
|
s->top = top;
|
|
|
|
s->active = bs;
|
|
|
|
|
|
|
|
s->base_flags = orig_base_flags;
|
|
|
|
s->orig_overlay_flags = orig_overlay_flags;
|
|
|
|
|
block: extend block-commit to accept a string for the backing file
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 commit.
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-commit api, the user is able to change
the backing file of the overlay image as part of the block-commit
operation.
This allows the change to be 'safe', in the sense that if the attempt
to write the overlay image metadata fails, then the block-commit
operation returns failure, without disrupting the guest.
If the commit top is the active layer, then specifying the backing
file string will be treated as an error (there is no overlay image
to modify in that case).
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>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2014-06-25 21:40:10 +02:00
|
|
|
s->backing_file_str = g_strdup(backing_file_str);
|
|
|
|
|
2012-09-27 19:29:13 +02:00
|
|
|
s->on_error = on_error;
|
|
|
|
s->common.co = qemu_coroutine_create(commit_run);
|
|
|
|
|
|
|
|
trace_commit_start(bs, base, top, s, s->common.co, opaque);
|
|
|
|
qemu_coroutine_enter(s->common.co, s);
|
|
|
|
}
|