blob: e22ac3eac638ec3748383e1ba9ca22c8cb93cf65 [file] [log] [blame]
Wenchao Xiade08c602013-05-25 11:09:43 +08001/*
2 * Block layer snapshot related functions
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
Peter Maydell80c71a22016-01-18 18:01:42 +000025#include "qemu/osdep.h"
Wenchao Xiade08c602013-05-25 11:09:43 +080026#include "block/snapshot.h"
27#include "block/block_int.h"
Max Reitz609f45e2018-06-14 21:14:28 +020028#include "block/qdict.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010029#include "qapi/error.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010030#include "qapi/qmp/qdict.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010031#include "qapi/qmp/qerror.h"
Dong Jia Shi7a9e5112017-04-05 11:19:09 +020032#include "qapi/qmp/qstring.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010033#include "qemu/option.h"
Kevin Wolf05f4ace2019-09-17 12:26:23 +020034#include "sysemu/block-backend.h"
Wenchao Xiade08c602013-05-25 11:09:43 +080035
Wenchao Xia8c116b02013-12-04 17:10:55 +080036QemuOptsList internal_snapshot_opts = {
37 .name = "snapshot",
38 .head = QTAILQ_HEAD_INITIALIZER(internal_snapshot_opts.head),
39 .desc = {
40 {
41 .name = SNAPSHOT_OPT_ID,
42 .type = QEMU_OPT_STRING,
43 .help = "snapshot id"
44 },{
45 .name = SNAPSHOT_OPT_NAME,
46 .type = QEMU_OPT_STRING,
47 .help = "snapshot name"
48 },{
49 /* end of list */
50 }
51 },
52};
53
Wenchao Xiade08c602013-05-25 11:09:43 +080054int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
55 const char *name)
56{
57 QEMUSnapshotInfo *sn_tab, *sn;
58 int nb_sns, i, ret;
59
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -050060 GLOBAL_STATE_CODE();
61
Wenchao Xiade08c602013-05-25 11:09:43 +080062 ret = -ENOENT;
63 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
64 if (nb_sns < 0) {
65 return ret;
66 }
67 for (i = 0; i < nb_sns; i++) {
68 sn = &sn_tab[i];
Daniel Henrique Barboza6ca08042018-11-07 11:09:58 -020069 if (!strcmp(sn->name, name)) {
Wenchao Xiade08c602013-05-25 11:09:43 +080070 *sn_info = *sn;
71 ret = 0;
72 break;
73 }
74 }
75 g_free(sn_tab);
76 return ret;
77}
78
Wenchao Xia2ea1dd72013-09-11 14:04:32 +080079/**
80 * Look up an internal snapshot by @id and @name.
81 * @bs: block device to search
82 * @id: unique snapshot ID, or NULL
83 * @name: snapshot name, or NULL
84 * @sn_info: location to store information on the snapshot found
85 * @errp: location to store error, will be set only for exception
86 *
87 * This function will traverse snapshot list in @bs to search the matching
88 * one, @id and @name are the matching condition:
89 * If both @id and @name are specified, find the first one with id @id and
90 * name @name.
91 * If only @id is specified, find the first one with id @id.
92 * If only @name is specified, find the first one with name @name.
93 * if none is specified, abort().
94 *
95 * Returns: true when a snapshot is found and @sn_info will be filled, false
96 * when error or not found. If all operation succeed but no matching one is
97 * found, @errp will NOT be set.
98 */
99bool bdrv_snapshot_find_by_id_and_name(BlockDriverState *bs,
100 const char *id,
101 const char *name,
102 QEMUSnapshotInfo *sn_info,
103 Error **errp)
104{
105 QEMUSnapshotInfo *sn_tab, *sn;
106 int nb_sns, i;
107 bool ret = false;
108
109 assert(id || name);
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500110 GLOBAL_STATE_CODE();
Wenchao Xia2ea1dd72013-09-11 14:04:32 +0800111
112 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
113 if (nb_sns < 0) {
114 error_setg_errno(errp, -nb_sns, "Failed to get a snapshot list");
115 return false;
116 } else if (nb_sns == 0) {
117 return false;
118 }
119
120 if (id && name) {
121 for (i = 0; i < nb_sns; i++) {
122 sn = &sn_tab[i];
123 if (!strcmp(sn->id_str, id) && !strcmp(sn->name, name)) {
124 *sn_info = *sn;
125 ret = true;
126 break;
127 }
128 }
129 } else if (id) {
130 for (i = 0; i < nb_sns; i++) {
131 sn = &sn_tab[i];
132 if (!strcmp(sn->id_str, id)) {
133 *sn_info = *sn;
134 ret = true;
135 break;
136 }
137 }
138 } else if (name) {
139 for (i = 0; i < nb_sns; i++) {
140 sn = &sn_tab[i];
141 if (!strcmp(sn->name, name)) {
142 *sn_info = *sn;
143 ret = true;
144 break;
145 }
146 }
147 }
148
149 g_free(sn_tab);
150 return ret;
151}
152
Max Reitzc8af8752019-06-12 18:21:07 +0200153/**
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300154 * Return a pointer to child of given BDS to which we can fall
Max Reitzc8af8752019-06-12 18:21:07 +0200155 * back if the given BDS does not support snapshots.
156 * Return NULL if there is no BDS to (safely) fall back to.
Max Reitzc8af8752019-06-12 18:21:07 +0200157 */
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300158static BdrvChild *bdrv_snapshot_fallback_child(BlockDriverState *bs)
Max Reitzc8af8752019-06-12 18:21:07 +0200159{
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300160 BdrvChild *fallback = bdrv_primary_child(bs);
161 BdrvChild *child;
Max Reitzc8af8752019-06-12 18:21:07 +0200162
Vladimir Sementsov-Ogievskiy0c6100a2022-07-26 23:11:27 +0300163 /* We allow fallback only to primary child */
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300164 if (!fallback) {
Max Reitzc8af8752019-06-12 18:21:07 +0200165 return NULL;
166 }
167
168 /*
169 * Check that there are no other children that would need to be
170 * snapshotted. If there are, it is not safe to fall back to
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300171 * fallback.
Max Reitzc8af8752019-06-12 18:21:07 +0200172 */
173 QLIST_FOREACH(child, &bs->children, next) {
174 if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
175 BDRV_CHILD_FILTERED) &&
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300176 child != fallback)
Max Reitzc8af8752019-06-12 18:21:07 +0200177 {
178 return NULL;
179 }
180 }
181
182 return fallback;
183}
184
185static BlockDriverState *bdrv_snapshot_fallback(BlockDriverState *bs)
186{
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300187 return child_bs(bdrv_snapshot_fallback_child(bs));
Max Reitzc8af8752019-06-12 18:21:07 +0200188}
189
Wenchao Xiade08c602013-05-25 11:09:43 +0800190int bdrv_can_snapshot(BlockDriverState *bs)
191{
192 BlockDriver *drv = bs->drv;
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500193 GLOBAL_STATE_CODE();
Wenchao Xiade08c602013-05-25 11:09:43 +0800194 if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
195 return 0;
196 }
197
198 if (!drv->bdrv_snapshot_create) {
Max Reitzc8af8752019-06-12 18:21:07 +0200199 BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
200 if (fallback_bs) {
201 return bdrv_can_snapshot(fallback_bs);
Wenchao Xiade08c602013-05-25 11:09:43 +0800202 }
203 return 0;
204 }
205
206 return 1;
207}
208
209int bdrv_snapshot_create(BlockDriverState *bs,
210 QEMUSnapshotInfo *sn_info)
211{
212 BlockDriver *drv = bs->drv;
Max Reitzc8af8752019-06-12 18:21:07 +0200213 BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500214
215 GLOBAL_STATE_CODE();
216
Wenchao Xiade08c602013-05-25 11:09:43 +0800217 if (!drv) {
218 return -ENOMEDIUM;
219 }
220 if (drv->bdrv_snapshot_create) {
221 return drv->bdrv_snapshot_create(bs, sn_info);
222 }
Max Reitzc8af8752019-06-12 18:21:07 +0200223 if (fallback_bs) {
224 return bdrv_snapshot_create(fallback_bs, sn_info);
Wenchao Xiade08c602013-05-25 11:09:43 +0800225 }
226 return -ENOTSUP;
227}
228
229int bdrv_snapshot_goto(BlockDriverState *bs,
Kevin Wolf0b62bcb2017-11-20 15:28:41 +0100230 const char *snapshot_id,
231 Error **errp)
Wenchao Xiade08c602013-05-25 11:09:43 +0800232{
233 BlockDriver *drv = bs->drv;
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300234 BdrvChild *fallback;
Wenchao Xiade08c602013-05-25 11:09:43 +0800235 int ret, open_ret;
236
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500237 GLOBAL_STATE_CODE();
238
Wenchao Xiade08c602013-05-25 11:09:43 +0800239 if (!drv) {
Kevin Wolf0b62bcb2017-11-20 15:28:41 +0100240 error_setg(errp, "Block driver is closed");
Wenchao Xiade08c602013-05-25 11:09:43 +0800241 return -ENOMEDIUM;
242 }
Vladimir Sementsov-Ogievskiy04dec3c2017-10-23 12:29:45 +0300243
Kevin Wolf70a5afe2017-11-20 15:41:31 +0100244 if (!QLIST_EMPTY(&bs->dirty_bitmaps)) {
245 error_setg(errp, "Device has active dirty bitmaps");
246 return -EBUSY;
Vladimir Sementsov-Ogievskiy04dec3c2017-10-23 12:29:45 +0300247 }
Vladimir Sementsov-Ogievskiy04dec3c2017-10-23 12:29:45 +0300248
Wenchao Xiade08c602013-05-25 11:09:43 +0800249 if (drv->bdrv_snapshot_goto) {
Kevin Wolf0b62bcb2017-11-20 15:28:41 +0100250 ret = drv->bdrv_snapshot_goto(bs, snapshot_id);
251 if (ret < 0) {
252 error_setg_errno(errp, -ret, "Failed to load snapshot");
253 }
254 return ret;
Wenchao Xiade08c602013-05-25 11:09:43 +0800255 }
256
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300257 fallback = bdrv_snapshot_fallback_child(bs);
258 if (fallback) {
Max Reitzc8af8752019-06-12 18:21:07 +0200259 QDict *options;
Dong Jia Shi7a9e5112017-04-05 11:19:09 +0200260 QDict *file_options;
Kevin Wolf0b62bcb2017-11-20 15:28:41 +0100261 Error *local_err = NULL;
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300262 BlockDriverState *fallback_bs = fallback->bs;
263 char *subqdict_prefix = g_strdup_printf("%s.", fallback->name);
Dong Jia Shi7a9e5112017-04-05 11:19:09 +0200264
Max Reitzc8af8752019-06-12 18:21:07 +0200265 options = qdict_clone_shallow(bs->options);
266
Dong Jia Shi7a9e5112017-04-05 11:19:09 +0200267 /* Prevent it from getting deleted when detached from bs */
Max Reitzc8af8752019-06-12 18:21:07 +0200268 bdrv_ref(fallback_bs);
Dong Jia Shi7a9e5112017-04-05 11:19:09 +0200269
Max Reitzc8af8752019-06-12 18:21:07 +0200270 qdict_extract_subqdict(options, &file_options, subqdict_prefix);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200271 qobject_unref(file_options);
Max Reitzc8af8752019-06-12 18:21:07 +0200272 g_free(subqdict_prefix);
273
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300274 /* Force .bdrv_open() below to re-attach fallback_bs on fallback */
275 qdict_put_str(options, fallback->name,
Max Reitzc8af8752019-06-12 18:21:07 +0200276 bdrv_get_node_name(fallback_bs));
Dong Jia Shi7a9e5112017-04-05 11:19:09 +0200277
Max Reitz32a9a242021-05-03 02:54:18 -0700278 /* Now close bs, apply the snapshot on fallback_bs, and re-open bs */
Vladimir Sementsov-Ogievskiy3c005292018-08-14 15:43:19 +0300279 if (drv->bdrv_close) {
280 drv->bdrv_close(bs);
281 }
Dong Jia Shi7a9e5112017-04-05 11:19:09 +0200282
Max Reitz32a9a242021-05-03 02:54:18 -0700283 /* .bdrv_open() will re-attach it */
Vladimir Sementsov-Ogievskiyc5c21742022-07-26 23:11:33 +0300284 bdrv_unref_child(bs, fallback);
Max Reitzc8af8752019-06-12 18:21:07 +0200285
286 ret = bdrv_snapshot_goto(fallback_bs, snapshot_id, errp);
Kevin Wolf0b62bcb2017-11-20 15:28:41 +0100287 open_ret = drv->bdrv_open(bs, options, bs->open_flags, &local_err);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200288 qobject_unref(options);
Wenchao Xiade08c602013-05-25 11:09:43 +0800289 if (open_ret < 0) {
Max Reitzc8af8752019-06-12 18:21:07 +0200290 bdrv_unref(fallback_bs);
Wenchao Xiade08c602013-05-25 11:09:43 +0800291 bs->drv = NULL;
Kevin Wolf0b62bcb2017-11-20 15:28:41 +0100292 /* A bdrv_snapshot_goto() error takes precedence */
293 error_propagate(errp, local_err);
294 return ret < 0 ? ret : open_ret;
Wenchao Xiade08c602013-05-25 11:09:43 +0800295 }
Dong Jia Shi7a9e5112017-04-05 11:19:09 +0200296
Max Reitz32a9a242021-05-03 02:54:18 -0700297 /*
Vladimir Sementsov-Ogievskiy0c6100a2022-07-26 23:11:27 +0300298 * fallback was a primary child. It was closed above and set to NULL,
299 * but the .bdrv_open() call has opened it again, because we set the
300 * respective option (with the qdict_put_str() call above).
301 * Assert that .bdrv_open() has attached the right BDS as primary child.
Max Reitz32a9a242021-05-03 02:54:18 -0700302 */
Vladimir Sementsov-Ogievskiy0c6100a2022-07-26 23:11:27 +0300303 assert(bdrv_primary_bs(bs) == fallback_bs);
Max Reitzc8af8752019-06-12 18:21:07 +0200304 bdrv_unref(fallback_bs);
Wenchao Xiade08c602013-05-25 11:09:43 +0800305 return ret;
306 }
307
Kevin Wolf0b62bcb2017-11-20 15:28:41 +0100308 error_setg(errp, "Block driver does not support snapshots");
Wenchao Xiade08c602013-05-25 11:09:43 +0800309 return -ENOTSUP;
310}
311
Wenchao Xiaa89d89d2013-09-11 14:04:33 +0800312/**
313 * Delete an internal snapshot by @snapshot_id and @name.
314 * @bs: block device used in the operation
315 * @snapshot_id: unique snapshot ID, or NULL
316 * @name: snapshot name, or NULL
317 * @errp: location to store error
318 *
319 * If both @snapshot_id and @name are specified, delete the first one with
320 * id @snapshot_id and name @name.
321 * If only @snapshot_id is specified, delete the first one with id
322 * @snapshot_id.
323 * If only @name is specified, delete the first one with name @name.
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800324 * if none is specified, return -EINVAL.
Wenchao Xiaa89d89d2013-09-11 14:04:33 +0800325 *
326 * Returns: 0 on success, -errno on failure. If @bs is not inserted, return
327 * -ENOMEDIUM. If @snapshot_id and @name are both NULL, return -EINVAL. If @bs
328 * does not support internal snapshot deletion, return -ENOTSUP. If @bs does
329 * not support parameter @snapshot_id or @name, or one of them is not correctly
330 * specified, return -EINVAL. If @bs can't find one matching @id and @name,
331 * return -ENOENT. If @errp != NULL, it will always be filled with error
332 * message on failure.
333 */
334int bdrv_snapshot_delete(BlockDriverState *bs,
335 const char *snapshot_id,
336 const char *name,
337 Error **errp)
Wenchao Xiade08c602013-05-25 11:09:43 +0800338{
339 BlockDriver *drv = bs->drv;
Max Reitzc8af8752019-06-12 18:21:07 +0200340 BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
Paolo Bonzini27a76492015-12-16 19:33:45 +0100341 int ret;
342
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500343 GLOBAL_STATE_CODE();
344
Wenchao Xiade08c602013-05-25 11:09:43 +0800345 if (!drv) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100346 error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, bdrv_get_device_name(bs));
Wenchao Xiade08c602013-05-25 11:09:43 +0800347 return -ENOMEDIUM;
348 }
Wenchao Xiaa89d89d2013-09-11 14:04:33 +0800349 if (!snapshot_id && !name) {
350 error_setg(errp, "snapshot_id and name are both NULL");
351 return -EINVAL;
352 }
Zhang Haoyu3432a192014-10-21 16:38:01 +0800353
354 /* drain all pending i/o before deleting snapshot */
Paolo Bonzini27a76492015-12-16 19:33:45 +0100355 bdrv_drained_begin(bs);
Zhang Haoyu3432a192014-10-21 16:38:01 +0800356
Wenchao Xiade08c602013-05-25 11:09:43 +0800357 if (drv->bdrv_snapshot_delete) {
Paolo Bonzini27a76492015-12-16 19:33:45 +0100358 ret = drv->bdrv_snapshot_delete(bs, snapshot_id, name, errp);
Max Reitzc8af8752019-06-12 18:21:07 +0200359 } else if (fallback_bs) {
360 ret = bdrv_snapshot_delete(fallback_bs, snapshot_id, name, errp);
Paolo Bonzini27a76492015-12-16 19:33:45 +0100361 } else {
362 error_setg(errp, "Block format '%s' used by device '%s' "
363 "does not support internal snapshot deletion",
364 drv->format_name, bdrv_get_device_name(bs));
365 ret = -ENOTSUP;
Wenchao Xiade08c602013-05-25 11:09:43 +0800366 }
Paolo Bonzini27a76492015-12-16 19:33:45 +0100367
368 bdrv_drained_end(bs);
369 return ret;
Wenchao Xiade08c602013-05-25 11:09:43 +0800370}
371
Wenchao Xiade08c602013-05-25 11:09:43 +0800372int bdrv_snapshot_list(BlockDriverState *bs,
373 QEMUSnapshotInfo **psn_info)
374{
375 BlockDriver *drv = bs->drv;
Max Reitzc8af8752019-06-12 18:21:07 +0200376 BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500377
378 GLOBAL_STATE_CODE();
Wenchao Xiade08c602013-05-25 11:09:43 +0800379 if (!drv) {
380 return -ENOMEDIUM;
381 }
382 if (drv->bdrv_snapshot_list) {
383 return drv->bdrv_snapshot_list(bs, psn_info);
384 }
Max Reitzc8af8752019-06-12 18:21:07 +0200385 if (fallback_bs) {
386 return bdrv_snapshot_list(fallback_bs, psn_info);
Wenchao Xiade08c602013-05-25 11:09:43 +0800387 }
388 return -ENOTSUP;
389}
390
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800391/**
392 * Temporarily load an internal snapshot by @snapshot_id and @name.
393 * @bs: block device used in the operation
394 * @snapshot_id: unique snapshot ID, or NULL
395 * @name: snapshot name, or NULL
396 * @errp: location to store error
397 *
398 * If both @snapshot_id and @name are specified, load the first one with
399 * id @snapshot_id and name @name.
400 * If only @snapshot_id is specified, load the first one with id
401 * @snapshot_id.
402 * If only @name is specified, load the first one with name @name.
403 * if none is specified, return -EINVAL.
404 *
405 * Returns: 0 on success, -errno on fail. If @bs is not inserted, return
406 * -ENOMEDIUM. If @bs is not readonly, return -EINVAL. If @bs did not support
407 * internal snapshot, return -ENOTSUP. If qemu can't find a matching @id and
408 * @name, return -ENOENT. If @errp != NULL, it will always be filled on
409 * failure.
410 */
Wenchao Xiade08c602013-05-25 11:09:43 +0800411int bdrv_snapshot_load_tmp(BlockDriverState *bs,
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800412 const char *snapshot_id,
413 const char *name,
414 Error **errp)
Wenchao Xiade08c602013-05-25 11:09:43 +0800415{
416 BlockDriver *drv = bs->drv;
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800417
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500418 GLOBAL_STATE_CODE();
419
Wenchao Xiade08c602013-05-25 11:09:43 +0800420 if (!drv) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100421 error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, bdrv_get_device_name(bs));
Wenchao Xiade08c602013-05-25 11:09:43 +0800422 return -ENOMEDIUM;
423 }
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800424 if (!snapshot_id && !name) {
425 error_setg(errp, "snapshot_id and name are both NULL");
426 return -EINVAL;
427 }
Vladimir Sementsov-Ogievskiy307261b2021-05-27 18:40:54 +0300428 if (!bdrv_is_read_only(bs)) {
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800429 error_setg(errp, "Device is not readonly");
Wenchao Xiade08c602013-05-25 11:09:43 +0800430 return -EINVAL;
431 }
432 if (drv->bdrv_snapshot_load_tmp) {
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800433 return drv->bdrv_snapshot_load_tmp(bs, snapshot_id, name, errp);
Wenchao Xiade08c602013-05-25 11:09:43 +0800434 }
Alberto Garcia81e5f782015-04-08 12:29:19 +0300435 error_setg(errp, "Block format '%s' used by device '%s' "
436 "does not support temporarily loading internal snapshots",
437 drv->format_name, bdrv_get_device_name(bs));
Wenchao Xiade08c602013-05-25 11:09:43 +0800438 return -ENOTSUP;
439}
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800440
441int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs,
442 const char *id_or_name,
443 Error **errp)
444{
445 int ret;
446 Error *local_err = NULL;
447
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500448 GLOBAL_STATE_CODE();
449
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800450 ret = bdrv_snapshot_load_tmp(bs, id_or_name, NULL, &local_err);
451 if (ret == -ENOENT || ret == -EINVAL) {
452 error_free(local_err);
453 local_err = NULL;
454 ret = bdrv_snapshot_load_tmp(bs, NULL, id_or_name, &local_err);
455 }
456
Eduardo Habkost621ff942016-06-13 18:57:56 -0300457 error_propagate(errp, local_err);
Wenchao Xia7b4c4782013-12-04 17:10:54 +0800458
459 return ret;
460}
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300461
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000462
463static int bdrv_all_get_snapshot_devices(bool has_devices, strList *devices,
464 GList **all_bdrvs,
465 Error **errp)
466{
467 g_autoptr(GList) bdrvs = NULL;
468
469 if (has_devices) {
470 if (!devices) {
471 error_setg(errp, "At least one device is required for snapshot");
472 return -1;
473 }
474
475 while (devices) {
476 BlockDriverState *bs = bdrv_find_node(devices->value);
477 if (!bs) {
478 error_setg(errp, "No block device node '%s'", devices->value);
479 return -1;
480 }
481 bdrvs = g_list_append(bdrvs, bs);
482 devices = devices->next;
483 }
484 } else {
485 BlockDriverState *bs;
486 BdrvNextIterator it;
487 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
488 bdrvs = g_list_append(bdrvs, bs);
489 }
490 }
491
492 *all_bdrvs = g_steal_pointer(&bdrvs);
493 return 0;
494}
495
496
Kevin Wolf05f4ace2019-09-17 12:26:23 +0200497static bool bdrv_all_snapshots_includes_bs(BlockDriverState *bs)
498{
499 if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
500 return false;
501 }
502
503 /* Include all nodes that are either in use by a BlockBackend, or that
504 * aren't attached to any node, but owned by the monitor. */
505 return bdrv_has_blk(bs) || QLIST_EMPTY(&bs->parents);
506}
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300507
508/* Group operations. All block drivers are involved.
509 * These functions will properly handle dataplane (take aio_context_acquire
510 * when appropriate for appropriate block drivers) */
511
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000512bool bdrv_all_can_snapshot(bool has_devices, strList *devices,
513 Error **errp)
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300514{
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000515 g_autoptr(GList) bdrvs = NULL;
516 GList *iterbdrvs;
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300517
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500518 GLOBAL_STATE_CODE();
519
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000520 if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
521 return false;
522 }
523
524 iterbdrvs = bdrvs;
525 while (iterbdrvs) {
526 BlockDriverState *bs = iterbdrvs->data;
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300527 AioContext *ctx = bdrv_get_aio_context(bs);
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000528 bool ok = true;
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300529
530 aio_context_acquire(ctx);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000531 if (devices || bdrv_all_snapshots_includes_bs(bs)) {
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300532 ok = bdrv_can_snapshot(bs);
533 }
534 aio_context_release(ctx);
Kevin Wolf88be7b42016-05-20 18:49:07 +0200535 if (!ok) {
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000536 error_setg(errp, "Device '%s' is writable but does not support "
537 "snapshots", bdrv_get_device_or_node_name(bs));
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000538 return false;
Kevin Wolf88be7b42016-05-20 18:49:07 +0200539 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000540
541 iterbdrvs = iterbdrvs->next;
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300542 }
543
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000544 return true;
Denis V. Luneve9ff9572015-11-19 09:42:01 +0300545}
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300546
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000547int bdrv_all_delete_snapshot(const char *name,
548 bool has_devices, strList *devices,
549 Error **errp)
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300550{
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000551 g_autoptr(GList) bdrvs = NULL;
552 GList *iterbdrvs;
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300553
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500554 GLOBAL_STATE_CODE();
555
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000556 if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
557 return -1;
558 }
559
560 iterbdrvs = bdrvs;
561 while (iterbdrvs) {
562 BlockDriverState *bs = iterbdrvs->data;
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300563 AioContext *ctx = bdrv_get_aio_context(bs);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000564 QEMUSnapshotInfo sn1, *snapshot = &sn1;
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000565 int ret = 0;
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300566
567 aio_context_acquire(ctx);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000568 if ((devices || bdrv_all_snapshots_includes_bs(bs)) &&
Kevin Wolf05f4ace2019-09-17 12:26:23 +0200569 bdrv_snapshot_find(bs, snapshot, name) >= 0)
570 {
Daniel Henrique Barboza6ca08042018-11-07 11:09:58 -0200571 ret = bdrv_snapshot_delete(bs, snapshot->id_str,
Vladimir Sementsov-Ogievskiye53a5782019-12-05 20:46:24 +0300572 snapshot->name, errp);
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300573 }
574 aio_context_release(ctx);
Kevin Wolf88be7b42016-05-20 18:49:07 +0200575 if (ret < 0) {
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000576 error_prepend(errp, "Could not delete snapshot '%s' on '%s': ",
577 name, bdrv_get_device_or_node_name(bs));
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000578 return -1;
Kevin Wolf88be7b42016-05-20 18:49:07 +0200579 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000580
581 iterbdrvs = iterbdrvs->next;
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300582 }
583
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000584 return 0;
Denis V. Lunev9b00ea32015-11-19 09:42:03 +0300585}
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300586
587
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000588int bdrv_all_goto_snapshot(const char *name,
589 bool has_devices, strList *devices,
590 Error **errp)
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300591{
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000592 g_autoptr(GList) bdrvs = NULL;
593 GList *iterbdrvs;
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300594
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500595 GLOBAL_STATE_CODE();
596
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000597 if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
598 return -1;
599 }
600
601 iterbdrvs = bdrvs;
602 while (iterbdrvs) {
603 BlockDriverState *bs = iterbdrvs->data;
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300604 AioContext *ctx = bdrv_get_aio_context(bs);
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000605 int ret = 0;
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300606
607 aio_context_acquire(ctx);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000608 if (devices || bdrv_all_snapshots_includes_bs(bs)) {
Kevin Wolf2b624fe2017-11-20 15:36:48 +0100609 ret = bdrv_snapshot_goto(bs, name, errp);
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300610 }
611 aio_context_release(ctx);
Kevin Wolf2b624fe2017-11-20 15:36:48 +0100612 if (ret < 0) {
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000613 error_prepend(errp, "Could not load snapshot '%s' on '%s': ",
614 name, bdrv_get_device_or_node_name(bs));
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000615 return -1;
Kevin Wolf88be7b42016-05-20 18:49:07 +0200616 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000617
618 iterbdrvs = iterbdrvs->next;
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300619 }
620
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000621 return 0;
Denis V. Lunev4c1cdba2015-11-19 09:42:04 +0300622}
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300623
Daniel P. Berrangé3d3e9b12021-02-04 12:48:28 +0000624int bdrv_all_has_snapshot(const char *name,
625 bool has_devices, strList *devices,
626 Error **errp)
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300627{
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000628 g_autoptr(GList) bdrvs = NULL;
629 GList *iterbdrvs;
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300630
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500631 GLOBAL_STATE_CODE();
632
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000633 if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
634 return -1;
635 }
636
637 iterbdrvs = bdrvs;
638 while (iterbdrvs) {
639 BlockDriverState *bs = iterbdrvs->data;
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300640 AioContext *ctx = bdrv_get_aio_context(bs);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000641 QEMUSnapshotInfo sn;
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000642 int ret = 0;
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300643
644 aio_context_acquire(ctx);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000645 if (devices || bdrv_all_snapshots_includes_bs(bs)) {
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000646 ret = bdrv_snapshot_find(bs, &sn, name);
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300647 }
648 aio_context_release(ctx);
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000649 if (ret < 0) {
Daniel P. Berrangé3d3e9b12021-02-04 12:48:28 +0000650 if (ret == -ENOENT) {
651 return 0;
652 } else {
653 error_setg_errno(errp, errno,
654 "Could not check snapshot '%s' on '%s'",
655 name, bdrv_get_device_or_node_name(bs));
656 return -1;
657 }
Kevin Wolf88be7b42016-05-20 18:49:07 +0200658 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000659
660 iterbdrvs = iterbdrvs->next;
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300661 }
662
Daniel P. Berrangé3d3e9b12021-02-04 12:48:28 +0000663 return 1;
Denis V. Lunev723ccda2015-11-19 09:42:06 +0300664}
Denis V. Luneva9085f92015-11-19 09:42:08 +0300665
666int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn,
667 BlockDriverState *vm_state_bs,
668 uint64_t vm_state_size,
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000669 bool has_devices, strList *devices,
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000670 Error **errp)
Denis V. Luneva9085f92015-11-19 09:42:08 +0300671{
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000672 g_autoptr(GList) bdrvs = NULL;
673 GList *iterbdrvs;
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500674 GLOBAL_STATE_CODE();
Denis V. Luneva9085f92015-11-19 09:42:08 +0300675
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000676 if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
677 return -1;
678 }
679
680 iterbdrvs = bdrvs;
681 while (iterbdrvs) {
682 BlockDriverState *bs = iterbdrvs->data;
Denis V. Luneva9085f92015-11-19 09:42:08 +0300683 AioContext *ctx = bdrv_get_aio_context(bs);
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000684 int ret = 0;
Denis V. Luneva9085f92015-11-19 09:42:08 +0300685
686 aio_context_acquire(ctx);
687 if (bs == vm_state_bs) {
688 sn->vm_state_size = vm_state_size;
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000689 ret = bdrv_snapshot_create(bs, sn);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000690 } else if (devices || bdrv_all_snapshots_includes_bs(bs)) {
Denis V. Luneva9085f92015-11-19 09:42:08 +0300691 sn->vm_state_size = 0;
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000692 ret = bdrv_snapshot_create(bs, sn);
Denis V. Luneva9085f92015-11-19 09:42:08 +0300693 }
694 aio_context_release(ctx);
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000695 if (ret < 0) {
696 error_setg(errp, "Could not create snapshot '%s' on '%s'",
697 sn->name, bdrv_get_device_or_node_name(bs));
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000698 return -1;
Kevin Wolf88be7b42016-05-20 18:49:07 +0200699 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000700
701 iterbdrvs = iterbdrvs->next;
Denis V. Luneva9085f92015-11-19 09:42:08 +0300702 }
703
Daniel P. Berrangée26f98e2021-02-04 12:48:23 +0000704 return 0;
Denis V. Luneva9085f92015-11-19 09:42:08 +0300705}
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300706
Daniel P. Berrangéc22d6442021-02-04 12:48:27 +0000707
708BlockDriverState *bdrv_all_find_vmstate_bs(const char *vmstate_bs,
709 bool has_devices, strList *devices,
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000710 Error **errp)
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300711{
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000712 g_autoptr(GList) bdrvs = NULL;
713 GList *iterbdrvs;
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300714
Emanuele Giuseppe Esposito6b573ef2022-03-03 10:16:07 -0500715 GLOBAL_STATE_CODE();
716
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000717 if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
718 return NULL;
719 }
720
721 iterbdrvs = bdrvs;
722 while (iterbdrvs) {
723 BlockDriverState *bs = iterbdrvs->data;
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300724 AioContext *ctx = bdrv_get_aio_context(bs);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000725 bool found = false;
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300726
727 aio_context_acquire(ctx);
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000728 found = (devices || bdrv_all_snapshots_includes_bs(bs)) &&
729 bdrv_can_snapshot(bs);
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300730 aio_context_release(ctx);
Kevin Wolf88be7b42016-05-20 18:49:07 +0200731
Daniel P. Berrangéc22d6442021-02-04 12:48:27 +0000732 if (vmstate_bs) {
733 if (g_str_equal(vmstate_bs,
734 bdrv_get_node_name(bs))) {
735 if (found) {
736 return bs;
737 } else {
738 error_setg(errp,
739 "vmstate block device '%s' does not support snapshots",
740 vmstate_bs);
741 return NULL;
742 }
743 }
744 } else if (found) {
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000745 return bs;
Kevin Wolf88be7b42016-05-20 18:49:07 +0200746 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000747
748 iterbdrvs = iterbdrvs->next;
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300749 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000750
Daniel P. Berrangéc22d6442021-02-04 12:48:27 +0000751 if (vmstate_bs) {
752 error_setg(errp,
753 "vmstate block device '%s' does not exist", vmstate_bs);
754 } else {
755 error_setg(errp,
756 "no block device can store vmstate for snapshot");
757 }
Daniel P. Berrangécf3a74c2021-02-04 12:48:26 +0000758 return NULL;
Denis V. Lunev7cb14482015-11-19 09:42:10 +0300759}