dataplane snapshot fixes
v10 cover dataplane snapshot fixes
with test
while /bin/true ; do
virsh snapshot-create rhel7
sleep 10
virsh snapshot-delete rhel7 --current
done
with enabled iothreads on a running VM leads to a lot of troubles: hangs, asserts, errors.
Anyway, I think that the construction like
assert(aio_context_is_locked(aio_context));
should be widely used to ensure proper locking.
Changes from v9:
- used proper BlockDriverState/AioContext in load_vmstate
Changes from v8:
- split patch 5 into 2 separate patches making changes better to understand and review
Changes from v7:
- patch 5: fixes for bdrv_all_find_snapshot. Changed parameter name to skip_read_only which better reflects the meaning of the value and fixed checks inside to conform the note from Stefan
Changes from v6:
- tricky part dropped from patch 7
- patch 5 reworked to process snapshot list differently in info commands and on savevm
Changes from v5:
- dropped already merged patch 11
- fixed spelling in patch 1
- changed order of condition in loops in all patches. Thank you Stefan
- dropped patch 9
- aio_context is not acquired any more in bdrv_all_find_vmstate_bs by request of Stefan
- patch 10 is implemented in completely different way
Changes from v4:
- only migration/savevm.c code and monitor is affected now. Generic block layer stuff will be sent separately to speedup merging. The approach in general was negotiated with Juan and Stefan.
Changes from v3:
- more places found
- new aio_poll concept, see patch 10
Changes from v2:
- droppped patch 5 as already merged
- changed locking scheme in patch 4 by suggestion of Juan
Changes from v1:
- aio-context locking added
- comment is rewritten
Denis V. Lunev (10):
snapshot: create helper to test that block drivers supports snapshots
snapshot: return error code from bdrv_snapshot_delete_by_id_or_name
snapshot: create bdrv_all_delete_snapshot helper
snapshot: create bdrv_all_goto_snapshot helper
snapshot: create bdrv_all_find_snapshot helper
migration: drop find_vmstate_bs check in hmp_delvm
snapshot: create bdrv_all_create_snapshot helper
migration: reorder processing in hmp_savevm
migration: implement bdrv_all_find_vmstate_bs helper
migration: normalize locking in migration/savevm.c
block/snapshot.c | 135 ++++++++++++++++++++++++++++++- include/block/snapshot.h | 25 +++++- migration/savevm.c | 207 +++++++++++++++-------------------------------- 3 files changed, 217 insertions(+), 150 deletions(-)
Signature · 1 line
2.5.0
PATCH 1/11 snapshot: create helper to test that block drivers supports snapshots
The patch enforces proper locking for this operation.
--- block/snapshot.c | 24 ++++++++++++++++++++++++ include/block/snapshot.h | 8 ++++++++ migration/savevm.c | 17 ++++------------- 3 files changed, 36 insertions(+), 13 deletions(-)
block/snapshot.c +24 -0
@@ -356,3 +356,27 @@ int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs,return ret; } + + +/* Group operations. All block drivers are involved. +* These functions will properly handle dataplane (take aio_context_acquire +* when appropriate for appropriate block drivers) */ + +bool bdrv_all_can_snapshot (BlockDriverState **first_bad_bs) +{ +bool ok = true; +BlockDriverState *bs =NULL ; + +while (ok && (bs =bdrv_next (bs))) { +AioContext *ctx =bdrv_get_aio_context (bs); + +aio_context_acquire (ctx); +if (bdrv_is_inserted (bs) && !bdrv_is_read_only (bs)) { + ok =bdrv_can_snapshot (bs); + } +aio_context_release (ctx); + } + + *first_bad_bs = bs; +return ok; +}
include/block/snapshot.h +8 -0
@@ -75,4 +75,12 @@ int bdrv_snapshot_load_tmp(BlockDriverState *bs,int bdrv_snapshot_load_tmp_by_id_or_name (BlockDriverState *bs,const char *id_or_name,Error **errp); + + +/* Group operations. All block drivers are involved. +* These functions will properly handle dataplane (take aio_context_acquire +* when appropriate for appropriate block drivers */ + +bool bdrv_all_can_snapshot (BlockDriverState **first_bad_bs); +#endif
migration/savevm.c +4 -13
@@ -1958,19 +1958,10 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)const char *name =qdict_get_try_str (qdict,"name" );Error *local_err =NULL ; -/* Verify if there is a device that doesn't support snapshots and is writable */ - bs =NULL ; -while ((bs =bdrv_next (bs))) { - -if (!bdrv_is_inserted (bs) ||bdrv_is_read_only (bs)) { -continue ; - } - -if (!bdrv_can_snapshot (bs)) { -monitor_printf (mon,"Device '%s' is writable but does not support snapshots.\n" , -bdrv_get_device_name (bs)); -return ; - } +if (!bdrv_all_can_snapshot (&bs)) { +monitor_printf (mon,"Device '%s' is writable but does not " +"support snapshots.\n" ,bdrv_get_device_name (bs)); +return ; } bs =find_vmstate_bs ();
Signature · 1 line
2.5.0
PATCH 2/11 snapshot: return error code from bdrv_snapshot_delete_by_id_or_name
In reply to Denis V. Lunevthis will make code better in the next patch
--- block/snapshot.c | 7 ++++--- include/block/snapshot.h | 6 +++--- 2 files changed, 7 insertions(+), 6 deletions(-)
block/snapshot.c +4 -3
@@ -253,9 +253,9 @@ int bdrv_snapshot_delete(BlockDriverState *bs,return -ENOTSUP ; } -void bdrv_snapshot_delete_by_id_or_name (BlockDriverState *bs, -const char *id_or_name, -Error **errp) +int bdrv_snapshot_delete_by_id_or_name (BlockDriverState *bs, +const char *id_or_name, +Error **errp) {int ret;Error *local_err =NULL ;
@@ -270,6 +270,7 @@ void bdrv_snapshot_delete_by_id_or_name(BlockDriverState *bs,if (ret <0 ) {error_propagate (errp, local_err); } +return ret; } int bdrv_snapshot_list(BlockDriverState *bs,
include/block/snapshot.h +3 -3
@@ -63,9 +63,9 @@ int bdrv_snapshot_delete(BlockDriverState *bs,const char *snapshot_id, const char *name, Error **errp); -void bdrv_snapshot_delete_by_id_or_name (BlockDriverState *bs, -const char *id_or_name, -Error **errp); +int bdrv_snapshot_delete_by_id_or_name (BlockDriverState *bs, +const char *id_or_name, +Error **errp);int bdrv_snapshot_list (BlockDriverState *bs,QEMUSnapshotInfo **psn_info); int bdrv_snapshot_load_tmp(BlockDriverState *bs,
Signature · 1 line
2.5.0
PATCH 3/11 snapshot: create bdrv_all_delete_snapshot helper
In reply to Denis V. Lunevto delete snapshots from all loaded block drivers.
The patch also ensures proper locking.
--- block/snapshot.c | 22 ++++++++++++++++++++ include/block/snapshot.h | 2 ++ migration/savevm.c | 54 +++++++++--------------------------------------- 3 files changed, 34 insertions(+), 44 deletions(-)
block/snapshot.c +22 -0
@@ -381,3 +381,25 @@ bool bdrv_all_can_snapshot(BlockDriverState **first_bad_bs) *first_bad_bs = bs;return ok; } + +int bdrv_all_delete_snapshot (const char *name,BlockDriverState **first_bad_bs, +Error **err) +{ +int ret =0 ; +BlockDriverState *bs =NULL ; +QEMUSnapshotInfo sn1, *snapshot = &sn1; + +while (ret ==0 && (bs =bdrv_next (bs))) { +AioContext *ctx =bdrv_get_aio_context (bs); + +aio_context_acquire (ctx); +if (bdrv_can_snapshot (bs) && +bdrv_snapshot_find (bs, snapshot, name) >=0 ) { + ret =bdrv_snapshot_delete_by_id_or_name (bs, name, err); + } +aio_context_release (ctx); + } + + *first_bad_bs = bs; +return ret; +}
include/block/snapshot.h +2 -0
@@ -82,5 +82,7 @@ int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs,* when appropriate for appropriate block drivers */ bool bdrv_all_can_snapshot (BlockDriverState **first_bad_bs); +int bdrv_all_delete_snapshot (const char *name,BlockDriverState **first_bsd_bs, +Error **err);#endif
migration/savevm.c +10 -44
72 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 4/11 snapshot: create bdrv_all_goto_snapshot helper
In reply to Denis V. Lunevto switch to snapshot on all loaded block drivers.
The patch also ensures proper locking.
--- block/snapshot.c | 20 ++++++++++++++++++++ include/block/snapshot.h | 1 + migration/savevm.c | 15 +++++---------- 3 files changed, 26 insertions(+), 10 deletions(-)
block/snapshot.c +20 -0
@@ -403,3 +403,23 @@ int bdrv_all_delete_snapshot(const char *name, BlockDriverState **first_bad_bs, *first_bad_bs = bs;return ret; } + + +int bdrv_all_goto_snapshot (const char *name,BlockDriverState **first_bad_bs) +{ +int err =0 ; +BlockDriverState *bs =NULL ; + +while (err ==0 && (bs =bdrv_next (bs))) { +AioContext *ctx =bdrv_get_aio_context (bs); + +aio_context_acquire (ctx); +if (bdrv_can_snapshot (bs)) { + err =bdrv_snapshot_goto (bs, name); + } +aio_context_release (ctx); + } + + *first_bad_bs = bs; +return err; +}
include/block/snapshot.h +1 -0
@@ -84,5 +84,6 @@ int bdrv_snapshot_load_tmp_by_id_or_name(BlockDriverState *bs,bool bdrv_all_can_snapshot (BlockDriverState **first_bad_bs);int bdrv_all_delete_snapshot (const char *name,BlockDriverState **first_bsd_bs,Error **err); +int bdrv_all_goto_snapshot (const char *name,BlockDriverState **first_bsd_bs);#endif
migration/savevm.c +5 -10
@@ -2093,16 +2093,11 @@ int load_vmstate(const char *name)/* Flush all IO requests so they don't interfere with the new state. */ bdrv_drain_all (); - bs =NULL ; -while ((bs =bdrv_next (bs))) { -if (bdrv_can_snapshot (bs)) { - ret =bdrv_snapshot_goto (bs, name); -if (ret <0 ) { -error_report ("Error %d while activating snapshot '%s' on '%s'" , - ret, name,bdrv_get_device_name (bs)); -return ret; - } - } + ret =bdrv_all_goto_snapshot (name, &bs); +if (ret <0 ) { +error_report ("Error %d while activating snapshot '%s' on '%s'" , + ret, name,bdrv_get_device_name (bs)); +return ret; }/* restore the VM state */
Signature · 1 line
2.5.0
PATCH 5/11 migration: factor our snapshottability check in load_vmstate
In reply to Denis V. LunevWe should check that all inserted and not read-only images support snapshotting. This could be made using already invented helper bdrv_all_can_snapshot().
--- migration/savevm.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)
migration/savevm.c +7 -8
@@ -2051,6 +2051,12 @@ int load_vmstate(const char *name)QEMUFile *f;int ret; +if (!bdrv_all_can_snapshot (&bs)) { +error_report ("Device '%s' is writable but does not support snapshots." , +bdrv_get_device_name (bs)); +return -ENOTSUP ; + } + bs_vm_state =find_vmstate_bs ();if (!bs_vm_state) {error_report ("No block device supports snapshots" );
@@ -2071,15 +2077,8 @@ int load_vmstate(const char *name)writable and check if the requested snapshot is available too. */ bs =NULL ;while ((bs =bdrv_next (bs))) { - -if (!bdrv_is_inserted (bs) ||bdrv_is_read_only (bs)) { -continue ; - } -if (!bdrv_can_snapshot (bs)) { -error_report ("Device '%s' is writable but does not support snapshots." , -bdrv_get_device_name (bs)); -return -ENOTSUP ; +continue ; } ret =bdrv_snapshot_find (bs, &sn, name);
Signature · 1 line
2.5.0
PATCH 6/11 snapshot: create bdrv_all_find_snapshot helper
In reply to Denis V. Lunevto check that snapshot is available for all loaded block drivers. The check bs != bs1 in hmp_info_snapshots is an optimization. The check for availability of this snapshot will return always true as the list of snapshots was collected from that image.
The patch also ensures proper locking.
--- block/snapshot.c | 20 ++++++++++++++++++++ include/block/snapshot.h | 1 + migration/savevm.c | 42 +++++++++--------------------------------- 3 files changed, 30 insertions(+), 33 deletions(-)
block/snapshot.c +20 -0
@@ -423,3 +423,23 @@ int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs) *first_bad_bs = bs;return err; } + +int bdrv_all_find_snapshot (const char *name,BlockDriverState **first_bad_bs) +{ +QEMUSnapshotInfo sn; +int err =0 ; +BlockDriverState *bs =NULL ; + +while (err ==0 && (bs =bdrv_next (bs))) { +AioContext *ctx =bdrv_get_aio_context (bs); + +aio_context_acquire (ctx); +if (bdrv_can_snapshot (bs)) { + err =bdrv_snapshot_find (bs, &sn, name); + } +aio_context_release (ctx); + } + + *first_bad_bs = bs; +return err; +}
include/block/snapshot.h +1 -0
@@ -85,5 +85,6 @@ bool bdrv_all_can_snapshot(BlockDriverState **first_bad_bs);int bdrv_all_delete_snapshot (const char *name,BlockDriverState **first_bsd_bs,Error **err);int bdrv_all_goto_snapshot (const char *name,BlockDriverState **first_bsd_bs); +int bdrv_all_find_snapshot (const char *name,BlockDriverState **first_bad_bs);#endif
migration/savevm.c +9 -33
66 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 7/11 migration: drop find_vmstate_bs check in hmp_delvm
In reply to Denis V. LunevThere is no much sense to do the check and write warning.
--- migration/savevm.c | 5 ----- 1 file changed, 5 deletions(-)
migration/savevm.c +0 -5
@@ -2116,11 +2116,6 @@ void hmp_delvm(Monitor *mon, const QDict *qdict)Error *err;const char *name =qdict_get_str (qdict,"name" ); -if (!find_vmstate_bs ()) { -monitor_printf (mon,"No block device supports snapshots\n" ); -return ; - } -if (bdrv_all_delete_snapshot (name, &bs, &err) <0 ) { monitor_printf(mon, "Error while deleting snapshot on device '%s': %s\n",
Signature · 1 line
2.5.0
PATCH 8/11 snapshot: create bdrv_all_create_snapshot helper
In reply to Denis V. Lunevto create snapshot for all loaded block drivers.
The patch also ensures proper locking.
--- block/snapshot.c | 26 ++++++++++++++++++++++++++ include/block/snapshot.h | 4 ++++ migration/savevm.c | 17 ++++------------- 3 files changed, 34 insertions(+), 13 deletions(-)
block/snapshot.c +26 -0
@@ -443,3 +443,29 @@ int bdrv_all_find_snapshot(const char *name, BlockDriverState **first_bad_bs) *first_bad_bs = bs;return err; } + +int bdrv_all_create_snapshot (QEMUSnapshotInfo *sn, +BlockDriverState *vm_state_bs, +uint64_t vm_state_size, +BlockDriverState **first_bad_bs) +{ +int err =0 ; +BlockDriverState *bs =NULL ; + +while (err ==0 && (bs =bdrv_next (bs))) { +AioContext *ctx =bdrv_get_aio_context (bs); + +aio_context_acquire (ctx); +if (bs == vm_state_bs) { + sn->vm_state_size = vm_state_size; + err =bdrv_snapshot_create (bs, sn); + }else if (bdrv_can_snapshot (bs)) { + sn->vm_state_size =0 ; + err =bdrv_snapshot_create (bs, sn); + } +aio_context_release (ctx); + } + + *first_bad_bs = bs; +return err; +}
include/block/snapshot.h +4 -0
@@ -86,5 +86,9 @@ int bdrv_all_delete_snapshot(const char *name, BlockDriverState **first_bsd_bs, Error **err);int bdrv_all_goto_snapshot (const char *name,BlockDriverState **first_bsd_bs);int bdrv_all_find_snapshot (const char *name,BlockDriverState **first_bad_bs); +int bdrv_all_create_snapshot (QEMUSnapshotInfo *sn, +BlockDriverState *vm_state_bs, +uint64_t vm_state_size, +BlockDriverState **first_bad_bs);#endif
migration/savevm.c +4 -13
@@ -1996,19 +1996,10 @@ void hmp_savevm(Monitor *mon, const QDict *qdict) goto the_end; } -/* create the snapshots */ - - bs1 =NULL ; -while ((bs1 =bdrv_next (bs1))) { -if (bdrv_can_snapshot (bs1)) { -/* Write VM state size only to the image that contains the state */ - sn->vm_state_size = (bs == bs1 ? vm_state_size :0 ); - ret =bdrv_snapshot_create (bs1, sn); -if (ret <0 ) { -monitor_printf (mon,"Error while creating snapshot on '%s'\n" , -bdrv_get_device_name (bs1)); - } - } + ret =bdrv_all_create_snapshot (sn, bs, vm_state_size, &bs); +if (ret <0 ) { +monitor_printf (mon,"Error while creating snapshot on '%s'\n" , +bdrv_get_device_name (bs)); } the_end:
Signature · 1 line
2.5.0
PATCH 9/11 migration: reorder processing in hmp_savevm
In reply to Denis V. LunevState deletion can be performed on running VM which reduces VM downtime This approach looks a bit more natural.
--- migration/savevm.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)
migration/savevm.c +9 -9
@@ -1935,6 +1935,15 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)return ; } +/* Delete old snapshots of the same name */ +if (name &&bdrv_all_delete_snapshot (name, &bs1, &local_err) <0 ) { +monitor_printf (mon, +"Error while deleting snapshot on device '%s': %s\n" , +bdrv_get_device_name (bs1),error_get_pretty (local_err)); +error_free (local_err); +return ; + } + bs =find_vmstate_bs ();if (!bs) {monitor_printf (mon,"No block device can accept snapshots\n" );
@@ -1972,15 +1981,6 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)strftime (sn->name,sizeof (sn->name),"vm-%Y%m%d%H%M%S" , &tm); } -/* Delete old snapshots of the same name */ -if (name &&bdrv_all_delete_snapshot (name, &bs1, &local_err) <0 ) { -monitor_printf (mon, -"Error while deleting snapshot on device '%s': %s\n" , -bdrv_get_device_name (bs1),error_get_pretty (local_err)); -error_free (local_err); - goto the_end; - } -/* save the VM state */ f =qemu_fopen_bdrv (bs,1 );if (!f) {
Signature · 1 line
2.5.0
PATCH 10/11 migration: implement bdrv_all_find_vmstate_bs helper
In reply to Denis V. LunevThe patch also ensures proper locking for the operation.
--- block/snapshot.c | 15 +++++++++++++++ include/block/snapshot.h | 2 ++ migration/savevm.c | 19 ++++--------------- 3 files changed, 21 insertions(+), 15 deletions(-)
block/snapshot.c +15 -0
@@ -469,3 +469,18 @@ int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn, *first_bad_bs = bs;return err; } + +BlockDriverState *bdrv_all_find_vmstate_bs (void ) +{ +bool not_found = true; +BlockDriverState *bs =NULL ; + +while (not_found && (bs =bdrv_next (bs))) { +AioContext *ctx =bdrv_get_aio_context (bs); + +aio_context_acquire (ctx); + not_found = !bdrv_can_snapshot (bs); +aio_context_release (ctx); + } +return bs; +}
include/block/snapshot.h +2 -0
@@ -91,4 +91,6 @@ int bdrv_all_create_snapshot(QEMUSnapshotInfo *sn,uint64_t vm_state_size, BlockDriverState **first_bad_bs); +BlockDriverState *bdrv_all_find_vmstate_bs (void ); +#endif
migration/savevm.c +4 -15
@@ -1905,17 +1905,6 @@ int qemu_loadvm_state(QEMUFile *f)return ret; } -static BlockDriverState *find_vmstate_bs (void ) -{ -BlockDriverState *bs =NULL ; -while ((bs =bdrv_next (bs))) { -if (bdrv_can_snapshot (bs)) { -return bs; - } - } -return NULL ; -} -void hmp_savevm (Monitor *mon,const QDict *qdict) {BlockDriverState *bs, *bs1;
@@ -1944,8 +1933,8 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)return ; } - bs =find_vmstate_bs (); -if (!bs) { + bs =bdrv_all_find_vmstate_bs (); +if (bs ==NULL ) {monitor_printf (mon,"No block device can accept snapshots\n" );return ; }
@@ -2054,7 +2043,7 @@ int load_vmstate(const char *name)return ret; } - bs_vm_state =find_vmstate_bs (); + bs_vm_state =bdrv_all_find_vmstate_bs ();if (!bs_vm_state) {error_report ("No block device supports snapshots" );return -ENOTSUP ;
@@ -2123,7 +2112,7 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict)int total;int *available_snapshots; - bs =find_vmstate_bs (); + bs =bdrv_all_find_vmstate_bs ();if (!bs) {monitor_printf (mon,"No available block device supports snapshots\n" );return ;
Signature · 1 line
2.5.0
PATCH 11/11 migration: normalize locking in migration/savevm.c
In reply to Denis V. Lunevbasically all bdrv_* operations must be called under aio_context_acquire except ones with bdrv_all prefix.
--- migration/savevm.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)
migration/savevm.c +18 -1
@@ -1917,6 +1917,7 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)struct tm tm;const char *name =qdict_get_try_str (qdict,"name" );Error *local_err =NULL ; +AioContext *aio_context;if (!bdrv_all_can_snapshot (&bs)) { monitor_printf(mon, "Device '%s' is writable but does not "
@@ -1938,6 +1939,7 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)monitor_printf (mon,"No block device can accept snapshots\n" );return ; } + aio_context =bdrv_get_aio_context (bs); saved_vm_running =runstate_is_running ();
@@ -1948,6 +1950,8 @@ void hmp_savevm(Monitor *mon, const QDict *qdict) }vm_stop (RUN_STATE_SAVE_VM ); +aio_context_acquire (aio_context); +memset (sn,0 ,sizeof (*sn));/* fill auxiliary fields */
@@ -1992,6 +1996,7 @@ void hmp_savevm(Monitor *mon, const QDict *qdict) } the_end: +aio_context_release (aio_context);if (saved_vm_running) {vm_start (); }
@@ -2030,6 +2035,7 @@ int load_vmstate(const char *name)QEMUSnapshotInfo sn;QEMUFile *f;int ret; +AioContext *aio_context;if (!bdrv_all_can_snapshot (&bs)) { error_report("Device '%s' is writable but does not support snapshots.",
@@ -2048,9 +2054,12 @@ int load_vmstate(const char *name)error_report ("No block device supports snapshots" );return -ENOTSUP ; } + aio_context =bdrv_get_aio_context (bs_vm_state);/* Don't even try to load empty VM states */ +aio_context_acquire (aio_context); ret =bdrv_snapshot_find (bs_vm_state, &sn, name); +aio_context_release (aio_context);if (ret <0 ) {return ret; }else if (sn.vm_state_size ==0 ) {
@@ -2078,9 +2087,12 @@ int load_vmstate(const char *name)qemu_system_reset (VMRESET_SILENT );migration_incoming_state_new (f); - ret =qemu_loadvm_state (f); +aio_context_acquire (aio_context); + ret =qemu_loadvm_state (f);qemu_fclose (f); +aio_context_release (aio_context); +migration_incoming_state_destroy ();if (ret <0 ) {error_report ("Error %d while loading VM state" , ret);
@@ -2111,14 +2123,19 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict)int nb_sns, i;int total;int *available_snapshots; +AioContext *aio_context; bs =bdrv_all_find_vmstate_bs ();if (!bs) {monitor_printf (mon,"No available block device supports snapshots\n" );return ; } + aio_context =bdrv_get_aio_context (bs); +aio_context_acquire (aio_context); nb_sns =bdrv_snapshot_list (bs, &sn_tab); +aio_context_release (aio_context); +if (nb_sns <0 ) {monitor_printf (mon,"bdrv_snapshot_list: error %d\n" , nb_sns);return ;
Signature · 1 line
2.5.0