Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging
[qemu/ar7.git] / block / snapshot.c
blobe8ae9a28c110d8f5c21bbea0a8473bc0842e3438
1 /*
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  */
25 #include "qemu/osdep.h"
26 #include "block/snapshot.h"
27 #include "block/block_int.h"
28 #include "block/qdict.h"
29 #include "qapi/error.h"
30 #include "qapi/qmp/qdict.h"
31 #include "qapi/qmp/qerror.h"
32 #include "qapi/qmp/qstring.h"
33 #include "qemu/option.h"
34 #include "sysemu/block-backend.h"
36 QemuOptsList 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     },
54 int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
55                        const char *name)
57     QEMUSnapshotInfo *sn_tab, *sn;
58     int nb_sns, i, ret;
60     ret = -ENOENT;
61     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
62     if (nb_sns < 0) {
63         return ret;
64     }
65     for (i = 0; i < nb_sns; i++) {
66         sn = &sn_tab[i];
67         if (!strcmp(sn->name, name)) {
68             *sn_info = *sn;
69             ret = 0;
70             break;
71         }
72     }
73     g_free(sn_tab);
74     return ret;
77 /**
78  * Look up an internal snapshot by @id and @name.
79  * @bs: block device to search
80  * @id: unique snapshot ID, or NULL
81  * @name: snapshot name, or NULL
82  * @sn_info: location to store information on the snapshot found
83  * @errp: location to store error, will be set only for exception
84  *
85  * This function will traverse snapshot list in @bs to search the matching
86  * one, @id and @name are the matching condition:
87  * If both @id and @name are specified, find the first one with id @id and
88  * name @name.
89  * If only @id is specified, find the first one with id @id.
90  * If only @name is specified, find the first one with name @name.
91  * if none is specified, abort().
92  *
93  * Returns: true when a snapshot is found and @sn_info will be filled, false
94  * when error or not found. If all operation succeed but no matching one is
95  * found, @errp will NOT be set.
96  */
97 bool bdrv_snapshot_find_by_id_and_name(BlockDriverState *bs,
98                                        const char *id,
99                                        const char *name,
100                                        QEMUSnapshotInfo *sn_info,
101                                        Error **errp)
103     QEMUSnapshotInfo *sn_tab, *sn;
104     int nb_sns, i;
105     bool ret = false;
107     assert(id || name);
109     nb_sns = bdrv_snapshot_list(bs, &sn_tab);
110     if (nb_sns < 0) {
111         error_setg_errno(errp, -nb_sns, "Failed to get a snapshot list");
112         return false;
113     } else if (nb_sns == 0) {
114         return false;
115     }
117     if (id && name) {
118         for (i = 0; i < nb_sns; i++) {
119             sn = &sn_tab[i];
120             if (!strcmp(sn->id_str, id) && !strcmp(sn->name, name)) {
121                 *sn_info = *sn;
122                 ret = true;
123                 break;
124             }
125         }
126     } else if (id) {
127         for (i = 0; i < nb_sns; i++) {
128             sn = &sn_tab[i];
129             if (!strcmp(sn->id_str, id)) {
130                 *sn_info = *sn;
131                 ret = true;
132                 break;
133             }
134         }
135     } else if (name) {
136         for (i = 0; i < nb_sns; i++) {
137             sn = &sn_tab[i];
138             if (!strcmp(sn->name, name)) {
139                 *sn_info = *sn;
140                 ret = true;
141                 break;
142             }
143         }
144     }
146     g_free(sn_tab);
147     return ret;
151  * Return a pointer to the child BDS pointer to which we can fall
152  * back if the given BDS does not support snapshots.
153  * Return NULL if there is no BDS to (safely) fall back to.
155  * We need to return an indirect pointer because bdrv_snapshot_goto()
156  * has to modify the BdrvChild pointer.
157  */
158 static BdrvChild **bdrv_snapshot_fallback_ptr(BlockDriverState *bs)
160     BdrvChild **fallback;
161     BdrvChild *child;
163     /*
164      * The only BdrvChild pointers that are safe to modify (and which
165      * we can thus return a reference to) are bs->file and
166      * bs->backing.
167      */
168     fallback = &bs->file;
169     if (!*fallback && bs->drv && bs->drv->is_filter) {
170         fallback = &bs->backing;
171     }
173     if (!*fallback) {
174         return NULL;
175     }
177     /*
178      * Check that there are no other children that would need to be
179      * snapshotted.  If there are, it is not safe to fall back to
180      * *fallback.
181      */
182     QLIST_FOREACH(child, &bs->children, next) {
183         if (child->role & (BDRV_CHILD_DATA | BDRV_CHILD_METADATA |
184                            BDRV_CHILD_FILTERED) &&
185             child != *fallback)
186         {
187             return NULL;
188         }
189     }
191     return fallback;
194 static BlockDriverState *bdrv_snapshot_fallback(BlockDriverState *bs)
196     BdrvChild **child_ptr = bdrv_snapshot_fallback_ptr(bs);
197     return child_ptr ? (*child_ptr)->bs : NULL;
200 int bdrv_can_snapshot(BlockDriverState *bs)
202     BlockDriver *drv = bs->drv;
203     if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
204         return 0;
205     }
207     if (!drv->bdrv_snapshot_create) {
208         BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
209         if (fallback_bs) {
210             return bdrv_can_snapshot(fallback_bs);
211         }
212         return 0;
213     }
215     return 1;
218 int bdrv_snapshot_create(BlockDriverState *bs,
219                          QEMUSnapshotInfo *sn_info)
221     BlockDriver *drv = bs->drv;
222     BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
223     if (!drv) {
224         return -ENOMEDIUM;
225     }
226     if (drv->bdrv_snapshot_create) {
227         return drv->bdrv_snapshot_create(bs, sn_info);
228     }
229     if (fallback_bs) {
230         return bdrv_snapshot_create(fallback_bs, sn_info);
231     }
232     return -ENOTSUP;
235 int bdrv_snapshot_goto(BlockDriverState *bs,
236                        const char *snapshot_id,
237                        Error **errp)
239     BlockDriver *drv = bs->drv;
240     BdrvChild **fallback_ptr;
241     int ret, open_ret;
243     if (!drv) {
244         error_setg(errp, "Block driver is closed");
245         return -ENOMEDIUM;
246     }
248     if (!QLIST_EMPTY(&bs->dirty_bitmaps)) {
249         error_setg(errp, "Device has active dirty bitmaps");
250         return -EBUSY;
251     }
253     if (drv->bdrv_snapshot_goto) {
254         ret = drv->bdrv_snapshot_goto(bs, snapshot_id);
255         if (ret < 0) {
256             error_setg_errno(errp, -ret, "Failed to load snapshot");
257         }
258         return ret;
259     }
261     fallback_ptr = bdrv_snapshot_fallback_ptr(bs);
262     if (fallback_ptr) {
263         QDict *options;
264         QDict *file_options;
265         Error *local_err = NULL;
266         BlockDriverState *fallback_bs = (*fallback_ptr)->bs;
267         char *subqdict_prefix = g_strdup_printf("%s.", (*fallback_ptr)->name);
269         options = qdict_clone_shallow(bs->options);
271         /* Prevent it from getting deleted when detached from bs */
272         bdrv_ref(fallback_bs);
274         qdict_extract_subqdict(options, &file_options, subqdict_prefix);
275         qobject_unref(file_options);
276         g_free(subqdict_prefix);
278         qdict_put_str(options, (*fallback_ptr)->name,
279                       bdrv_get_node_name(fallback_bs));
281         if (drv->bdrv_close) {
282             drv->bdrv_close(bs);
283         }
285         bdrv_unref_child(bs, *fallback_ptr);
286         *fallback_ptr = NULL;
288         ret = bdrv_snapshot_goto(fallback_bs, snapshot_id, errp);
289         open_ret = drv->bdrv_open(bs, options, bs->open_flags, &local_err);
290         qobject_unref(options);
291         if (open_ret < 0) {
292             bdrv_unref(fallback_bs);
293             bs->drv = NULL;
294             /* A bdrv_snapshot_goto() error takes precedence */
295             error_propagate(errp, local_err);
296             return ret < 0 ? ret : open_ret;
297         }
299         assert(fallback_bs == (*fallback_ptr)->bs);
300         bdrv_unref(fallback_bs);
301         return ret;
302     }
304     error_setg(errp, "Block driver does not support snapshots");
305     return -ENOTSUP;
309  * Delete an internal snapshot by @snapshot_id and @name.
310  * @bs: block device used in the operation
311  * @snapshot_id: unique snapshot ID, or NULL
312  * @name: snapshot name, or NULL
313  * @errp: location to store error
315  * If both @snapshot_id and @name are specified, delete the first one with
316  * id @snapshot_id and name @name.
317  * If only @snapshot_id is specified, delete the first one with id
318  * @snapshot_id.
319  * If only @name is specified, delete the first one with name @name.
320  * if none is specified, return -EINVAL.
322  * Returns: 0 on success, -errno on failure. If @bs is not inserted, return
323  * -ENOMEDIUM. If @snapshot_id and @name are both NULL, return -EINVAL. If @bs
324  * does not support internal snapshot deletion, return -ENOTSUP. If @bs does
325  * not support parameter @snapshot_id or @name, or one of them is not correctly
326  * specified, return -EINVAL. If @bs can't find one matching @id and @name,
327  * return -ENOENT. If @errp != NULL, it will always be filled with error
328  * message on failure.
329  */
330 int bdrv_snapshot_delete(BlockDriverState *bs,
331                          const char *snapshot_id,
332                          const char *name,
333                          Error **errp)
335     BlockDriver *drv = bs->drv;
336     BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
337     int ret;
339     if (!drv) {
340         error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, bdrv_get_device_name(bs));
341         return -ENOMEDIUM;
342     }
343     if (!snapshot_id && !name) {
344         error_setg(errp, "snapshot_id and name are both NULL");
345         return -EINVAL;
346     }
348     /* drain all pending i/o before deleting snapshot */
349     bdrv_drained_begin(bs);
351     if (drv->bdrv_snapshot_delete) {
352         ret = drv->bdrv_snapshot_delete(bs, snapshot_id, name, errp);
353     } else if (fallback_bs) {
354         ret = bdrv_snapshot_delete(fallback_bs, snapshot_id, name, errp);
355     } else {
356         error_setg(errp, "Block format '%s' used by device '%s' "
357                    "does not support internal snapshot deletion",
358                    drv->format_name, bdrv_get_device_name(bs));
359         ret = -ENOTSUP;
360     }
362     bdrv_drained_end(bs);
363     return ret;
366 int bdrv_snapshot_list(BlockDriverState *bs,
367                        QEMUSnapshotInfo **psn_info)
369     BlockDriver *drv = bs->drv;
370     BlockDriverState *fallback_bs = bdrv_snapshot_fallback(bs);
371     if (!drv) {
372         return -ENOMEDIUM;
373     }
374     if (drv->bdrv_snapshot_list) {
375         return drv->bdrv_snapshot_list(bs, psn_info);
376     }
377     if (fallback_bs) {
378         return bdrv_snapshot_list(fallback_bs, psn_info);
379     }
380     return -ENOTSUP;
384  * Temporarily load an internal snapshot by @snapshot_id and @name.
385  * @bs: block device used in the operation
386  * @snapshot_id: unique snapshot ID, or NULL
387  * @name: snapshot name, or NULL
388  * @errp: location to store error
390  * If both @snapshot_id and @name are specified, load the first one with
391  * id @snapshot_id and name @name.
392  * If only @snapshot_id is specified, load the first one with id
393  * @snapshot_id.
394  * If only @name is specified, load the first one with name @name.
395  * if none is specified, return -EINVAL.
397  * Returns: 0 on success, -errno on fail. If @bs is not inserted, return
398  * -ENOMEDIUM. If @bs is not readonly, return -EINVAL. If @bs did not support
399  * internal snapshot, return -ENOTSUP. If qemu can't find a matching @id and
400  * @name, return -ENOENT. If @errp != NULL, it will always be filled on
401  * failure.
402  */
403 int bdrv_snapshot_load_tmp(BlockDriverState *bs,
404                            const char *snapshot_id,
405                            const char *name,
406                            Error **errp)
408     BlockDriver *drv = bs->drv;
410     if (!drv) {
411         error_setg(errp, QERR_DEVICE_HAS_NO_MEDIUM, bdrv_get_device_name(bs));
412         return -ENOMEDIUM;
413     }
414     if (!snapshot_id && !name) {
415         error_setg(errp, "snapshot_id and name are both NULL");
416         return -EINVAL;
417     }
418     if (!bs->read_only) {
419         error_setg(errp, "Device is not readonly");
420         return -EINVAL;
421     }
422     if (drv->bdrv_snapshot_load_tmp) {
423         return drv->bdrv_snapshot_load_tmp(bs, snapshot_id, name, errp);
424     }
425     error_setg(errp, "Block format '%s' used by device '%s' "
426                "does not support temporarily loading internal snapshots",
427                drv->format_name, bdrv_get_device_name(bs));
428     return -ENOTSUP;
431 int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs,
432                                          const char *id_or_name,
433                                          Error **errp)
435     int ret;
436     Error *local_err = NULL;
438     ret = bdrv_snapshot_load_tmp(bs, id_or_name, NULL, &local_err);
439     if (ret == -ENOENT || ret == -EINVAL) {
440         error_free(local_err);
441         local_err = NULL;
442         ret = bdrv_snapshot_load_tmp(bs, NULL, id_or_name, &local_err);
443     }
445     error_propagate(errp, local_err);
447     return ret;
451 static int bdrv_all_get_snapshot_devices(bool has_devices, strList *devices,
452                                          GList **all_bdrvs,
453                                          Error **errp)
455     g_autoptr(GList) bdrvs = NULL;
457     if (has_devices) {
458         if (!devices) {
459             error_setg(errp, "At least one device is required for snapshot");
460             return -1;
461         }
463         while (devices) {
464             BlockDriverState *bs = bdrv_find_node(devices->value);
465             if (!bs) {
466                 error_setg(errp, "No block device node '%s'", devices->value);
467                 return -1;
468             }
469             bdrvs = g_list_append(bdrvs, bs);
470             devices = devices->next;
471         }
472     } else {
473         BlockDriverState *bs;
474         BdrvNextIterator it;
475         for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
476             bdrvs = g_list_append(bdrvs, bs);
477         }
478     }
480     *all_bdrvs = g_steal_pointer(&bdrvs);
481     return 0;
485 static bool bdrv_all_snapshots_includes_bs(BlockDriverState *bs)
487     if (!bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
488         return false;
489     }
491     /* Include all nodes that are either in use by a BlockBackend, or that
492      * aren't attached to any node, but owned by the monitor. */
493     return bdrv_has_blk(bs) || QLIST_EMPTY(&bs->parents);
496 /* Group operations. All block drivers are involved.
497  * These functions will properly handle dataplane (take aio_context_acquire
498  * when appropriate for appropriate block drivers) */
500 bool bdrv_all_can_snapshot(bool has_devices, strList *devices,
501                            Error **errp)
503     g_autoptr(GList) bdrvs = NULL;
504     GList *iterbdrvs;
506     if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
507         return false;
508     }
510     iterbdrvs = bdrvs;
511     while (iterbdrvs) {
512         BlockDriverState *bs = iterbdrvs->data;
513         AioContext *ctx = bdrv_get_aio_context(bs);
514         bool ok = true;
516         aio_context_acquire(ctx);
517         if (devices || bdrv_all_snapshots_includes_bs(bs)) {
518             ok = bdrv_can_snapshot(bs);
519         }
520         aio_context_release(ctx);
521         if (!ok) {
522             error_setg(errp, "Device '%s' is writable but does not support "
523                        "snapshots", bdrv_get_device_or_node_name(bs));
524             return false;
525         }
527         iterbdrvs = iterbdrvs->next;
528     }
530     return true;
533 int bdrv_all_delete_snapshot(const char *name,
534                              bool has_devices, strList *devices,
535                              Error **errp)
537     g_autoptr(GList) bdrvs = NULL;
538     GList *iterbdrvs;
540     if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
541         return -1;
542     }
544     iterbdrvs = bdrvs;
545     while (iterbdrvs) {
546         BlockDriverState *bs = iterbdrvs->data;
547         AioContext *ctx = bdrv_get_aio_context(bs);
548         QEMUSnapshotInfo sn1, *snapshot = &sn1;
549         int ret = 0;
551         aio_context_acquire(ctx);
552         if ((devices || bdrv_all_snapshots_includes_bs(bs)) &&
553             bdrv_snapshot_find(bs, snapshot, name) >= 0)
554         {
555             ret = bdrv_snapshot_delete(bs, snapshot->id_str,
556                                        snapshot->name, errp);
557         }
558         aio_context_release(ctx);
559         if (ret < 0) {
560             error_prepend(errp, "Could not delete snapshot '%s' on '%s': ",
561                           name, bdrv_get_device_or_node_name(bs));
562             return -1;
563         }
565         iterbdrvs = iterbdrvs->next;
566     }
568     return 0;
572 int bdrv_all_goto_snapshot(const char *name,
573                            bool has_devices, strList *devices,
574                            Error **errp)
576     g_autoptr(GList) bdrvs = NULL;
577     GList *iterbdrvs;
579     if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
580         return -1;
581     }
583     iterbdrvs = bdrvs;
584     while (iterbdrvs) {
585         BlockDriverState *bs = iterbdrvs->data;
586         AioContext *ctx = bdrv_get_aio_context(bs);
587         int ret = 0;
589         aio_context_acquire(ctx);
590         if (devices || bdrv_all_snapshots_includes_bs(bs)) {
591             ret = bdrv_snapshot_goto(bs, name, errp);
592         }
593         aio_context_release(ctx);
594         if (ret < 0) {
595             error_prepend(errp, "Could not load snapshot '%s' on '%s': ",
596                           name, bdrv_get_device_or_node_name(bs));
597             return -1;
598         }
600         iterbdrvs = iterbdrvs->next;
601     }
603     return 0;
606 int bdrv_all_has_snapshot(const char *name,
607                           bool has_devices, strList *devices,
608                           Error **errp)
610     g_autoptr(GList) bdrvs = NULL;
611     GList *iterbdrvs;
613     if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
614         return -1;
615     }
617     iterbdrvs = bdrvs;
618     while (iterbdrvs) {
619         BlockDriverState *bs = iterbdrvs->data;
620         AioContext *ctx = bdrv_get_aio_context(bs);
621         QEMUSnapshotInfo sn;
622         int ret = 0;
624         aio_context_acquire(ctx);
625         if (devices || bdrv_all_snapshots_includes_bs(bs)) {
626             ret = bdrv_snapshot_find(bs, &sn, name);
627         }
628         aio_context_release(ctx);
629         if (ret < 0) {
630             if (ret == -ENOENT) {
631                 return 0;
632             } else {
633                 error_setg_errno(errp, errno,
634                                  "Could not check snapshot '%s' on '%s'",
635                                  name, bdrv_get_device_or_node_name(bs));
636                 return -1;
637             }
638         }
640         iterbdrvs = iterbdrvs->next;
641     }
643     return 1;
646 int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn,
647                              BlockDriverState *vm_state_bs,
648                              uint64_t vm_state_size,
649                              bool has_devices, strList *devices,
650                              Error **errp)
652     g_autoptr(GList) bdrvs = NULL;
653     GList *iterbdrvs;
655     if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
656         return -1;
657     }
659     iterbdrvs = bdrvs;
660     while (iterbdrvs) {
661         BlockDriverState *bs = iterbdrvs->data;
662         AioContext *ctx = bdrv_get_aio_context(bs);
663         int ret = 0;
665         aio_context_acquire(ctx);
666         if (bs == vm_state_bs) {
667             sn->vm_state_size = vm_state_size;
668             ret = bdrv_snapshot_create(bs, sn);
669         } else if (devices || bdrv_all_snapshots_includes_bs(bs)) {
670             sn->vm_state_size = 0;
671             ret = bdrv_snapshot_create(bs, sn);
672         }
673         aio_context_release(ctx);
674         if (ret < 0) {
675             error_setg(errp, "Could not create snapshot '%s' on '%s'",
676                        sn->name, bdrv_get_device_or_node_name(bs));
677             return -1;
678         }
680         iterbdrvs = iterbdrvs->next;
681     }
683     return 0;
687 BlockDriverState *bdrv_all_find_vmstate_bs(const char *vmstate_bs,
688                                            bool has_devices, strList *devices,
689                                            Error **errp)
691     g_autoptr(GList) bdrvs = NULL;
692     GList *iterbdrvs;
694     if (bdrv_all_get_snapshot_devices(has_devices, devices, &bdrvs, errp) < 0) {
695         return NULL;
696     }
698     iterbdrvs = bdrvs;
699     while (iterbdrvs) {
700         BlockDriverState *bs = iterbdrvs->data;
701         AioContext *ctx = bdrv_get_aio_context(bs);
702         bool found = false;
704         aio_context_acquire(ctx);
705         found = (devices || bdrv_all_snapshots_includes_bs(bs)) &&
706             bdrv_can_snapshot(bs);
707         aio_context_release(ctx);
709         if (vmstate_bs) {
710             if (g_str_equal(vmstate_bs,
711                             bdrv_get_node_name(bs))) {
712                 if (found) {
713                     return bs;
714                 } else {
715                     error_setg(errp,
716                                "vmstate block device '%s' does not support snapshots",
717                                vmstate_bs);
718                     return NULL;
719                 }
720             }
721         } else if (found) {
722             return bs;
723         }
725         iterbdrvs = iterbdrvs->next;
726     }
728     if (vmstate_bs) {
729         error_setg(errp,
730                    "vmstate block device '%s' does not exist", vmstate_bs);
731     } else {
732         error_setg(errp,
733                    "no block device can store vmstate for snapshot");
734     }
735     return NULL;