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