spapr: Workaround for broken radix guests
[qemu.git] / block / commit.c
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 "qemu/osdep.h"
16 #include "qemu/cutils.h"
17 #include "trace.h"
18 #include "block/block_int.h"
19 #include "block/blockjob_int.h"
20 #include "qapi/error.h"
21 #include "qapi/qmp/qerror.h"
22 #include "qemu/ratelimit.h"
23 #include "sysemu/block-backend.h"
24
25 enum {
26 /*
27 * Size of data buffer for populating the image file. This should be large
28 * enough to process multiple clusters in a single call, so that populating
29 * contiguous regions of the image is efficient.
30 */
31 COMMIT_BUFFER_SIZE = 512 * 1024, /* in bytes */
32 };
33
34 #define SLICE_TIME 100000000ULL /* ns */
35
36 typedef struct CommitBlockJob {
37 BlockJob common;
38 RateLimit limit;
39 BlockDriverState *active;
40 BlockDriverState *commit_top_bs;
41 BlockBackend *top;
42 BlockBackend *base;
43 BlockdevOnError on_error;
44 int base_flags;
45 int orig_overlay_flags;
46 char *backing_file_str;
47 } CommitBlockJob;
48
49 static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base,
50 int64_t sector_num, int nb_sectors,
51 void *buf)
52 {
53 int ret = 0;
54 QEMUIOVector qiov;
55 struct iovec iov = {
56 .iov_base = buf,
57 .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
58 };
59
60 qemu_iovec_init_external(&qiov, &iov, 1);
61
62 ret = blk_co_preadv(bs, sector_num * BDRV_SECTOR_SIZE,
63 qiov.size, &qiov, 0);
64 if (ret < 0) {
65 return ret;
66 }
67
68 ret = blk_co_pwritev(base, sector_num * BDRV_SECTOR_SIZE,
69 qiov.size, &qiov, 0);
70 if (ret < 0) {
71 return ret;
72 }
73
74 return 0;
75 }
76
77 typedef struct {
78 int ret;
79 } CommitCompleteData;
80
81 static void commit_complete(BlockJob *job, void *opaque)
82 {
83 CommitBlockJob *s = container_of(job, CommitBlockJob, common);
84 CommitCompleteData *data = opaque;
85 BlockDriverState *active = s->active;
86 BlockDriverState *top = blk_bs(s->top);
87 BlockDriverState *base = blk_bs(s->base);
88 BlockDriverState *overlay_bs = bdrv_find_overlay(active, s->commit_top_bs);
89 int ret = data->ret;
90 bool remove_commit_top_bs = false;
91
92 /* Remove base node parent that still uses BLK_PERM_WRITE/RESIZE before
93 * the normal backing chain can be restored. */
94 blk_unref(s->base);
95
96 if (!block_job_is_cancelled(&s->common) && ret == 0) {
97 /* success */
98 ret = bdrv_drop_intermediate(active, s->commit_top_bs, base,
99 s->backing_file_str);
100 } else if (overlay_bs) {
101 /* XXX Can (or should) we somehow keep 'consistent read' blocked even
102 * after the failed/cancelled commit job is gone? If we already wrote
103 * something to base, the intermediate images aren't valid any more. */
104 remove_commit_top_bs = true;
105 }
106
107 /* restore base open flags here if appropriate (e.g., change the base back
108 * to r/o). These reopens do not need to be atomic, since we won't abort
109 * even on failure here */
110 if (s->base_flags != bdrv_get_flags(base)) {
111 bdrv_reopen(base, s->base_flags, NULL);
112 }
113 if (overlay_bs && s->orig_overlay_flags != bdrv_get_flags(overlay_bs)) {
114 bdrv_reopen(overlay_bs, s->orig_overlay_flags, NULL);
115 }
116 g_free(s->backing_file_str);
117 blk_unref(s->top);
118 block_job_completed(&s->common, ret);
119 g_free(data);
120
121 /* If bdrv_drop_intermediate() didn't already do that, remove the commit
122 * filter driver from the backing chain. Do this as the final step so that
123 * the 'consistent read' permission can be granted. */
124 if (remove_commit_top_bs) {
125 bdrv_set_backing_hd(overlay_bs, top, &error_abort);
126 }
127 }
128
129 static void coroutine_fn commit_run(void *opaque)
130 {
131 CommitBlockJob *s = opaque;
132 CommitCompleteData *data;
133 int64_t sector_num, end;
134 uint64_t delay_ns = 0;
135 int ret = 0;
136 int n = 0;
137 void *buf = NULL;
138 int bytes_written = 0;
139 int64_t base_len;
140
141 ret = s->common.len = blk_getlength(s->top);
142
143
144 if (s->common.len < 0) {
145 goto out;
146 }
147
148 ret = base_len = blk_getlength(s->base);
149 if (base_len < 0) {
150 goto out;
151 }
152
153 if (base_len < s->common.len) {
154 ret = blk_truncate(s->base, s->common.len);
155 if (ret) {
156 goto out;
157 }
158 }
159
160 end = s->common.len >> BDRV_SECTOR_BITS;
161 buf = blk_blockalign(s->top, COMMIT_BUFFER_SIZE);
162
163 for (sector_num = 0; sector_num < end; sector_num += n) {
164 bool copy;
165
166 /* Note that even when no rate limit is applied we need to yield
167 * with no pending I/O here so that bdrv_drain_all() returns.
168 */
169 block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns);
170 if (block_job_is_cancelled(&s->common)) {
171 break;
172 }
173 /* Copy if allocated above the base */
174 ret = bdrv_is_allocated_above(blk_bs(s->top), blk_bs(s->base),
175 sector_num,
176 COMMIT_BUFFER_SIZE / BDRV_SECTOR_SIZE,
177 &n);
178 copy = (ret == 1);
179 trace_commit_one_iteration(s, sector_num, n, ret);
180 if (copy) {
181 ret = commit_populate(s->top, s->base, sector_num, n, buf);
182 bytes_written += n * BDRV_SECTOR_SIZE;
183 }
184 if (ret < 0) {
185 BlockErrorAction action =
186 block_job_error_action(&s->common, false, s->on_error, -ret);
187 if (action == BLOCK_ERROR_ACTION_REPORT) {
188 goto out;
189 } else {
190 n = 0;
191 continue;
192 }
193 }
194 /* Publish progress */
195 s->common.offset += n * BDRV_SECTOR_SIZE;
196
197 if (copy && s->common.speed) {
198 delay_ns = ratelimit_calculate_delay(&s->limit, n);
199 }
200 }
201
202 ret = 0;
203
204 out:
205 qemu_vfree(buf);
206
207 data = g_malloc(sizeof(*data));
208 data->ret = ret;
209 block_job_defer_to_main_loop(&s->common, commit_complete, data);
210 }
211
212 static void commit_set_speed(BlockJob *job, int64_t speed, Error **errp)
213 {
214 CommitBlockJob *s = container_of(job, CommitBlockJob, common);
215
216 if (speed < 0) {
217 error_setg(errp, QERR_INVALID_PARAMETER, "speed");
218 return;
219 }
220 ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME);
221 }
222
223 static const BlockJobDriver commit_job_driver = {
224 .instance_size = sizeof(CommitBlockJob),
225 .job_type = BLOCK_JOB_TYPE_COMMIT,
226 .set_speed = commit_set_speed,
227 .start = commit_run,
228 };
229
230 static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs,
231 uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags)
232 {
233 return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags);
234 }
235
236 static int64_t coroutine_fn bdrv_commit_top_get_block_status(
237 BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum,
238 BlockDriverState **file)
239 {
240 *pnum = nb_sectors;
241 *file = bs->backing->bs;
242 return BDRV_BLOCK_RAW | BDRV_BLOCK_OFFSET_VALID | BDRV_BLOCK_DATA |
243 (sector_num << BDRV_SECTOR_BITS);
244 }
245
246 static void bdrv_commit_top_refresh_filename(BlockDriverState *bs, QDict *opts)
247 {
248 bdrv_refresh_filename(bs->backing->bs);
249 pstrcpy(bs->exact_filename, sizeof(bs->exact_filename),
250 bs->backing->bs->filename);
251 }
252
253 static void bdrv_commit_top_close(BlockDriverState *bs)
254 {
255 }
256
257 static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,
258 const BdrvChildRole *role,
259 uint64_t perm, uint64_t shared,
260 uint64_t *nperm, uint64_t *nshared)
261 {
262 *nperm = 0;
263 *nshared = BLK_PERM_ALL;
264 }
265
266 /* Dummy node that provides consistent read to its users without requiring it
267 * from its backing file and that allows writes on the backing file chain. */
268 static BlockDriver bdrv_commit_top = {
269 .format_name = "commit_top",
270 .bdrv_co_preadv = bdrv_commit_top_preadv,
271 .bdrv_co_get_block_status = bdrv_commit_top_get_block_status,
272 .bdrv_refresh_filename = bdrv_commit_top_refresh_filename,
273 .bdrv_close = bdrv_commit_top_close,
274 .bdrv_child_perm = bdrv_commit_top_child_perm,
275 };
276
277 void commit_start(const char *job_id, BlockDriverState *bs,
278 BlockDriverState *base, BlockDriverState *top, int64_t speed,
279 BlockdevOnError on_error, const char *backing_file_str,
280 const char *filter_node_name, Error **errp)
281 {
282 CommitBlockJob *s;
283 BlockReopenQueue *reopen_queue = NULL;
284 int orig_overlay_flags;
285 int orig_base_flags;
286 BlockDriverState *iter;
287 BlockDriverState *overlay_bs;
288 BlockDriverState *commit_top_bs = NULL;
289 Error *local_err = NULL;
290 int ret;
291
292 assert(top != bs);
293 if (top == base) {
294 error_setg(errp, "Invalid files for merge: top and base are the same");
295 return;
296 }
297
298 overlay_bs = bdrv_find_overlay(bs, top);
299
300 if (overlay_bs == NULL) {
301 error_setg(errp, "Could not find overlay image for %s:", top->filename);
302 return;
303 }
304
305 s = block_job_create(job_id, &commit_job_driver, bs, 0, BLK_PERM_ALL,
306 speed, BLOCK_JOB_DEFAULT, NULL, NULL, errp);
307 if (!s) {
308 return;
309 }
310
311 orig_base_flags = bdrv_get_flags(base);
312 orig_overlay_flags = bdrv_get_flags(overlay_bs);
313
314 /* convert base & overlay_bs to r/w, if necessary */
315 if (!(orig_base_flags & BDRV_O_RDWR)) {
316 reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,
317 orig_base_flags | BDRV_O_RDWR);
318 }
319 if (!(orig_overlay_flags & BDRV_O_RDWR)) {
320 reopen_queue = bdrv_reopen_queue(reopen_queue, overlay_bs, NULL,
321 orig_overlay_flags | BDRV_O_RDWR);
322 }
323 if (reopen_queue) {
324 bdrv_reopen_multiple(bdrv_get_aio_context(bs), reopen_queue, &local_err);
325 if (local_err != NULL) {
326 error_propagate(errp, local_err);
327 goto fail;
328 }
329 }
330
331 /* Insert commit_top block node above top, so we can block consistent read
332 * on the backing chain below it */
333 commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, filter_node_name, 0,
334 errp);
335 if (commit_top_bs == NULL) {
336 goto fail;
337 }
338 commit_top_bs->total_sectors = top->total_sectors;
339 bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(top));
340
341 bdrv_set_backing_hd(commit_top_bs, top, &local_err);
342 if (local_err) {
343 bdrv_unref(commit_top_bs);
344 commit_top_bs = NULL;
345 error_propagate(errp, local_err);
346 goto fail;
347 }
348 bdrv_set_backing_hd(overlay_bs, commit_top_bs, &local_err);
349 if (local_err) {
350 bdrv_unref(commit_top_bs);
351 commit_top_bs = NULL;
352 error_propagate(errp, local_err);
353 goto fail;
354 }
355
356 s->commit_top_bs = commit_top_bs;
357 bdrv_unref(commit_top_bs);
358
359 /* Block all nodes between top and base, because they will
360 * disappear from the chain after this operation. */
361 assert(bdrv_chain_contains(top, base));
362 for (iter = top; iter != base; iter = backing_bs(iter)) {
363 /* XXX BLK_PERM_WRITE needs to be allowed so we don't block ourselves
364 * at s->base (if writes are blocked for a node, they are also blocked
365 * for its backing file). The other options would be a second filter
366 * driver above s->base. */
367 ret = block_job_add_bdrv(&s->common, "intermediate node", iter, 0,
368 BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE,
369 errp);
370 if (ret < 0) {
371 goto fail;
372 }
373 }
374
375 ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp);
376 if (ret < 0) {
377 goto fail;
378 }
379
380 /* overlay_bs must be blocked because it needs to be modified to
381 * update the backing image string. */
382 ret = block_job_add_bdrv(&s->common, "overlay of top", overlay_bs,
383 BLK_PERM_GRAPH_MOD, BLK_PERM_ALL, errp);
384 if (ret < 0) {
385 goto fail;
386 }
387
388 s->base = blk_new(BLK_PERM_CONSISTENT_READ
389 | BLK_PERM_WRITE
390 | BLK_PERM_RESIZE,
391 BLK_PERM_CONSISTENT_READ
392 | BLK_PERM_GRAPH_MOD
393 | BLK_PERM_WRITE_UNCHANGED);
394 ret = blk_insert_bs(s->base, base, errp);
395 if (ret < 0) {
396 goto fail;
397 }
398
399 /* Required permissions are already taken with block_job_add_bdrv() */
400 s->top = blk_new(0, BLK_PERM_ALL);
401 ret = blk_insert_bs(s->top, top, errp);
402 if (ret < 0) {
403 goto fail;
404 }
405
406 s->active = bs;
407
408 s->base_flags = orig_base_flags;
409 s->orig_overlay_flags = orig_overlay_flags;
410
411 s->backing_file_str = g_strdup(backing_file_str);
412
413 s->on_error = on_error;
414
415 trace_commit_start(bs, base, top, s);
416 block_job_start(&s->common);
417 return;
418
419 fail:
420 if (s->base) {
421 blk_unref(s->base);
422 }
423 if (s->top) {
424 blk_unref(s->top);
425 }
426 if (commit_top_bs) {
427 bdrv_set_backing_hd(overlay_bs, top, &error_abort);
428 }
429 block_job_unref(&s->common);
430 }
431
432
433 #define COMMIT_BUF_SECTORS 2048
434
435 /* commit COW file into the raw image */
436 int bdrv_commit(BlockDriverState *bs)
437 {
438 BlockBackend *src, *backing;
439 BlockDriverState *backing_file_bs = NULL;
440 BlockDriverState *commit_top_bs = NULL;
441 BlockDriver *drv = bs->drv;
442 int64_t sector, total_sectors, length, backing_length;
443 int n, ro, open_flags;
444 int ret = 0;
445 uint8_t *buf = NULL;
446 Error *local_err = NULL;
447
448 if (!drv)
449 return -ENOMEDIUM;
450
451 if (!bs->backing) {
452 return -ENOTSUP;
453 }
454
455 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) ||
456 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) {
457 return -EBUSY;
458 }
459
460 ro = bs->backing->bs->read_only;
461 open_flags = bs->backing->bs->open_flags;
462
463 if (ro) {
464 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) {
465 return -EACCES;
466 }
467 }
468
469 src = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
470 backing = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
471
472 ret = blk_insert_bs(src, bs, &local_err);
473 if (ret < 0) {
474 error_report_err(local_err);
475 goto ro_cleanup;
476 }
477
478 /* Insert commit_top block node above backing, so we can write to it */
479 backing_file_bs = backing_bs(bs);
480
481 commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, NULL, BDRV_O_RDWR,
482 &local_err);
483 if (commit_top_bs == NULL) {
484 error_report_err(local_err);
485 goto ro_cleanup;
486 }
487 bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(backing_file_bs));
488
489 bdrv_set_backing_hd(commit_top_bs, backing_file_bs, &error_abort);
490 bdrv_set_backing_hd(bs, commit_top_bs, &error_abort);
491
492 ret = blk_insert_bs(backing, backing_file_bs, &local_err);
493 if (ret < 0) {
494 error_report_err(local_err);
495 goto ro_cleanup;
496 }
497
498 length = blk_getlength(src);
499 if (length < 0) {
500 ret = length;
501 goto ro_cleanup;
502 }
503
504 backing_length = blk_getlength(backing);
505 if (backing_length < 0) {
506 ret = backing_length;
507 goto ro_cleanup;
508 }
509
510 /* If our top snapshot is larger than the backing file image,
511 * grow the backing file image if possible. If not possible,
512 * we must return an error */
513 if (length > backing_length) {
514 ret = blk_truncate(backing, length);
515 if (ret < 0) {
516 goto ro_cleanup;
517 }
518 }
519
520 total_sectors = length >> BDRV_SECTOR_BITS;
521
522 /* blk_try_blockalign() for src will choose an alignment that works for
523 * backing as well, so no need to compare the alignment manually. */
524 buf = blk_try_blockalign(src, COMMIT_BUF_SECTORS * BDRV_SECTOR_SIZE);
525 if (buf == NULL) {
526 ret = -ENOMEM;
527 goto ro_cleanup;
528 }
529
530 for (sector = 0; sector < total_sectors; sector += n) {
531 ret = bdrv_is_allocated(bs, sector, COMMIT_BUF_SECTORS, &n);
532 if (ret < 0) {
533 goto ro_cleanup;
534 }
535 if (ret) {
536 ret = blk_pread(src, sector * BDRV_SECTOR_SIZE, buf,
537 n * BDRV_SECTOR_SIZE);
538 if (ret < 0) {
539 goto ro_cleanup;
540 }
541
542 ret = blk_pwrite(backing, sector * BDRV_SECTOR_SIZE, buf,
543 n * BDRV_SECTOR_SIZE, 0);
544 if (ret < 0) {
545 goto ro_cleanup;
546 }
547 }
548 }
549
550 if (drv->bdrv_make_empty) {
551 ret = drv->bdrv_make_empty(bs);
552 if (ret < 0) {
553 goto ro_cleanup;
554 }
555 blk_flush(src);
556 }
557
558 /*
559 * Make sure all data we wrote to the backing device is actually
560 * stable on disk.
561 */
562 blk_flush(backing);
563
564 ret = 0;
565 ro_cleanup:
566 qemu_vfree(buf);
567
568 blk_unref(backing);
569 if (backing_file_bs) {
570 bdrv_set_backing_hd(bs, backing_file_bs, &error_abort);
571 }
572 bdrv_unref(commit_top_bs);
573 blk_unref(src);
574
575 if (ro) {
576 /* ignoring error return here */
577 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL);
578 }
579
580 return ret;
581 }