Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 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 | |
Peter Maydell | 80c71a2 | 2016-01-18 18:01:42 +0000 | [diff] [blame] | 15 | #include "qemu/osdep.h" |
Kevin Wolf | dcbf37c | 2017-03-09 11:49:16 +0100 | [diff] [blame] | 16 | #include "qemu/cutils.h" |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 17 | #include "trace.h" |
Paolo Bonzini | 737e150 | 2012-12-17 18:19:44 +0100 | [diff] [blame] | 18 | #include "block/block_int.h" |
John Snow | c87621e | 2016-10-27 12:07:00 -0400 | [diff] [blame] | 19 | #include "block/blockjob_int.h" |
Markus Armbruster | da34e65 | 2016-03-14 09:01:28 +0100 | [diff] [blame] | 20 | #include "qapi/error.h" |
Markus Armbruster | cc7a8ea | 2015-03-17 17:22:46 +0100 | [diff] [blame] | 21 | #include "qapi/qmp/qerror.h" |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 22 | #include "qemu/ratelimit.h" |
Max Reitz | 373340b | 2015-10-19 17:53:22 +0200 | [diff] [blame] | 23 | #include "sysemu/block-backend.h" |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 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 | |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 34 | typedef struct CommitBlockJob { |
| 35 | BlockJob common; |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 36 | BlockDriverState *commit_top_bs; |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 37 | BlockBackend *top; |
| 38 | BlockBackend *base; |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 39 | BlockDriverState *base_bs; |
Paolo Bonzini | 92aa5c6 | 2012-09-28 17:22:55 +0200 | [diff] [blame] | 40 | BlockdevOnError on_error; |
Alberto Garcia | e70cdc5 | 2018-11-12 16:00:35 +0200 | [diff] [blame] | 41 | bool base_read_only; |
Jeff Cody | 54e2690 | 2014-06-25 15:40:10 -0400 | [diff] [blame] | 42 | char *backing_file_str; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 43 | } CommitBlockJob; |
| 44 | |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 45 | static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base, |
Eric Blake | d8a9858 | 2017-07-07 07:44:44 -0500 | [diff] [blame] | 46 | int64_t offset, uint64_t bytes, |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 47 | void *buf) |
| 48 | { |
| 49 | int ret = 0; |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 50 | QEMUIOVector qiov; |
| 51 | struct iovec iov = { |
| 52 | .iov_base = buf, |
Eric Blake | d8a9858 | 2017-07-07 07:44:44 -0500 | [diff] [blame] | 53 | .iov_len = bytes, |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 54 | }; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 55 | |
Eric Blake | d8a9858 | 2017-07-07 07:44:44 -0500 | [diff] [blame] | 56 | assert(bytes < SIZE_MAX); |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 57 | qemu_iovec_init_external(&qiov, &iov, 1); |
| 58 | |
Eric Blake | d8a9858 | 2017-07-07 07:44:44 -0500 | [diff] [blame] | 59 | ret = blk_co_preadv(bs, offset, qiov.size, &qiov, 0); |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 60 | if (ret < 0) { |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 61 | return ret; |
| 62 | } |
| 63 | |
Eric Blake | d8a9858 | 2017-07-07 07:44:44 -0500 | [diff] [blame] | 64 | ret = blk_co_pwritev(base, offset, qiov.size, &qiov, 0); |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 65 | if (ret < 0) { |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 66 | return ret; |
| 67 | } |
| 68 | |
| 69 | return 0; |
| 70 | } |
| 71 | |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 72 | static int commit_prepare(Job *job) |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 73 | { |
Kevin Wolf | 1908a55 | 2018-04-17 16:41:17 +0200 | [diff] [blame] | 74 | CommitBlockJob *s = container_of(job, CommitBlockJob, common.job); |
Kevin Wolf | 19ebd13 | 2017-06-02 23:04:55 +0200 | [diff] [blame] | 75 | |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 76 | /* Remove base node parent that still uses BLK_PERM_WRITE/RESIZE before |
| 77 | * the normal backing chain can be restored. */ |
| 78 | blk_unref(s->base); |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 79 | s->base = NULL; |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 80 | |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 81 | /* FIXME: bdrv_drop_intermediate treats total failures and partial failures |
| 82 | * identically. Further work is needed to disambiguate these cases. */ |
| 83 | return bdrv_drop_intermediate(s->commit_top_bs, s->base_bs, |
| 84 | s->backing_file_str); |
| 85 | } |
| 86 | |
| 87 | static void commit_abort(Job *job) |
| 88 | { |
| 89 | CommitBlockJob *s = container_of(job, CommitBlockJob, common.job); |
| 90 | BlockDriverState *top_bs = blk_bs(s->top); |
| 91 | |
| 92 | /* Make sure commit_top_bs and top stay around until bdrv_replace_node() */ |
| 93 | bdrv_ref(top_bs); |
| 94 | bdrv_ref(s->commit_top_bs); |
| 95 | |
| 96 | if (s->base) { |
| 97 | blk_unref(s->base); |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 98 | } |
| 99 | |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 100 | /* free the blockers on the intermediate nodes so that bdrv_replace_nodes |
| 101 | * can succeed */ |
| 102 | block_job_remove_all_bdrv(&s->common); |
| 103 | |
| 104 | /* If bdrv_drop_intermediate() failed (or was not invoked), remove the |
| 105 | * commit filter driver from the backing chain now. Do this as the final |
| 106 | * step so that the 'consistent read' permission can be granted. |
| 107 | * |
| 108 | * XXX Can (or should) we somehow keep 'consistent read' blocked even |
| 109 | * after the failed/cancelled commit job is gone? If we already wrote |
| 110 | * something to base, the intermediate images aren't valid any more. */ |
| 111 | bdrv_child_try_set_perm(s->commit_top_bs->backing, 0, BLK_PERM_ALL, |
| 112 | &error_abort); |
| 113 | bdrv_replace_node(s->commit_top_bs, backing_bs(s->commit_top_bs), |
| 114 | &error_abort); |
| 115 | |
| 116 | bdrv_unref(s->commit_top_bs); |
| 117 | bdrv_unref(top_bs); |
| 118 | } |
| 119 | |
| 120 | static void commit_clean(Job *job) |
| 121 | { |
| 122 | CommitBlockJob *s = container_of(job, CommitBlockJob, common.job); |
| 123 | |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 124 | /* restore base open flags here if appropriate (e.g., change the base back |
| 125 | * to r/o). These reopens do not need to be atomic, since we won't abort |
| 126 | * even on failure here */ |
Alberto Garcia | e70cdc5 | 2018-11-12 16:00:35 +0200 | [diff] [blame] | 127 | if (s->base_read_only) { |
| 128 | bdrv_reopen_set_read_only(s->base_bs, true, NULL); |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 129 | } |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 130 | |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 131 | g_free(s->backing_file_str); |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 132 | blk_unref(s->top); |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 133 | } |
| 134 | |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 135 | static int coroutine_fn commit_run(Job *job, Error **errp) |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 136 | { |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 137 | CommitBlockJob *s = container_of(job, CommitBlockJob, common.job); |
Eric Blake | 317a667 | 2017-07-07 07:44:45 -0500 | [diff] [blame] | 138 | int64_t offset; |
Sascha Silbe | f14a39c | 2016-06-28 17:28:41 +0200 | [diff] [blame] | 139 | uint64_t delay_ns = 0; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 140 | int ret = 0; |
Eric Blake | 51b0a48 | 2017-07-07 07:44:59 -0500 | [diff] [blame] | 141 | int64_t n = 0; /* bytes */ |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 142 | void *buf = NULL; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 143 | int bytes_written = 0; |
Kevin Wolf | 05df8a6 | 2018-01-18 18:08:22 +0100 | [diff] [blame] | 144 | int64_t len, base_len; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 145 | |
Kevin Wolf | 05df8a6 | 2018-01-18 18:08:22 +0100 | [diff] [blame] | 146 | ret = len = blk_getlength(s->top); |
| 147 | if (len < 0) { |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 148 | goto out; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 149 | } |
Kevin Wolf | 30a5c88 | 2018-05-04 12:17:20 +0200 | [diff] [blame] | 150 | job_progress_set_remaining(&s->common.job, len); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 151 | |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 152 | ret = base_len = blk_getlength(s->base); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 153 | if (base_len < 0) { |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 154 | goto out; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 155 | } |
| 156 | |
Kevin Wolf | 05df8a6 | 2018-01-18 18:08:22 +0100 | [diff] [blame] | 157 | if (base_len < len) { |
| 158 | ret = blk_truncate(s->base, len, PREALLOC_MODE_OFF, NULL); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 159 | if (ret) { |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 160 | goto out; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 161 | } |
| 162 | } |
| 163 | |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 164 | buf = blk_blockalign(s->top, COMMIT_BUFFER_SIZE); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 165 | |
Kevin Wolf | 05df8a6 | 2018-01-18 18:08:22 +0100 | [diff] [blame] | 166 | for (offset = 0; offset < len; offset += n) { |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 167 | bool copy; |
| 168 | |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 169 | /* Note that even when no rate limit is applied we need to yield |
Kevin Wolf | c57b665 | 2012-11-13 16:35:13 +0100 | [diff] [blame] | 170 | * with no pending I/O here so that bdrv_drain_all() returns. |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 171 | */ |
Kevin Wolf | 5d43e86 | 2018-04-18 16:32:20 +0200 | [diff] [blame] | 172 | job_sleep_ns(&s->common.job, delay_ns); |
Kevin Wolf | daa7f2f | 2018-04-17 12:56:07 +0200 | [diff] [blame] | 173 | if (job_is_cancelled(&s->common.job)) { |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 174 | break; |
| 175 | } |
| 176 | /* Copy if allocated above the base */ |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 177 | ret = bdrv_is_allocated_above(blk_bs(s->top), blk_bs(s->base), |
Eric Blake | 51b0a48 | 2017-07-07 07:44:59 -0500 | [diff] [blame] | 178 | offset, COMMIT_BUFFER_SIZE, &n); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 179 | copy = (ret == 1); |
Eric Blake | 51b0a48 | 2017-07-07 07:44:59 -0500 | [diff] [blame] | 180 | trace_commit_one_iteration(s, offset, n, ret); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 181 | if (copy) { |
Eric Blake | 51b0a48 | 2017-07-07 07:44:59 -0500 | [diff] [blame] | 182 | ret = commit_populate(s->top, s->base, offset, n, buf); |
| 183 | bytes_written += n; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 184 | } |
| 185 | if (ret < 0) { |
Kevin Wolf | 1e8fb7f | 2016-06-29 17:38:57 +0200 | [diff] [blame] | 186 | BlockErrorAction action = |
| 187 | block_job_error_action(&s->common, false, s->on_error, -ret); |
| 188 | if (action == BLOCK_ERROR_ACTION_REPORT) { |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 189 | goto out; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 190 | } else { |
| 191 | n = 0; |
| 192 | continue; |
| 193 | } |
| 194 | } |
| 195 | /* Publish progress */ |
Kevin Wolf | 30a5c88 | 2018-05-04 12:17:20 +0200 | [diff] [blame] | 196 | job_progress_update(&s->common.job, n); |
Sascha Silbe | f14a39c | 2016-06-28 17:28:41 +0200 | [diff] [blame] | 197 | |
Kevin Wolf | dee81d5 | 2018-01-18 21:19:38 +0100 | [diff] [blame] | 198 | if (copy) { |
| 199 | delay_ns = block_job_ratelimit_get_delay(&s->common, n); |
Kevin Wolf | 2fe4bba | 2018-01-18 21:23:52 +0100 | [diff] [blame] | 200 | } else { |
| 201 | delay_ns = 0; |
Sascha Silbe | f14a39c | 2016-06-28 17:28:41 +0200 | [diff] [blame] | 202 | } |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | ret = 0; |
| 206 | |
Stefan Hajnoczi | 9e85cd5 | 2014-10-21 12:03:59 +0100 | [diff] [blame] | 207 | out: |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 208 | qemu_vfree(buf); |
| 209 | |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 210 | return ret; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 211 | } |
| 212 | |
Fam Zheng | 3fc4b10 | 2013-10-08 17:29:38 +0800 | [diff] [blame] | 213 | static const BlockJobDriver commit_job_driver = { |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 214 | .job_driver = { |
| 215 | .instance_size = sizeof(CommitBlockJob), |
Kevin Wolf | 252291e | 2018-04-12 17:57:08 +0200 | [diff] [blame] | 216 | .job_type = JOB_TYPE_COMMIT, |
Kevin Wolf | 80fa2c7 | 2018-04-13 18:50:05 +0200 | [diff] [blame] | 217 | .free = block_job_free, |
Kevin Wolf | b15de82 | 2018-04-18 17:10:26 +0200 | [diff] [blame] | 218 | .user_resume = block_job_user_resume, |
Kevin Wolf | b69f777 | 2018-04-20 17:00:29 +0200 | [diff] [blame] | 219 | .drain = block_job_drain, |
John Snow | f67432a | 2018-08-29 21:57:26 -0400 | [diff] [blame] | 220 | .run = commit_run, |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 221 | .prepare = commit_prepare, |
| 222 | .abort = commit_abort, |
| 223 | .clean = commit_clean |
Kevin Wolf | 33e9e9b | 2018-04-12 17:29:59 +0200 | [diff] [blame] | 224 | }, |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 225 | }; |
| 226 | |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 227 | static int coroutine_fn bdrv_commit_top_preadv(BlockDriverState *bs, |
| 228 | uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags) |
| 229 | { |
| 230 | return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags); |
| 231 | } |
| 232 | |
Kevin Wolf | dcbf37c | 2017-03-09 11:49:16 +0100 | [diff] [blame] | 233 | static void bdrv_commit_top_refresh_filename(BlockDriverState *bs, QDict *opts) |
| 234 | { |
| 235 | bdrv_refresh_filename(bs->backing->bs); |
| 236 | pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), |
| 237 | bs->backing->bs->filename); |
| 238 | } |
Kevin Wolf | 9196565 | 2017-03-08 15:07:12 +0100 | [diff] [blame] | 239 | |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 240 | static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c, |
| 241 | const BdrvChildRole *role, |
Kevin Wolf | e0995dc | 2017-09-14 12:47:11 +0200 | [diff] [blame] | 242 | BlockReopenQueue *reopen_queue, |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 243 | uint64_t perm, uint64_t shared, |
| 244 | uint64_t *nperm, uint64_t *nshared) |
| 245 | { |
| 246 | *nperm = 0; |
| 247 | *nshared = BLK_PERM_ALL; |
| 248 | } |
| 249 | |
| 250 | /* Dummy node that provides consistent read to its users without requiring it |
| 251 | * from its backing file and that allows writes on the backing file chain. */ |
| 252 | static BlockDriver bdrv_commit_top = { |
Kevin Wolf | 9196565 | 2017-03-08 15:07:12 +0100 | [diff] [blame] | 253 | .format_name = "commit_top", |
| 254 | .bdrv_co_preadv = bdrv_commit_top_preadv, |
Eric Blake | 3e4d0e7 | 2018-02-13 14:26:43 -0600 | [diff] [blame] | 255 | .bdrv_co_block_status = bdrv_co_block_status_from_backing, |
Kevin Wolf | dcbf37c | 2017-03-09 11:49:16 +0100 | [diff] [blame] | 256 | .bdrv_refresh_filename = bdrv_commit_top_refresh_filename, |
Kevin Wolf | 9196565 | 2017-03-08 15:07:12 +0100 | [diff] [blame] | 257 | .bdrv_child_perm = bdrv_commit_top_child_perm, |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 258 | }; |
| 259 | |
Alberto Garcia | fd62c60 | 2016-07-05 17:29:00 +0300 | [diff] [blame] | 260 | void commit_start(const char *job_id, BlockDriverState *bs, |
John Snow | 5360782 | 2018-09-06 09:02:10 -0400 | [diff] [blame] | 261 | BlockDriverState *base, BlockDriverState *top, |
| 262 | int creation_flags, int64_t speed, |
John Snow | 8254b6d | 2016-10-27 12:06:58 -0400 | [diff] [blame] | 263 | BlockdevOnError on_error, const char *backing_file_str, |
Kevin Wolf | 0db832f | 2017-02-20 18:10:05 +0100 | [diff] [blame] | 264 | const char *filter_node_name, Error **errp) |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 265 | { |
| 266 | CommitBlockJob *s; |
Alberto Garcia | 3e4c512 | 2016-10-28 10:08:08 +0300 | [diff] [blame] | 267 | BlockDriverState *iter; |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 268 | BlockDriverState *commit_top_bs = NULL; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 269 | Error *local_err = NULL; |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 270 | int ret; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 271 | |
Fam Zheng | 18da7f9 | 2013-12-16 14:45:33 +0800 | [diff] [blame] | 272 | assert(top != bs); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 273 | if (top == base) { |
| 274 | error_setg(errp, "Invalid files for merge: top and base are the same"); |
| 275 | return; |
| 276 | } |
| 277 | |
John Snow | 75859b9 | 2018-03-10 03:27:27 -0500 | [diff] [blame] | 278 | s = block_job_create(job_id, &commit_job_driver, NULL, bs, 0, BLK_PERM_ALL, |
John Snow | 5360782 | 2018-09-06 09:02:10 -0400 | [diff] [blame] | 279 | speed, creation_flags, NULL, NULL, errp); |
Alberto Garcia | 834fe28 | 2016-05-27 12:53:39 +0200 | [diff] [blame] | 280 | if (!s) { |
| 281 | return; |
| 282 | } |
| 283 | |
Kevin Wolf | bde7071 | 2017-06-27 20:36:18 +0200 | [diff] [blame] | 284 | /* convert base to r/w, if necessary */ |
Alberto Garcia | e70cdc5 | 2018-11-12 16:00:35 +0200 | [diff] [blame] | 285 | s->base_read_only = bdrv_is_read_only(base); |
| 286 | if (s->base_read_only) { |
| 287 | if (bdrv_reopen_set_read_only(base, false, errp) != 0) { |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 288 | goto fail; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 289 | } |
| 290 | } |
| 291 | |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 292 | /* Insert commit_top block node above top, so we can block consistent read |
| 293 | * on the backing chain below it */ |
Kevin Wolf | 0db832f | 2017-02-20 18:10:05 +0100 | [diff] [blame] | 294 | commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, filter_node_name, 0, |
| 295 | errp); |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 296 | if (commit_top_bs == NULL) { |
| 297 | goto fail; |
| 298 | } |
Kevin Wolf | d3c8c67 | 2017-07-18 17:24:05 +0200 | [diff] [blame] | 299 | if (!filter_node_name) { |
| 300 | commit_top_bs->implicit = true; |
| 301 | } |
Kevin Wolf | 0d0676a | 2017-04-06 19:07:14 +0200 | [diff] [blame] | 302 | commit_top_bs->total_sectors = top->total_sectors; |
Kevin Wolf | 02be4ae | 2017-04-06 19:05:07 +0200 | [diff] [blame] | 303 | bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(top)); |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 304 | |
Fam Zheng | b69f00d | 2017-03-07 19:07:22 +0800 | [diff] [blame] | 305 | bdrv_set_backing_hd(commit_top_bs, top, &local_err); |
| 306 | if (local_err) { |
| 307 | bdrv_unref(commit_top_bs); |
| 308 | commit_top_bs = NULL; |
| 309 | error_propagate(errp, local_err); |
| 310 | goto fail; |
| 311 | } |
Kevin Wolf | 61f09ce | 2017-09-19 16:22:54 +0200 | [diff] [blame] | 312 | bdrv_replace_node(top, commit_top_bs, &local_err); |
Fam Zheng | b69f00d | 2017-03-07 19:07:22 +0800 | [diff] [blame] | 313 | if (local_err) { |
| 314 | bdrv_unref(commit_top_bs); |
| 315 | commit_top_bs = NULL; |
| 316 | error_propagate(errp, local_err); |
| 317 | goto fail; |
| 318 | } |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 319 | |
| 320 | s->commit_top_bs = commit_top_bs; |
| 321 | bdrv_unref(commit_top_bs); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 322 | |
Alberto Garcia | 3e4c512 | 2016-10-28 10:08:08 +0300 | [diff] [blame] | 323 | /* Block all nodes between top and base, because they will |
| 324 | * disappear from the chain after this operation. */ |
| 325 | assert(bdrv_chain_contains(top, base)); |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 326 | for (iter = top; iter != base; iter = backing_bs(iter)) { |
| 327 | /* XXX BLK_PERM_WRITE needs to be allowed so we don't block ourselves |
| 328 | * at s->base (if writes are blocked for a node, they are also blocked |
| 329 | * for its backing file). The other options would be a second filter |
| 330 | * driver above s->base. */ |
| 331 | ret = block_job_add_bdrv(&s->common, "intermediate node", iter, 0, |
| 332 | BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE, |
| 333 | errp); |
| 334 | if (ret < 0) { |
| 335 | goto fail; |
| 336 | } |
Alberto Garcia | 3e4c512 | 2016-10-28 10:08:08 +0300 | [diff] [blame] | 337 | } |
| 338 | |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 339 | ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp); |
| 340 | if (ret < 0) { |
| 341 | goto fail; |
| 342 | } |
| 343 | |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 344 | s->base = blk_new(BLK_PERM_CONSISTENT_READ |
| 345 | | BLK_PERM_WRITE |
| 346 | | BLK_PERM_RESIZE, |
| 347 | BLK_PERM_CONSISTENT_READ |
| 348 | | BLK_PERM_GRAPH_MOD |
| 349 | | BLK_PERM_WRITE_UNCHANGED); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 350 | ret = blk_insert_bs(s->base, base, errp); |
| 351 | if (ret < 0) { |
| 352 | goto fail; |
| 353 | } |
John Snow | 22dffcb | 2018-09-06 09:02:13 -0400 | [diff] [blame] | 354 | s->base_bs = base; |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 355 | |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 356 | /* Required permissions are already taken with block_job_add_bdrv() */ |
Kevin Wolf | 6d0eb64 | 2017-01-20 17:07:26 +0100 | [diff] [blame] | 357 | s->top = blk_new(0, BLK_PERM_ALL); |
Kevin Wolf | b247767 | 2017-03-03 16:54:21 +0100 | [diff] [blame] | 358 | ret = blk_insert_bs(s->top, top, errp); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 359 | if (ret < 0) { |
| 360 | goto fail; |
| 361 | } |
Kevin Wolf | 4653456 | 2016-04-14 13:09:53 +0200 | [diff] [blame] | 362 | |
Jeff Cody | 54e2690 | 2014-06-25 15:40:10 -0400 | [diff] [blame] | 363 | s->backing_file_str = g_strdup(backing_file_str); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 364 | s->on_error = on_error; |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 365 | |
John Snow | 5ccac6f | 2016-11-08 01:50:37 -0500 | [diff] [blame] | 366 | trace_commit_start(bs, base, top, s); |
Kevin Wolf | da01ff7 | 2018-04-13 17:31:02 +0200 | [diff] [blame] | 367 | job_start(&s->common.job); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 368 | return; |
| 369 | |
| 370 | fail: |
| 371 | if (s->base) { |
| 372 | blk_unref(s->base); |
| 373 | } |
| 374 | if (s->top) { |
| 375 | blk_unref(s->top); |
| 376 | } |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 377 | if (commit_top_bs) { |
Kevin Wolf | bde7071 | 2017-06-27 20:36:18 +0200 | [diff] [blame] | 378 | bdrv_replace_node(commit_top_bs, top, &error_abort); |
Kevin Wolf | 8dfba27 | 2017-01-16 16:22:34 +0100 | [diff] [blame] | 379 | } |
Kevin Wolf | 4ad3518 | 2018-04-19 17:30:16 +0200 | [diff] [blame] | 380 | job_early_fail(&s->common.job); |
Jeff Cody | 747ff60 | 2012-09-27 13:29:13 -0400 | [diff] [blame] | 381 | } |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 382 | |
| 383 | |
Eric Blake | d6a644b | 2017-07-07 07:44:57 -0500 | [diff] [blame] | 384 | #define COMMIT_BUF_SIZE (2048 * BDRV_SECTOR_SIZE) |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 385 | |
| 386 | /* commit COW file into the raw image */ |
| 387 | int bdrv_commit(BlockDriverState *bs) |
| 388 | { |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 389 | BlockBackend *src, *backing; |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 390 | BlockDriverState *backing_file_bs = NULL; |
| 391 | BlockDriverState *commit_top_bs = NULL; |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 392 | BlockDriver *drv = bs->drv; |
Eric Blake | d6a644b | 2017-07-07 07:44:57 -0500 | [diff] [blame] | 393 | int64_t offset, length, backing_length; |
Alberto Garcia | c742a36 | 2018-11-12 16:00:36 +0200 | [diff] [blame] | 394 | int ro; |
Eric Blake | d6a644b | 2017-07-07 07:44:57 -0500 | [diff] [blame] | 395 | int64_t n; |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 396 | int ret = 0; |
| 397 | uint8_t *buf = NULL; |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 398 | Error *local_err = NULL; |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 399 | |
| 400 | if (!drv) |
| 401 | return -ENOMEDIUM; |
| 402 | |
| 403 | if (!bs->backing) { |
| 404 | return -ENOTSUP; |
| 405 | } |
| 406 | |
| 407 | if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_COMMIT_SOURCE, NULL) || |
| 408 | bdrv_op_is_blocked(bs->backing->bs, BLOCK_OP_TYPE_COMMIT_TARGET, NULL)) { |
| 409 | return -EBUSY; |
| 410 | } |
| 411 | |
| 412 | ro = bs->backing->bs->read_only; |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 413 | |
| 414 | if (ro) { |
Alberto Garcia | c742a36 | 2018-11-12 16:00:36 +0200 | [diff] [blame] | 415 | if (bdrv_reopen_set_read_only(bs->backing->bs, false, NULL)) { |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 416 | return -EACCES; |
| 417 | } |
| 418 | } |
| 419 | |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 420 | src = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL); |
| 421 | backing = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 422 | |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 423 | ret = blk_insert_bs(src, bs, &local_err); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 424 | if (ret < 0) { |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 425 | error_report_err(local_err); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 426 | goto ro_cleanup; |
| 427 | } |
| 428 | |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 429 | /* Insert commit_top block node above backing, so we can write to it */ |
| 430 | backing_file_bs = backing_bs(bs); |
| 431 | |
| 432 | commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, NULL, BDRV_O_RDWR, |
| 433 | &local_err); |
| 434 | if (commit_top_bs == NULL) { |
| 435 | error_report_err(local_err); |
| 436 | goto ro_cleanup; |
| 437 | } |
Kevin Wolf | 02be4ae | 2017-04-06 19:05:07 +0200 | [diff] [blame] | 438 | bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(backing_file_bs)); |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 439 | |
Kevin Wolf | 12fa4af | 2017-02-17 20:42:32 +0100 | [diff] [blame] | 440 | bdrv_set_backing_hd(commit_top_bs, backing_file_bs, &error_abort); |
| 441 | bdrv_set_backing_hd(bs, commit_top_bs, &error_abort); |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 442 | |
| 443 | ret = blk_insert_bs(backing, backing_file_bs, &local_err); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 444 | if (ret < 0) { |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 445 | error_report_err(local_err); |
Kevin Wolf | d708642 | 2017-01-13 19:02:32 +0100 | [diff] [blame] | 446 | goto ro_cleanup; |
| 447 | } |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 448 | |
| 449 | length = blk_getlength(src); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 450 | if (length < 0) { |
| 451 | ret = length; |
| 452 | goto ro_cleanup; |
| 453 | } |
| 454 | |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 455 | backing_length = blk_getlength(backing); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 456 | if (backing_length < 0) { |
| 457 | ret = backing_length; |
| 458 | goto ro_cleanup; |
| 459 | } |
| 460 | |
| 461 | /* If our top snapshot is larger than the backing file image, |
| 462 | * grow the backing file image if possible. If not possible, |
| 463 | * we must return an error */ |
| 464 | if (length > backing_length) { |
Max Reitz | 3a691c5 | 2017-06-13 22:20:54 +0200 | [diff] [blame] | 465 | ret = blk_truncate(backing, length, PREALLOC_MODE_OFF, &local_err); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 466 | if (ret < 0) { |
Max Reitz | ed3d2ec | 2017-03-28 22:51:27 +0200 | [diff] [blame] | 467 | error_report_err(local_err); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 468 | goto ro_cleanup; |
| 469 | } |
| 470 | } |
| 471 | |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 472 | /* blk_try_blockalign() for src will choose an alignment that works for |
| 473 | * backing as well, so no need to compare the alignment manually. */ |
Eric Blake | d6a644b | 2017-07-07 07:44:57 -0500 | [diff] [blame] | 474 | buf = blk_try_blockalign(src, COMMIT_BUF_SIZE); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 475 | if (buf == NULL) { |
| 476 | ret = -ENOMEM; |
| 477 | goto ro_cleanup; |
| 478 | } |
| 479 | |
Eric Blake | d6a644b | 2017-07-07 07:44:57 -0500 | [diff] [blame] | 480 | for (offset = 0; offset < length; offset += n) { |
| 481 | ret = bdrv_is_allocated(bs, offset, COMMIT_BUF_SIZE, &n); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 482 | if (ret < 0) { |
| 483 | goto ro_cleanup; |
| 484 | } |
| 485 | if (ret) { |
Eric Blake | d6a644b | 2017-07-07 07:44:57 -0500 | [diff] [blame] | 486 | ret = blk_pread(src, offset, buf, n); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 487 | if (ret < 0) { |
| 488 | goto ro_cleanup; |
| 489 | } |
| 490 | |
Eric Blake | d6a644b | 2017-07-07 07:44:57 -0500 | [diff] [blame] | 491 | ret = blk_pwrite(backing, offset, buf, n, 0); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 492 | if (ret < 0) { |
| 493 | goto ro_cleanup; |
| 494 | } |
| 495 | } |
| 496 | } |
| 497 | |
| 498 | if (drv->bdrv_make_empty) { |
| 499 | ret = drv->bdrv_make_empty(bs); |
| 500 | if (ret < 0) { |
| 501 | goto ro_cleanup; |
| 502 | } |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 503 | blk_flush(src); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 504 | } |
| 505 | |
| 506 | /* |
| 507 | * Make sure all data we wrote to the backing device is actually |
| 508 | * stable on disk. |
| 509 | */ |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 510 | blk_flush(backing); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 511 | |
| 512 | ret = 0; |
| 513 | ro_cleanup: |
| 514 | qemu_vfree(buf); |
| 515 | |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 516 | blk_unref(backing); |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 517 | if (backing_file_bs) { |
Kevin Wolf | 12fa4af | 2017-02-17 20:42:32 +0100 | [diff] [blame] | 518 | bdrv_set_backing_hd(bs, backing_file_bs, &error_abort); |
Kevin Wolf | d3f0675 | 2017-01-19 18:16:03 +0100 | [diff] [blame] | 519 | } |
| 520 | bdrv_unref(commit_top_bs); |
| 521 | blk_unref(src); |
Kevin Wolf | f8e2bd5 | 2016-05-30 16:29:47 +0200 | [diff] [blame] | 522 | |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 523 | if (ro) { |
| 524 | /* ignoring error return here */ |
Alberto Garcia | c742a36 | 2018-11-12 16:00:36 +0200 | [diff] [blame] | 525 | bdrv_reopen_set_read_only(bs->backing->bs, true, NULL); |
Kevin Wolf | 83fd6dd | 2016-05-30 15:53:15 +0200 | [diff] [blame] | 526 | } |
| 527 | |
| 528 | return ret; |
| 529 | } |