blob: 53148e610bceeca0bc52c1edad961c6fc0da3177 [file] [log] [blame]
Jeff Cody747ff602012-09-27 13:29:13 -04001/*
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 Maydell80c71a22016-01-18 18:01:42 +000015#include "qemu/osdep.h"
Kevin Wolfdcbf37c2017-03-09 11:49:16 +010016#include "qemu/cutils.h"
Jeff Cody747ff602012-09-27 13:29:13 -040017#include "trace.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010018#include "block/block_int.h"
John Snowc87621e2016-10-27 12:07:00 -040019#include "block/blockjob_int.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010020#include "qapi/error.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010021#include "qapi/qmp/qerror.h"
Jeff Cody747ff602012-09-27 13:29:13 -040022#include "qemu/ratelimit.h"
Max Reitz373340b2015-10-19 17:53:22 +020023#include "sysemu/block-backend.h"
Jeff Cody747ff602012-09-27 13:29:13 -040024
25enum {
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 Cody747ff602012-09-27 13:29:13 -040034typedef struct CommitBlockJob {
35 BlockJob common;
Kevin Wolf8dfba272017-01-16 16:22:34 +010036 BlockDriverState *commit_top_bs;
Kevin Wolf46534562016-04-14 13:09:53 +020037 BlockBackend *top;
38 BlockBackend *base;
John Snow22dffcb2018-09-06 09:02:13 -040039 BlockDriverState *base_bs;
Paolo Bonzini92aa5c62012-09-28 17:22:55 +020040 BlockdevOnError on_error;
Alberto Garciae70cdc52018-11-12 16:00:35 +020041 bool base_read_only;
Jeff Cody54e26902014-06-25 15:40:10 -040042 char *backing_file_str;
Jeff Cody747ff602012-09-27 13:29:13 -040043} CommitBlockJob;
44
Kevin Wolf46534562016-04-14 13:09:53 +020045static int coroutine_fn commit_populate(BlockBackend *bs, BlockBackend *base,
Eric Blaked8a98582017-07-07 07:44:44 -050046 int64_t offset, uint64_t bytes,
Jeff Cody747ff602012-09-27 13:29:13 -040047 void *buf)
48{
49 int ret = 0;
Kevin Wolf46534562016-04-14 13:09:53 +020050 QEMUIOVector qiov;
51 struct iovec iov = {
52 .iov_base = buf,
Eric Blaked8a98582017-07-07 07:44:44 -050053 .iov_len = bytes,
Kevin Wolf46534562016-04-14 13:09:53 +020054 };
Jeff Cody747ff602012-09-27 13:29:13 -040055
Eric Blaked8a98582017-07-07 07:44:44 -050056 assert(bytes < SIZE_MAX);
Kevin Wolf46534562016-04-14 13:09:53 +020057 qemu_iovec_init_external(&qiov, &iov, 1);
58
Eric Blaked8a98582017-07-07 07:44:44 -050059 ret = blk_co_preadv(bs, offset, qiov.size, &qiov, 0);
Kevin Wolf46534562016-04-14 13:09:53 +020060 if (ret < 0) {
Jeff Cody747ff602012-09-27 13:29:13 -040061 return ret;
62 }
63
Eric Blaked8a98582017-07-07 07:44:44 -050064 ret = blk_co_pwritev(base, offset, qiov.size, &qiov, 0);
Kevin Wolf46534562016-04-14 13:09:53 +020065 if (ret < 0) {
Jeff Cody747ff602012-09-27 13:29:13 -040066 return ret;
67 }
68
69 return 0;
70}
71
John Snow22dffcb2018-09-06 09:02:13 -040072static int commit_prepare(Job *job)
Jeff Cody747ff602012-09-27 13:29:13 -040073{
Kevin Wolf1908a552018-04-17 16:41:17 +020074 CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
Kevin Wolf19ebd132017-06-02 23:04:55 +020075
Kevin Wolf8dfba272017-01-16 16:22:34 +010076 /* 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 Snow22dffcb2018-09-06 09:02:13 -040079 s->base = NULL;
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +010080
John Snow22dffcb2018-09-06 09:02:13 -040081 /* 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
87static 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 Hajnoczi9e85cd52014-10-21 12:03:59 +010098 }
99
John Snow22dffcb2018-09-06 09:02:13 -0400100 /* 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
120static void commit_clean(Job *job)
121{
122 CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
123
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100124 /* 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 Garciae70cdc52018-11-12 16:00:35 +0200127 if (s->base_read_only) {
128 bdrv_reopen_set_read_only(s->base_bs, true, NULL);
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100129 }
John Snow22dffcb2018-09-06 09:02:13 -0400130
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100131 g_free(s->backing_file_str);
Kevin Wolf46534562016-04-14 13:09:53 +0200132 blk_unref(s->top);
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100133}
134
John Snowf67432a2018-08-29 21:57:26 -0400135static int coroutine_fn commit_run(Job *job, Error **errp)
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100136{
John Snowf67432a2018-08-29 21:57:26 -0400137 CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
Eric Blake317a6672017-07-07 07:44:45 -0500138 int64_t offset;
Sascha Silbef14a39c2016-06-28 17:28:41 +0200139 uint64_t delay_ns = 0;
Jeff Cody747ff602012-09-27 13:29:13 -0400140 int ret = 0;
Eric Blake51b0a482017-07-07 07:44:59 -0500141 int64_t n = 0; /* bytes */
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100142 void *buf = NULL;
Jeff Cody747ff602012-09-27 13:29:13 -0400143 int bytes_written = 0;
Kevin Wolf05df8a62018-01-18 18:08:22 +0100144 int64_t len, base_len;
Jeff Cody747ff602012-09-27 13:29:13 -0400145
Kevin Wolf05df8a62018-01-18 18:08:22 +0100146 ret = len = blk_getlength(s->top);
147 if (len < 0) {
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100148 goto out;
Jeff Cody747ff602012-09-27 13:29:13 -0400149 }
Kevin Wolf30a5c882018-05-04 12:17:20 +0200150 job_progress_set_remaining(&s->common.job, len);
Jeff Cody747ff602012-09-27 13:29:13 -0400151
Kevin Wolf46534562016-04-14 13:09:53 +0200152 ret = base_len = blk_getlength(s->base);
Jeff Cody747ff602012-09-27 13:29:13 -0400153 if (base_len < 0) {
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100154 goto out;
Jeff Cody747ff602012-09-27 13:29:13 -0400155 }
156
Kevin Wolf05df8a62018-01-18 18:08:22 +0100157 if (base_len < len) {
158 ret = blk_truncate(s->base, len, PREALLOC_MODE_OFF, NULL);
Jeff Cody747ff602012-09-27 13:29:13 -0400159 if (ret) {
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100160 goto out;
Jeff Cody747ff602012-09-27 13:29:13 -0400161 }
162 }
163
Kevin Wolf46534562016-04-14 13:09:53 +0200164 buf = blk_blockalign(s->top, COMMIT_BUFFER_SIZE);
Jeff Cody747ff602012-09-27 13:29:13 -0400165
Kevin Wolf05df8a62018-01-18 18:08:22 +0100166 for (offset = 0; offset < len; offset += n) {
Jeff Cody747ff602012-09-27 13:29:13 -0400167 bool copy;
168
Jeff Cody747ff602012-09-27 13:29:13 -0400169 /* Note that even when no rate limit is applied we need to yield
Kevin Wolfc57b6652012-11-13 16:35:13 +0100170 * with no pending I/O here so that bdrv_drain_all() returns.
Jeff Cody747ff602012-09-27 13:29:13 -0400171 */
Kevin Wolf5d43e862018-04-18 16:32:20 +0200172 job_sleep_ns(&s->common.job, delay_ns);
Kevin Wolfdaa7f2f2018-04-17 12:56:07 +0200173 if (job_is_cancelled(&s->common.job)) {
Jeff Cody747ff602012-09-27 13:29:13 -0400174 break;
175 }
176 /* Copy if allocated above the base */
Kevin Wolf46534562016-04-14 13:09:53 +0200177 ret = bdrv_is_allocated_above(blk_bs(s->top), blk_bs(s->base),
Eric Blake51b0a482017-07-07 07:44:59 -0500178 offset, COMMIT_BUFFER_SIZE, &n);
Jeff Cody747ff602012-09-27 13:29:13 -0400179 copy = (ret == 1);
Eric Blake51b0a482017-07-07 07:44:59 -0500180 trace_commit_one_iteration(s, offset, n, ret);
Jeff Cody747ff602012-09-27 13:29:13 -0400181 if (copy) {
Eric Blake51b0a482017-07-07 07:44:59 -0500182 ret = commit_populate(s->top, s->base, offset, n, buf);
183 bytes_written += n;
Jeff Cody747ff602012-09-27 13:29:13 -0400184 }
185 if (ret < 0) {
Kevin Wolf1e8fb7f2016-06-29 17:38:57 +0200186 BlockErrorAction action =
187 block_job_error_action(&s->common, false, s->on_error, -ret);
188 if (action == BLOCK_ERROR_ACTION_REPORT) {
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100189 goto out;
Jeff Cody747ff602012-09-27 13:29:13 -0400190 } else {
191 n = 0;
192 continue;
193 }
194 }
195 /* Publish progress */
Kevin Wolf30a5c882018-05-04 12:17:20 +0200196 job_progress_update(&s->common.job, n);
Sascha Silbef14a39c2016-06-28 17:28:41 +0200197
Kevin Wolfdee81d52018-01-18 21:19:38 +0100198 if (copy) {
199 delay_ns = block_job_ratelimit_get_delay(&s->common, n);
Kevin Wolf2fe4bba2018-01-18 21:23:52 +0100200 } else {
201 delay_ns = 0;
Sascha Silbef14a39c2016-06-28 17:28:41 +0200202 }
Jeff Cody747ff602012-09-27 13:29:13 -0400203 }
204
205 ret = 0;
206
Stefan Hajnoczi9e85cd52014-10-21 12:03:59 +0100207out:
Jeff Cody747ff602012-09-27 13:29:13 -0400208 qemu_vfree(buf);
209
John Snowf67432a2018-08-29 21:57:26 -0400210 return ret;
Jeff Cody747ff602012-09-27 13:29:13 -0400211}
212
Fam Zheng3fc4b102013-10-08 17:29:38 +0800213static const BlockJobDriver commit_job_driver = {
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200214 .job_driver = {
215 .instance_size = sizeof(CommitBlockJob),
Kevin Wolf252291e2018-04-12 17:57:08 +0200216 .job_type = JOB_TYPE_COMMIT,
Kevin Wolf80fa2c72018-04-13 18:50:05 +0200217 .free = block_job_free,
Kevin Wolfb15de822018-04-18 17:10:26 +0200218 .user_resume = block_job_user_resume,
Kevin Wolfb69f7772018-04-20 17:00:29 +0200219 .drain = block_job_drain,
John Snowf67432a2018-08-29 21:57:26 -0400220 .run = commit_run,
John Snow22dffcb2018-09-06 09:02:13 -0400221 .prepare = commit_prepare,
222 .abort = commit_abort,
223 .clean = commit_clean
Kevin Wolf33e9e9b2018-04-12 17:29:59 +0200224 },
Jeff Cody747ff602012-09-27 13:29:13 -0400225};
226
Kevin Wolf8dfba272017-01-16 16:22:34 +0100227static 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 Wolfdcbf37c2017-03-09 11:49:16 +0100233static 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 Wolf91965652017-03-08 15:07:12 +0100239
Kevin Wolf8dfba272017-01-16 16:22:34 +0100240static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,
241 const BdrvChildRole *role,
Kevin Wolfe0995dc2017-09-14 12:47:11 +0200242 BlockReopenQueue *reopen_queue,
Kevin Wolf8dfba272017-01-16 16:22:34 +0100243 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. */
252static BlockDriver bdrv_commit_top = {
Kevin Wolf91965652017-03-08 15:07:12 +0100253 .format_name = "commit_top",
254 .bdrv_co_preadv = bdrv_commit_top_preadv,
Eric Blake3e4d0e72018-02-13 14:26:43 -0600255 .bdrv_co_block_status = bdrv_co_block_status_from_backing,
Kevin Wolfdcbf37c2017-03-09 11:49:16 +0100256 .bdrv_refresh_filename = bdrv_commit_top_refresh_filename,
Kevin Wolf91965652017-03-08 15:07:12 +0100257 .bdrv_child_perm = bdrv_commit_top_child_perm,
Kevin Wolf8dfba272017-01-16 16:22:34 +0100258};
259
Alberto Garciafd62c602016-07-05 17:29:00 +0300260void commit_start(const char *job_id, BlockDriverState *bs,
John Snow53607822018-09-06 09:02:10 -0400261 BlockDriverState *base, BlockDriverState *top,
262 int creation_flags, int64_t speed,
John Snow8254b6d2016-10-27 12:06:58 -0400263 BlockdevOnError on_error, const char *backing_file_str,
Kevin Wolf0db832f2017-02-20 18:10:05 +0100264 const char *filter_node_name, Error **errp)
Jeff Cody747ff602012-09-27 13:29:13 -0400265{
266 CommitBlockJob *s;
Alberto Garcia3e4c5122016-10-28 10:08:08 +0300267 BlockDriverState *iter;
Kevin Wolf8dfba272017-01-16 16:22:34 +0100268 BlockDriverState *commit_top_bs = NULL;
Jeff Cody747ff602012-09-27 13:29:13 -0400269 Error *local_err = NULL;
Kevin Wolfd7086422017-01-13 19:02:32 +0100270 int ret;
Jeff Cody747ff602012-09-27 13:29:13 -0400271
Fam Zheng18da7f92013-12-16 14:45:33 +0800272 assert(top != bs);
Jeff Cody747ff602012-09-27 13:29:13 -0400273 if (top == base) {
274 error_setg(errp, "Invalid files for merge: top and base are the same");
275 return;
276 }
277
John Snow75859b92018-03-10 03:27:27 -0500278 s = block_job_create(job_id, &commit_job_driver, NULL, bs, 0, BLK_PERM_ALL,
John Snow53607822018-09-06 09:02:10 -0400279 speed, creation_flags, NULL, NULL, errp);
Alberto Garcia834fe282016-05-27 12:53:39 +0200280 if (!s) {
281 return;
282 }
283
Kevin Wolfbde70712017-06-27 20:36:18 +0200284 /* convert base to r/w, if necessary */
Alberto Garciae70cdc52018-11-12 16:00:35 +0200285 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 Wolfd7086422017-01-13 19:02:32 +0100288 goto fail;
Jeff Cody747ff602012-09-27 13:29:13 -0400289 }
290 }
291
Kevin Wolf8dfba272017-01-16 16:22:34 +0100292 /* Insert commit_top block node above top, so we can block consistent read
293 * on the backing chain below it */
Kevin Wolf0db832f2017-02-20 18:10:05 +0100294 commit_top_bs = bdrv_new_open_driver(&bdrv_commit_top, filter_node_name, 0,
295 errp);
Kevin Wolf8dfba272017-01-16 16:22:34 +0100296 if (commit_top_bs == NULL) {
297 goto fail;
298 }
Kevin Wolfd3c8c672017-07-18 17:24:05 +0200299 if (!filter_node_name) {
300 commit_top_bs->implicit = true;
301 }
Kevin Wolf0d0676a2017-04-06 19:07:14 +0200302 commit_top_bs->total_sectors = top->total_sectors;
Kevin Wolf02be4ae2017-04-06 19:05:07 +0200303 bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(top));
Kevin Wolf8dfba272017-01-16 16:22:34 +0100304
Fam Zhengb69f00d2017-03-07 19:07:22 +0800305 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 Wolf61f09ce2017-09-19 16:22:54 +0200312 bdrv_replace_node(top, commit_top_bs, &local_err);
Fam Zhengb69f00d2017-03-07 19:07:22 +0800313 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 Wolf8dfba272017-01-16 16:22:34 +0100319
320 s->commit_top_bs = commit_top_bs;
321 bdrv_unref(commit_top_bs);
Jeff Cody747ff602012-09-27 13:29:13 -0400322
Alberto Garcia3e4c5122016-10-28 10:08:08 +0300323 /* 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 Wolf8dfba272017-01-16 16:22:34 +0100326 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 Garcia3e4c5122016-10-28 10:08:08 +0300337 }
338
Kevin Wolf8dfba272017-01-16 16:22:34 +0100339 ret = block_job_add_bdrv(&s->common, "base", base, 0, BLK_PERM_ALL, errp);
340 if (ret < 0) {
341 goto fail;
342 }
343
Kevin Wolf8dfba272017-01-16 16:22:34 +0100344 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 Wolfd7086422017-01-13 19:02:32 +0100350 ret = blk_insert_bs(s->base, base, errp);
351 if (ret < 0) {
352 goto fail;
353 }
John Snow22dffcb2018-09-06 09:02:13 -0400354 s->base_bs = base;
Kevin Wolf46534562016-04-14 13:09:53 +0200355
Kevin Wolf8dfba272017-01-16 16:22:34 +0100356 /* Required permissions are already taken with block_job_add_bdrv() */
Kevin Wolf6d0eb642017-01-20 17:07:26 +0100357 s->top = blk_new(0, BLK_PERM_ALL);
Kevin Wolfb2477672017-03-03 16:54:21 +0100358 ret = blk_insert_bs(s->top, top, errp);
Kevin Wolfd7086422017-01-13 19:02:32 +0100359 if (ret < 0) {
360 goto fail;
361 }
Kevin Wolf46534562016-04-14 13:09:53 +0200362
Jeff Cody54e26902014-06-25 15:40:10 -0400363 s->backing_file_str = g_strdup(backing_file_str);
Jeff Cody747ff602012-09-27 13:29:13 -0400364 s->on_error = on_error;
Jeff Cody747ff602012-09-27 13:29:13 -0400365
John Snow5ccac6f2016-11-08 01:50:37 -0500366 trace_commit_start(bs, base, top, s);
Kevin Wolfda01ff72018-04-13 17:31:02 +0200367 job_start(&s->common.job);
Kevin Wolfd7086422017-01-13 19:02:32 +0100368 return;
369
370fail:
371 if (s->base) {
372 blk_unref(s->base);
373 }
374 if (s->top) {
375 blk_unref(s->top);
376 }
Kevin Wolf8dfba272017-01-16 16:22:34 +0100377 if (commit_top_bs) {
Kevin Wolfbde70712017-06-27 20:36:18 +0200378 bdrv_replace_node(commit_top_bs, top, &error_abort);
Kevin Wolf8dfba272017-01-16 16:22:34 +0100379 }
Kevin Wolf4ad35182018-04-19 17:30:16 +0200380 job_early_fail(&s->common.job);
Jeff Cody747ff602012-09-27 13:29:13 -0400381}
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200382
383
Eric Blaked6a644b2017-07-07 07:44:57 -0500384#define COMMIT_BUF_SIZE (2048 * BDRV_SECTOR_SIZE)
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200385
386/* commit COW file into the raw image */
387int bdrv_commit(BlockDriverState *bs)
388{
Kevin Wolff8e2bd52016-05-30 16:29:47 +0200389 BlockBackend *src, *backing;
Kevin Wolfd3f06752017-01-19 18:16:03 +0100390 BlockDriverState *backing_file_bs = NULL;
391 BlockDriverState *commit_top_bs = NULL;
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200392 BlockDriver *drv = bs->drv;
Eric Blaked6a644b2017-07-07 07:44:57 -0500393 int64_t offset, length, backing_length;
Alberto Garciac742a362018-11-12 16:00:36 +0200394 int ro;
Eric Blaked6a644b2017-07-07 07:44:57 -0500395 int64_t n;
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200396 int ret = 0;
397 uint8_t *buf = NULL;
Kevin Wolfd3f06752017-01-19 18:16:03 +0100398 Error *local_err = NULL;
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200399
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 Wolf83fd6dd2016-05-30 15:53:15 +0200413
414 if (ro) {
Alberto Garciac742a362018-11-12 16:00:36 +0200415 if (bdrv_reopen_set_read_only(bs->backing->bs, false, NULL)) {
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200416 return -EACCES;
417 }
418 }
419
Kevin Wolfd3f06752017-01-19 18:16:03 +0100420 src = blk_new(BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
421 backing = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE, BLK_PERM_ALL);
Kevin Wolfd7086422017-01-13 19:02:32 +0100422
Kevin Wolfd3f06752017-01-19 18:16:03 +0100423 ret = blk_insert_bs(src, bs, &local_err);
Kevin Wolfd7086422017-01-13 19:02:32 +0100424 if (ret < 0) {
Kevin Wolfd3f06752017-01-19 18:16:03 +0100425 error_report_err(local_err);
Kevin Wolfd7086422017-01-13 19:02:32 +0100426 goto ro_cleanup;
427 }
428
Kevin Wolfd3f06752017-01-19 18:16:03 +0100429 /* 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 Wolf02be4ae2017-04-06 19:05:07 +0200438 bdrv_set_aio_context(commit_top_bs, bdrv_get_aio_context(backing_file_bs));
Kevin Wolfd3f06752017-01-19 18:16:03 +0100439
Kevin Wolf12fa4af2017-02-17 20:42:32 +0100440 bdrv_set_backing_hd(commit_top_bs, backing_file_bs, &error_abort);
441 bdrv_set_backing_hd(bs, commit_top_bs, &error_abort);
Kevin Wolfd3f06752017-01-19 18:16:03 +0100442
443 ret = blk_insert_bs(backing, backing_file_bs, &local_err);
Kevin Wolfd7086422017-01-13 19:02:32 +0100444 if (ret < 0) {
Kevin Wolfd3f06752017-01-19 18:16:03 +0100445 error_report_err(local_err);
Kevin Wolfd7086422017-01-13 19:02:32 +0100446 goto ro_cleanup;
447 }
Kevin Wolff8e2bd52016-05-30 16:29:47 +0200448
449 length = blk_getlength(src);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200450 if (length < 0) {
451 ret = length;
452 goto ro_cleanup;
453 }
454
Kevin Wolff8e2bd52016-05-30 16:29:47 +0200455 backing_length = blk_getlength(backing);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200456 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 Reitz3a691c52017-06-13 22:20:54 +0200465 ret = blk_truncate(backing, length, PREALLOC_MODE_OFF, &local_err);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200466 if (ret < 0) {
Max Reitzed3d2ec2017-03-28 22:51:27 +0200467 error_report_err(local_err);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200468 goto ro_cleanup;
469 }
470 }
471
Kevin Wolff8e2bd52016-05-30 16:29:47 +0200472 /* 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 Blaked6a644b2017-07-07 07:44:57 -0500474 buf = blk_try_blockalign(src, COMMIT_BUF_SIZE);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200475 if (buf == NULL) {
476 ret = -ENOMEM;
477 goto ro_cleanup;
478 }
479
Eric Blaked6a644b2017-07-07 07:44:57 -0500480 for (offset = 0; offset < length; offset += n) {
481 ret = bdrv_is_allocated(bs, offset, COMMIT_BUF_SIZE, &n);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200482 if (ret < 0) {
483 goto ro_cleanup;
484 }
485 if (ret) {
Eric Blaked6a644b2017-07-07 07:44:57 -0500486 ret = blk_pread(src, offset, buf, n);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200487 if (ret < 0) {
488 goto ro_cleanup;
489 }
490
Eric Blaked6a644b2017-07-07 07:44:57 -0500491 ret = blk_pwrite(backing, offset, buf, n, 0);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200492 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 Wolff8e2bd52016-05-30 16:29:47 +0200503 blk_flush(src);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200504 }
505
506 /*
507 * Make sure all data we wrote to the backing device is actually
508 * stable on disk.
509 */
Kevin Wolff8e2bd52016-05-30 16:29:47 +0200510 blk_flush(backing);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200511
512 ret = 0;
513ro_cleanup:
514 qemu_vfree(buf);
515
Kevin Wolff8e2bd52016-05-30 16:29:47 +0200516 blk_unref(backing);
Kevin Wolfd3f06752017-01-19 18:16:03 +0100517 if (backing_file_bs) {
Kevin Wolf12fa4af2017-02-17 20:42:32 +0100518 bdrv_set_backing_hd(bs, backing_file_bs, &error_abort);
Kevin Wolfd3f06752017-01-19 18:16:03 +0100519 }
520 bdrv_unref(commit_top_bs);
521 blk_unref(src);
Kevin Wolff8e2bd52016-05-30 16:29:47 +0200522
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200523 if (ro) {
524 /* ignoring error return here */
Alberto Garciac742a362018-11-12 16:00:36 +0200525 bdrv_reopen_set_read_only(bs->backing->bs, true, NULL);
Kevin Wolf83fd6dd2016-05-30 15:53:15 +0200526 }
527
528 return ret;
529}