]> git.proxmox.com Git - mirror_qemu.git/blame - block/commit.c
qerror: Eliminate QERR_DEVICE_NOT_FOUND
[mirror_qemu.git] / block / commit.c
CommitLineData
747ff602
JC
1/*
2 * Live block commit
3 *
4 * Copyright Red Hat, Inc. 2012
5 *
6 * Authors:
7 * Jeff Cody <jcody@redhat.com>
8 * Based on stream.c by Stefan Hajnoczi
9 *
10 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
11 * See the COPYING.LIB file in the top-level directory.
12 *
13 */
14
15#include "trace.h"
737e150e
PB
16#include "block/block_int.h"
17#include "block/blockjob.h"
747ff602
JC
18#include "qemu/ratelimit.h"
19
20enum {
21 /*
22 * Size of data buffer for populating the image file. This should be large
23 * enough to process multiple clusters in a single call, so that populating
24 * contiguous regions of the image is efficient.
25 */
26 COMMIT_BUFFER_SIZE = 512 * 1024, /* in bytes */
27};
28
29#define SLICE_TIME 100000000ULL /* ns */
30
31typedef struct CommitBlockJob {
32 BlockJob common;
33 RateLimit limit;
34 BlockDriverState *active;
35 BlockDriverState *top;
36 BlockDriverState *base;
92aa5c6d 37 BlockdevOnError on_error;
747ff602
JC
38 int base_flags;
39 int orig_overlay_flags;
54e26900 40 char *backing_file_str;
747ff602
JC
41} CommitBlockJob;
42
43static int coroutine_fn commit_populate(BlockDriverState *bs,
44 BlockDriverState *base,
45 int64_t sector_num, int nb_sectors,
46 void *buf)
47{
48 int ret = 0;
49
50 ret = bdrv_read(bs, sector_num, buf, nb_sectors);
51 if (ret) {
52 return ret;
53 }
54
55 ret = bdrv_write(base, sector_num, buf, nb_sectors);
56 if (ret) {
57 return ret;
58 }
59
60 return 0;
61}
62
9e85cd5c
SH
63typedef struct {
64 int ret;
65} CommitCompleteData;
66
67static void commit_complete(BlockJob *job, void *opaque)
747ff602 68{
9e85cd5c
SH
69 CommitBlockJob *s = container_of(job, CommitBlockJob, common);
70 CommitCompleteData *data = opaque;
747ff602
JC
71 BlockDriverState *active = s->active;
72 BlockDriverState *top = s->top;
73 BlockDriverState *base = s->base;
6d759117 74 BlockDriverState *overlay_bs;
9e85cd5c
SH
75 int ret = data->ret;
76
77 if (!block_job_is_cancelled(&s->common) && ret == 0) {
78 /* success */
79 ret = bdrv_drop_intermediate(active, top, base, s->backing_file_str);
80 }
81
82 /* restore base open flags here if appropriate (e.g., change the base back
83 * to r/o). These reopens do not need to be atomic, since we won't abort
84 * even on failure here */
85 if (s->base_flags != bdrv_get_flags(base)) {
86 bdrv_reopen(base, s->base_flags, NULL);
87 }
88 overlay_bs = bdrv_find_overlay(active, top);
89 if (overlay_bs && s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {
90 bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);
91 }
92 g_free(s->backing_file_str);
93 block_job_completed(&s->common, ret);
94 g_free(data);
95}
96
97static void coroutine_fn commit_run(void *opaque)
98{
99 CommitBlockJob *s = opaque;
100 CommitCompleteData *data;
101 BlockDriverState *top = s->top;
102 BlockDriverState *base = s->base;
747ff602
JC
103 int64_t sector_num, end;
104 int ret = 0;
105 int n = 0;
9e85cd5c 106 void *buf = NULL;
747ff602
JC
107 int bytes_written = 0;
108 int64_t base_len;
109
110 ret = s->common.len = bdrv_getlength(top);
111
112
113 if (s->common.len < 0) {
9e85cd5c 114 goto out;
747ff602
JC
115 }
116
117 ret = base_len = bdrv_getlength(base);
118 if (base_len < 0) {
9e85cd5c 119 goto out;
747ff602
JC
120 }
121
122 if (base_len < s->common.len) {
123 ret = bdrv_truncate(base, s->common.len);
124 if (ret) {
9e85cd5c 125 goto out;
747ff602
JC
126 }
127 }
128
747ff602
JC
129 end = s->common.len >> BDRV_SECTOR_BITS;
130 buf = qemu_blockalign(top, COMMIT_BUFFER_SIZE);
131
132 for (sector_num = 0; sector_num < end; sector_num += n) {
133 uint64_t delay_ns = 0;
134 bool copy;
135
136wait:
137 /* Note that even when no rate limit is applied we need to yield
c57b6656 138 * with no pending I/O here so that bdrv_drain_all() returns.
747ff602 139 */
7483d1e5 140 block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
747ff602
JC
141 if (block_job_is_cancelled(&s->common)) {
142 break;
143 }
144 /* Copy if allocated above the base */
4f578637
PB
145 ret = bdrv_is_allocated_above(top, base, sector_num,
146 COMMIT_BUFFER_SIZE / BDRV_SECTOR_SIZE,
147 &n);
747ff602
JC
148 copy = (ret == 1);
149 trace_commit_one_iteration(s, sector_num, n, ret);
150 if (copy) {
151 if (s->common.speed) {
152 delay_ns = ratelimit_calculate_delay(&s->limit, n);
153 if (delay_ns > 0) {
154 goto wait;
155 }
156 }
157 ret = commit_populate(top, base, sector_num, n, buf);
158 bytes_written += n * BDRV_SECTOR_SIZE;
159 }
160 if (ret < 0) {
92aa5c6d
PB
161 if (s->on_error == BLOCKDEV_ON_ERROR_STOP ||
162 s->on_error == BLOCKDEV_ON_ERROR_REPORT||
163 (s->on_error == BLOCKDEV_ON_ERROR_ENOSPC && ret == -ENOSPC)) {
9e85cd5c 164 goto out;
747ff602
JC
165 } else {
166 n = 0;
167 continue;
168 }
169 }
170 /* Publish progress */
171 s->common.offset += n * BDRV_SECTOR_SIZE;
172 }
173
174 ret = 0;
175
9e85cd5c 176out:
747ff602
JC
177 qemu_vfree(buf);
178
9e85cd5c
SH
179 data = g_malloc(sizeof(*data));
180 data->ret = ret;
181 block_job_defer_to_main_loop(&s->common, commit_complete, data);
747ff602
JC
182}
183
184static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp)
185{
186 CommitBlockJob *s = container_of(job, CommitBlockJob, common);
187
188 if (speed < 0) {
189 error_set(errp, QERR_INVALID_PARAMETER, "speed");
190 return;
191 }
192 ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
193}
194
3fc4b10a 195static const BlockJobDriver commit_job_driver = {
747ff602 196 .instance_size = sizeof(CommitBlockJob),
79e14bf7 197 .job_type = BLOCK_JOB_TYPE_COMMIT,
747ff602
JC
198 .set_speed = commit_set_speed,
199};
200
201void commit_start(BlockDriverState *bs, BlockDriverState *base,
202 BlockDriverState *top, int64_t speed,
097310b5 203 BlockdevOnError on_error, BlockCompletionFunc *cb,
54e26900 204 void *opaque, const char *backing_file_str, Error **errp)
747ff602
JC
205{
206 CommitBlockJob *s;
207 BlockReopenQueue *reopen_queue = NULL;
208 int orig_overlay_flags;
209 int orig_base_flags;
210 BlockDriverState *overlay_bs;
211 Error *local_err = NULL;
212
92aa5c6d
PB
213 if ((on_error == BLOCKDEV_ON_ERROR_STOP ||
214 on_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
747ff602 215 !bdrv_iostatus_is_enabled(bs)) {
f231b88d 216 error_setg(errp, "Invalid parameter combination");
747ff602
JC
217 return;
218 }
219
18da7f94 220 assert(top != bs);
747ff602
JC
221 if (top == base) {
222 error_setg(errp, "Invalid files for merge: top and base are the same");
223 return;
224 }
225
747ff602
JC
226 overlay_bs = bdrv_find_overlay(bs, top);
227
228 if (overlay_bs == NULL) {
229 error_setg(errp, "Could not find overlay image for %s:", top->filename);
230 return;
231 }
232
233 orig_base_flags = bdrv_get_flags(base);
234 orig_overlay_flags = bdrv_get_flags(overlay_bs);
235
236 /* convert base & overlay_bs to r/w, if necessary */
237 if (!(orig_base_flags & BDRV_O_RDWR)) {
238 reopen_queue = bdrv_reopen_queue(reopen_queue, base,
239 orig_base_flags | BDRV_O_RDWR);
240 }
241 if (!(orig_overlay_flags & BDRV_O_RDWR)) {
242 reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs,
243 orig_overlay_flags | BDRV_O_RDWR);
244 }
245 if (reopen_queue) {
246 bdrv_reopen_multiple(reopen_queue, &local_err);
247 if (local_err != NULL) {
248 error_propagate(errp, local_err);
249 return;
250 }
251 }
252
253
3fc4b10a 254 s = block_job_create(&commit_job_driver, bs, speed, cb, opaque, errp);
747ff602
JC
255 if (!s) {
256 return;
257 }
258
259 s->base = base;
260 s->top = top;
261 s->active = bs;
262
263 s->base_flags = orig_base_flags;
264 s->orig_overlay_flags = orig_overlay_flags;
265
54e26900
JC
266 s->backing_file_str = g_strdup(backing_file_str);
267
747ff602
JC
268 s->on_error = on_error;
269 s->common.co = qemu_coroutine_create(commit_run);
270
271 trace_commit_start(bs, base, top, s, s->common.co, opaque);
272 qemu_coroutine_enter(s->common.co, s);
273}