dataplane snapshot fixes
v8 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 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 v8 1/10 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 v8 2/10 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 v8 3/10 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 v8 4/10 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 v8 5/10 snapshot: create bdrv_all_find_snapshot helper
In reply to Denis V. Lunevto check that snapshot is available for all loaded block drivers. The ability to switch to snapshot is verified separately using bdrv_all_can_snapshot.
The patch also ensures proper locking.
--- block/snapshot.c | 26 +++++++++++++++++++++++ include/block/snapshot.h | 2 ++ migration/savevm.c | 55 +++++++++++++----------------------------------- 3 files changed, 43 insertions(+), 40 deletions(-)
block/snapshot.c +26 -0
@@ -423,3 +423,29 @@ 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,bool skip_read_only, +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); + +if (skip_read_only && + (!bdrv_is_inserted (bs) ||bdrv_is_read_only (bs))) { +continue ; + } + +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 +2 -0
@@ -85,5 +85,7 @@ 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,bool skip_read_only, +BlockDriverState **first_bad_bs);#endif
migration/savevm.c +15 -40
79 lines not on this page · raw message
Signature · 1 line
2.5.0
Re: [Qemu-devel] [PATCH 05/10] snapshot: create bdrv_all_find_snapshot helper
block/snapshot.c int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs) · line 438
Quoted 12 lines · Denis V. Lunev
block/snapshot.c +12
-0+int bdrv_all_find_snapshot (const char *name,bool skip_read_only, +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); + +if (skip_read_only && + (!bdrv_is_inserted (bs) ||bdrv_is_read_only (bs))) {
These must be called with AioContext acquired.
block/snapshot.c int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs) · line 443
Quoted 5 lines
block/snapshot.c +5
-0+continue ; + } + +aio_context_acquire (ctx); +if (bdrv_can_snapshot (bs)) {
The !bdrv_is_inserted(bs) || bdrv_is_read_only(bs) checks above are redundant since bdrv_can_snapshot() checks too:
int bdrv_can_snapshot(BlockDriverState *bs)
{
BlockDriver *drv = bs->drv;
if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) {
return 0;
}It also means that the "skip_read_only" name is inaccurate. Read-only drives are always skipped, regardless of skip_read_only's value.
The skip_read_only argument can be dropped and the earlier !bdrv_is_inserted(bs) || bdrv_is_read_only(bs) check can be dropped too.
Quoted 10 lines
migration/savevm.c +0
-6@@ -2168,21 +2157,7 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict) available_snapshots =g_new0 (int, nb_sns); total =0 ;for (i =0 ; i < nb_sns; i++) { - sn = &sn_tab[i]; - available =1 ; - bs1 =NULL ; - -while ((bs1 =bdrv_next (bs1))) { -if (bdrv_can_snapshot (bs1) && bs1 != bs) {
migration/savevm.c void hmp_info_snapshots(Monitor *mon, const QDict *qdict) · line 2160
Quoted 10 lines
migration/savevm.c +1
-9- ret =bdrv_snapshot_find (bs1, sn_info, sn->id_str); -if (ret <0 ) { - available =0 ; -break ; - } - } - } - -if (available) { +if (bdrv_all_find_snapshot (sn_tab[i].id_str, false, &bs1) ==0 ) {
bdrv_all_find_snapshot() doesn't do the bs1 != bs exclusion so the new code behaves differently from the old code. That seems like a bug.
Re: [Qemu-devel] [PATCH 05/10] snapshot: create bdrv_all_find_snapshot helper
Quoted 15 lines · Stefan Hajnoczi
block/snapshot.c int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs) · line 438
Quoted 12 lines · Denis V. Lunev
block/snapshot.c +12
-0+int bdrv_all_find_snapshot (const char *name,bool skip_read_only, +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); + +if (skip_read_only && + (!bdrv_is_inserted (bs) ||bdrv_is_read_only (bs))) {These must be called with AioContext acquired.
AFAIK no. this is called without that in bdrv jobs code.
bdrv_is_read_only is a simple flag, which is filled on open bdrv_is_inserted is defined for CDROM only and does not rely on AIO context stuff.
Quoted 15 lines
block/snapshot.c int bdrv_all_goto_snapshot(const char *name, BlockDriverState **first_bad_bs) · line 443
Quoted 5 lines
block/snapshot.c +5
-0+continue ; + } + +aio_context_acquire (ctx); +if (bdrv_can_snapshot (bs)) {The !bdrv_is_inserted(bs) ||
bdrv_is_read_only(bs)checks above are redundant sincebdrv_can_snapshot()checks too:int bdrv_can_snapshot(BlockDriverState *bs) { BlockDriver *drv = bs->drv; if (!drv || !bdrv_is_inserted(bs) || bdrv_is_read_only(bs)) { return 0; }
Quoted 5 lines
It also means that the "
skip_read_only" name is inaccurate. Read-only drives are always skipped, regardless of skip_read_only's value.The
skip_read_onlyargument can be dropped and the earlier !bdrv_is_inserted(bs) ||bdrv_is_read_only(bs)check can be dropped too.
I have though on this several times and once again I am wrong :( This looks like a punishment for my sins. OK :(
Quoted 14 lines
Quoted 14 lines
migration/savevm.c +0
-10@@ -2168,21 +2157,7 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict) available_snapshots =g_new0 (int, nb_sns); total =0 ;for (i =0 ; i < nb_sns; i++) { - sn = &sn_tab[i]; - available =1 ; - bs1 =NULL ; - -while ((bs1 =bdrv_next (bs1))) { -if (bdrv_can_snapshot (bs1) && bs1 != bs) { - ret =bdrv_snapshot_find (bs1, sn_info, sn->id_str); -if (ret <0 ) { - available =0 ; -break ;
Quoted 8 lines
migration/savevm.c void hmp_info_snapshots(Monitor *mon, const QDict *qdict) · line 2160
Quoted 6 lines
migration/savevm.c +1
-5- } - } - } - -if (available) { +if (bdrv_all_find_snapshot (sn_tab[i].id_str, false, &bs1) ==0 ) {
bdrv_all_find_snapshot()doesn't do the bs1 != bs exclusion so the new code behaves differently from the old code. That seems like a bug.
no. The result will be the same. This is a minor optimisation:
- we get the first block device we can make snapshot on
- we get snapshot list on that device
- after that we start iterations over the list and removing not available snapshots on other devices This means that if bs == bs1 the check will be "always true"
Re: [Qemu-devel] [PATCH 05/10] snapshot: create bdrv_all_find_snapshot helper
Quoted 24 lines · Denis V. Lunev
Quoted 15 lines · Stefan Hajnoczi
Quoted 14 lines · Denis V. Lunev
migration/savevm.c +0
-10@@ -2168,21 +2157,7 @@ void hmp_info_snapshots(Monitor *mon, const QDict *qdict) available_snapshots =g_new0 (int, nb_sns); total =0 ;for (i =0 ; i < nb_sns; i++) { - sn = &sn_tab[i]; - available =1 ; - bs1 =NULL ; - -while ((bs1 =bdrv_next (bs1))) { -if (bdrv_can_snapshot (bs1) && bs1 != bs) { - ret =bdrv_snapshot_find (bs1, sn_info, sn->id_str); -if (ret <0 ) { - available =0 ; -break ;Quoted 8 lines
migration/savevm.c void hmp_info_snapshots(Monitor *mon, const QDict *qdict) · line 2160
Quoted 6 lines
migration/savevm.c +1
-5- } - } - } - -if (available) { +if (bdrv_all_find_snapshot (sn_tab[i].id_str, false, &bs1) ==0 ) {
bdrv_all_find_snapshot()doesn't do the bs1 != bs exclusion so the new code behaves differently from the old code. That seems like a bug.
Quoted 6 lines
no. The result will be the same. This is a minor optimisation:
- we get the first block device we can make snapshot on
- we get snapshot list on that device
- after that we start iterations over the list and removing not available snapshots on other devices
This means that if bs == bs1 the check will be "always true"
Ah, I see. Thanks!
Stefan
PATCH v8 6/10 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 v8 7/10 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
@@ -449,3 +449,29 @@ int bdrv_all_find_snapshot(const char *name, bool skip_read_only, *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
@@ -87,5 +87,9 @@ int bdrv_all_delete_snapshot(const char *name, BlockDriverState **first_bsd_bs,int bdrv_all_goto_snapshot (const char *name,BlockDriverState **first_bsd_bs);int bdrv_all_find_snapshot (const char *name,bool skip_read_only,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 v8 8/10 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 v8 9/10 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
@@ -475,3 +475,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
@@ -92,4 +92,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 v8 10/10 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);/* 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