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_child_perm(BlockDriverState *bs, BdrvChild *c, 243 const BdrvChildRole *role, 244 BlockReopenQueue *reopen_queue, 245 uint64_t perm, uint64_t shared, 246 uint64_t *nperm, uint64_t *nshared) 247 { 248 *nperm = 0; 249 *nshared = BLK_PERM_ALL; 250 } 251 252 /* Dummy node that provides consistent read to its users without requiring it 253 * from its backing file and that allows writes on the backing file chain. */ 254 static BlockDriver bdrv_commit_top = { 255 .format_name = "commit_top", 256 .bdrv_co_preadv = bdrv_commit_top_preadv, 257 .bdrv_co_block_status = bdrv_co_block_status_from_backing, 258 .bdrv_refresh_filename = bdrv_commit_top_refresh_filename, 259 .bdrv_child_perm = bdrv_commit_top_child_perm, 260 }; 261 262 void commit_start(const char *job_id, BlockDriverState *bs, 263 BlockDriverState *base, BlockDriverState *top, int64_t speed, 264 BlockdevOnError on_error, const char *backing_file_str, 265 const char *filter_node_name, Error **errp) 266 { 267 CommitBlockJob *s; 268 int orig_base_flags; 269 BlockDriverState *iter; 270 BlockDriverState *commit_top_bs = NULL; 271 Error *local_err = NULL; 272 int ret; 273 274 assert(top != bs); 275 if (top == base) { 276 error_setg(errp, "Invalid files for merge: top and base are the same"); 277 return; 278 } 279 280 s = block_job_create(job_id, &commit_job_driver, NULL, bs, 0, BLK_PERM_ALL, 281 speed, JOB_DEFAULT, NULL, NULL, errp); 282 if (!s) { 283 return; 284 } 285 286 /* convert base to r/w, if necessary */ 287 orig_base_flags = bdrv_get_flags(base); 288 if (!(orig_base_flags & BDRV_O_RDWR)) { 289 bdrv_reopen(base, orig_base_flags | BDRV_O_RDWR, &local_err); 290 if (local_err != NULL) { 291 error_propagate(errp, local_err); 292 goto fail; 293 } 294 } 295 296 /* Insert commit_top block node above top, so we can block consistent read 297 * on the backing chain below it */ 298 commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, filter_node_name, 0, 299 errp); 300 if (commit_top_bs == NULL) { 301 goto fail; 302 } 303 if (!filter_node_name) { 304 commit_top_bs->implicit = true; 305 } 306 commit_top_bs->total_sectors = top->total_sectors; 307 bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(top)); 308 309 bdrv_set_backing_hd(commit_top_bs, top, &local_err); 310 if (local_err) { 311 bdrv_unref(commit_top_bs); 312 commit_top_bs = NULL; 313 error_propagate(errp, local_err); 314 goto fail; 315 } 316 bdrv_replace_node(top, commit_top_bs, &local_err); 317 if (local_err) { 318 bdrv_unref(commit_top_bs); 319 commit_top_bs = NULL; 320 error_propagate(errp, local_err); 321 goto fail; 322 } 323 324 s->commit_top_bs = commit_top_bs; 325 bdrv_unref(commit_top_bs); 326 327 /* Block all nodes between top and base, because they will 328 * disappear from the chain after this operation. */ 329 assert(bdrv_chain_contains(top, base)); 330 for (iter = top; iter != base; iter = backing_bs(iter)) { 331 /* XXX BLK_PERM_WRITE needs to be allowed so we don't block ourselves 332 * at s->base (if writes are blocked for a node, they are also blocked 333 * for its backing file). The other options would be a second filter 334 * driver above s->base. */ 335 ret = block_job_add_bdrv(&s->common, "intermediate node", iter, 0, 336 BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE, 337 errp); 338 if (ret < 0) { 339 goto fail; 340 } 341 } 342 343 ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp); 344 if (ret < 0) { 345 goto fail; 346 } 347 348 s->base = blk_new(BLK_PERM_CONSISTENT_READ 349 | BLK_PERM_WRITE 350 | BLK_PERM_RESIZE, 351 BLK_PERM_CONSISTENT_READ 352 | BLK_PERM_GRAPH_MOD 353 | BLK_PERM_WRITE_UNCHANGED); 354 ret = blk_insert_bs(s->base, base, errp); 355 if (ret < 0) { 356 goto fail; 357 } 358 359 /* Required permissions are already taken with block_job_add_bdrv() */ 360 s->top = blk_new(0, BLK_PERM_ALL); 361 ret = blk_insert_bs(s->top, top, errp); 362 if (ret < 0) { 363 goto fail; 364 } 365 366 s->base_flags = orig_base_flags; 367 s->backing_file_str = g_strdup(backing_file_str); 368 s->on_error = on_error; 369 370 trace_commit_start(bs, base, top, s); 371 job_start(&s->common.job); 372 return; 373 374 fail: 375 if (s->base) { 376 blk_unref(s->base); 377 } 378 if (s->top) { 379 blk_unref(s->top); 380 } 381 if (commit_top_bs) { 382 bdrv_replace_node(commit_top_bs, top, &error_abort); 383 } 384 job_early_fail(&s->common.job); 385 } 386 387 388 #define COMMIT_BUF_SIZE (2048 * BDRV_SECTOR_SIZE) 389 390 /* commit COW file into the raw image */ 391 int bdrv_commit(BlockDriverState *bs) 392 { 393 BlockBackend *src, *backing; 394 BlockDriverState *backing_file_bs = NULL; 395 BlockDriverState *commit_top_bs = NULL; 396 BlockDriver *drv = bs->drv; 397 int64_t offset, length, backing_length; 398 int ro, open_flags; 399 int64_t n; 400 int ret = 0; 401 uint8_t *buf = NULL; 402 Error *local_err = NULL; 403 404 if (!drv) 405 return -ENOMEDIUM; 406 407 if (!bs->backing) { 408 return -ENOTSUP; 409 } 410 411 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) || 412 bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) { 413 return -EBUSY; 414 } 415 416 ro = bs->backing->bs->read_only; 417 open_flags = bs->backing->bs->open_flags; 418 419 if (ro) { 420 if (bdrv_reopen(bs->backing->bs, open_flags | BDRV_O_RDWR, NULL)) { 421 return -EACCES; 422 } 423 } 424 425 src = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL); 426 backing = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL); 427 428 ret = blk_insert_bs(src, bs, &local_err); 429 if (ret < 0) { 430 error_report_err(local_err); 431 goto ro_cleanup; 432 } 433 434 /* Insert commit_top block node above backing, so we can write to it */ 435 backing_file_bs = backing_bs(bs); 436 437 commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, NULL, BDRV_O_RDWR, 438 &local_err); 439 if (commit_top_bs == NULL) { 440 error_report_err(local_err); 441 goto ro_cleanup; 442 } 443 bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(backing_file_bs)); 444 445 bdrv_set_backing_hd(commit_top_bs, backing_file_bs, &error_abort); 446 bdrv_set_backing_hd(bs, commit_top_bs, &error_abort); 447 448 ret = blk_insert_bs(backing, backing_file_bs, &local_err); 449 if (ret < 0) { 450 error_report_err(local_err); 451 goto ro_cleanup; 452 } 453 454 length = blk_getlength(src); 455 if (length < 0) { 456 ret = length; 457 goto ro_cleanup; 458 } 459 460 backing_length = blk_getlength(backing); 461 if (backing_length < 0) { 462 ret = backing_length; 463 goto ro_cleanup; 464 } 465 466 /* If our top snapshot is larger than the backing file image, 467 * grow the backing file image if possible. If not possible, 468 * we must return an error */ 469 if (length > backing_length) { 470 ret = blk_truncate(backing, length, PREALLOC_MODE_OFF, &local_err); 471 if (ret < 0) { 472 error_report_err(local_err); 473 goto ro_cleanup; 474 } 475 } 476 477 /* blk_try_blockalign() for src will choose an alignment that works for 478 * backing as well, so no need to compare the alignment manually. */ 479 buf = blk_try_blockalign(src, COMMIT_BUF_SIZE); 480 if (buf == NULL) { 481 ret = -ENOMEM; 482 goto ro_cleanup; 483 } 484 485 for (offset = 0; offset < length; offset += n) { 486 ret = bdrv_is_allocated(bs, offset, COMMIT_BUF_SIZE, &n); 487 if (ret < 0) { 488 goto ro_cleanup; 489 } 490 if (ret) { 491 ret = blk_pread(src, offset, buf, n); 492 if (ret < 0) { 493 goto ro_cleanup; 494 } 495 496 ret = blk_pwrite(backing, offset, buf, n, 0); 497 if (ret < 0) { 498 goto ro_cleanup; 499 } 500 } 501 } 502 503 if (drv->bdrv_make_empty) { 504 ret = drv->bdrv_make_empty(bs); 505 if (ret < 0) { 506 goto ro_cleanup; 507 } 508 blk_flush(src); 509 } 510 511 /* 512 * Make sure all data we wrote to the backing device is actually 513 * stable on disk. 514 */ 515 blk_flush(backing); 516 517 ret = 0; 518 ro_cleanup: 519 qemu_vfree(buf); 520 521 blk_unref(backing); 522 if (backing_file_bs) { 523 bdrv_set_backing_hd(bs, backing_file_bs, &error_abort); 524 } 525 bdrv_unref(commit_top_bs); 526 blk_unref(src); 527 528 if (ro) { 529 /* ignoring error return here */ 530 bdrv_reopen(bs->backing->bs, open_flags & ~BDRV_O_RDWR, NULL); 531 } 532 533 return ret; 534 } 535