[v3] savevm: Really verify if a drive supports snapshots

Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.

First issue: Their names implies different porpouses, but they do the same thing
and have exactly the same code. Maybe copied and pasted and forgotten?
bdrv_has_snapshot() is called in various places for actually checking if there
is snapshots or not.

Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
not snapshots does not catch all cases. E.g.: a raw image.

So when do_savevm() is called, first thing it does is to set a global
BlockDriverState to save the VM memory state calling get_bs_snapshots().

static BlockDriverState *get_bs_snapshots(void)
{
    BlockDriverState *bs;
    DriveInfo *dinfo;

    if (bs_snapshots)
        return bs_snapshots;
    QTAILQ_FOREACH(dinfo, &drives, next) {
        bs = dinfo->bdrv;
        if (bdrv_can_snapshot(bs))
            goto ok;
    }
    return NULL;
 ok:
    bs_snapshots = bs;
    return bs;
}

bdrv_can_snapshot() may return a BlockDriverState that does not support
snapshots and do_savevm() goes on.

Later on in do_savevm(), we find:

    QTAILQ_FOREACH(dinfo, &drives, next) {
        bs1 = dinfo->bdrv;
        if (bdrv_has_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));
            }
        }
    }

bdrv_has_snapshot(bs1) is not checking if the device does support or has
snapshots as explained above. Only in bdrv_snapshot_create() the device is
actually checked for snapshot support.

So, in cases where the first device supports snapshots, and the second does not,
the snapshot on the first will happen anyways. I believe this is not a good
behavior. It should be an all or nothing process.

This patch addresses these issues by making bdrv_can_snapshot() actually do
what it must do and enforces better tests to avoid errors in the middle of
do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
where appropriate.

bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.

The loadvm_state() function was updated too to enforce that when loading a VM at
least all writable devices must support snapshots too.

Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
---
 block.c  |   11 +++++++++++
 block.h  |    1 +
 savevm.c |   58 ++++++++++++++++++++++++++++++++++++----------------------
 3 files changed, 48 insertions(+), 22 deletions(-)

Am 03.06.2010 21:52, schrieb Miguel Di Ciurcio Filho:
> Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
> 
> First issue: Their names implies different porpouses, but they do the same thing
> and have exactly the same code. Maybe copied and pasted and forgotten?
> bdrv_has_snapshot() is called in various places for actually checking if there
> is snapshots or not.
> 
> Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
> not snapshots does not catch all cases. E.g.: a raw image.
> 
> So when do_savevm() is called, first thing it does is to set a global
> BlockDriverState to save the VM memory state calling get_bs_snapshots().
> 
> static BlockDriverState *get_bs_snapshots(void)
> {
>     BlockDriverState *bs;
>     DriveInfo *dinfo;
> 
>     if (bs_snapshots)
>         return bs_snapshots;
>     QTAILQ_FOREACH(dinfo, &drives, next) {
>         bs = dinfo->bdrv;
>         if (bdrv_can_snapshot(bs))
>             goto ok;
>     }
>     return NULL;
>  ok:
>     bs_snapshots = bs;
>     return bs;
> }
> 
> bdrv_can_snapshot() may return a BlockDriverState that does not support
> snapshots and do_savevm() goes on.
> 
> Later on in do_savevm(), we find:
> 
>     QTAILQ_FOREACH(dinfo, &drives, next) {
>         bs1 = dinfo->bdrv;
>         if (bdrv_has_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));
>             }
>         }
>     }
> 
> bdrv_has_snapshot(bs1) is not checking if the device does support or has
> snapshots as explained above. Only in bdrv_snapshot_create() the device is
> actually checked for snapshot support.
> 
> So, in cases where the first device supports snapshots, and the second does not,
> the snapshot on the first will happen anyways. I believe this is not a good
> behavior. It should be an all or nothing process.
> 
> This patch addresses these issues by making bdrv_can_snapshot() actually do
> what it must do and enforces better tests to avoid errors in the middle of
> do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
> where appropriate.
> 
> bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
> 
> The loadvm_state() function was updated too to enforce that when loading a VM at
> least all writable devices must support snapshots too.
> 
> Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>

Thanks, applied to the block branch.

Kevin

Am 03.06.2010 21:52, schrieb Miguel Di Ciurcio Filho:
> Both bdrv_can_snapshot() and bdrv_has_snapshot() does not work as advertized.
> 
> First issue: Their names implies different porpouses, but they do the same thing
> and have exactly the same code. Maybe copied and pasted and forgotten?
> bdrv_has_snapshot() is called in various places for actually checking if there
> is snapshots or not.
> 
> Second issue: the way bdrv_can_snapshot() verifies if a block driver supports or
> not snapshots does not catch all cases. E.g.: a raw image.
> 
> So when do_savevm() is called, first thing it does is to set a global
> BlockDriverState to save the VM memory state calling get_bs_snapshots().
> 
> static BlockDriverState *get_bs_snapshots(void)
> {
>     BlockDriverState *bs;
>     DriveInfo *dinfo;
> 
>     if (bs_snapshots)
>         return bs_snapshots;
>     QTAILQ_FOREACH(dinfo, &drives, next) {
>         bs = dinfo->bdrv;
>         if (bdrv_can_snapshot(bs))
>             goto ok;
>     }
>     return NULL;
>  ok:
>     bs_snapshots = bs;
>     return bs;
> }
> 
> bdrv_can_snapshot() may return a BlockDriverState that does not support
> snapshots and do_savevm() goes on.
> 
> Later on in do_savevm(), we find:
> 
>     QTAILQ_FOREACH(dinfo, &drives, next) {
>         bs1 = dinfo->bdrv;
>         if (bdrv_has_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));
>             }
>         }
>     }
> 
> bdrv_has_snapshot(bs1) is not checking if the device does support or has
> snapshots as explained above. Only in bdrv_snapshot_create() the device is
> actually checked for snapshot support.
> 
> So, in cases where the first device supports snapshots, and the second does not,
> the snapshot on the first will happen anyways. I believe this is not a good
> behavior. It should be an all or nothing process.
> 
> This patch addresses these issues by making bdrv_can_snapshot() actually do
> what it must do and enforces better tests to avoid errors in the middle of
> do_savevm(). bdrv_has_snapshot() is removed and replaced by bdrv_can_snapshot()
> where appropriate.
> 
> bdrv_can_snapshot() was moved from savevm.c to block.c. It makes more sense to me.
> 
> The loadvm_state() function was updated too to enforce that when loading a VM at
> least all writable devices must support snapshots too.
> 
> Signed-off-by: Miguel Di Ciurcio Filho <miguel.filho@gmail.com>
> ---
>  block.c  |   11 +++++++++++
>  block.h  |    1 +
>  savevm.c |   58 ++++++++++++++++++++++++++++++++++++----------------------
>  3 files changed, 48 insertions(+), 22 deletions(-)
> 
> diff --git a/block.c b/block.c
> index cd70730..ace3cdb 100644
> --- a/block.c
> +++ b/block.c
> @@ -1720,6 +1720,17 @@ void bdrv_debug_event(BlockDriverState *bs, BlkDebugEvent event)
>  /**************************************************************/
>  /* handling of snapshots */
>  
> +int bdrv_can_snapshot(BlockDriverState *bs)
> +{
> +    BlockDriver *drv = bs->drv;
> +    if (!drv || !drv->bdrv_snapshot_create || bdrv_is_removable(bs) ||
> +        bdrv_is_read_only(bs)) {
> +        return 0;
> +    }
> +
> +    return 1;
> +}
> +
>  int bdrv_snapshot_create(BlockDriverState *bs,
>                           QEMUSnapshotInfo *sn_info)
>  {
> diff --git a/block.h b/block.h
> index 24efeb6..fbcd8af 100644
> --- a/block.h
> +++ b/block.h
> @@ -173,6 +173,7 @@ int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi);
>  const char *bdrv_get_encrypted_filename(BlockDriverState *bs);
>  void bdrv_get_backing_filename(BlockDriverState *bs,
>                                 char *filename, int filename_size);
> +int bdrv_can_snapshot(BlockDriverState *bs);
>  int bdrv_snapshot_create(BlockDriverState *bs,
>                           QEMUSnapshotInfo *sn_info);
>  int bdrv_snapshot_goto(BlockDriverState *bs,
> diff --git a/savevm.c b/savevm.c
> index dc20390..6549ca7 100644
> --- a/savevm.c
> +++ b/savevm.c
> @@ -1574,22 +1574,6 @@ out:
>      return ret;
>  }
>  
> -/* device can contain snapshots */
> -static int bdrv_can_snapshot(BlockDriverState *bs)
> -{
> -    return (bs &&
> -            !bdrv_is_removable(bs) &&
> -            !bdrv_is_read_only(bs));
> -}
> -
> -/* device must be snapshots in order to have a reliable snapshot */
> -static int bdrv_has_snapshot(BlockDriverState *bs)
> -{
> -    return (bs &&
> -            !bdrv_is_removable(bs) &&
> -            !bdrv_is_read_only(bs));
> -}
> -
>  static BlockDriverState *get_bs_snapshots(void)
>  {
>      BlockDriverState *bs;
> @@ -1599,8 +1583,9 @@ static BlockDriverState *get_bs_snapshots(void)
>          return bs_snapshots;
>      QTAILQ_FOREACH(dinfo, &drives, next) {
>          bs = dinfo->bdrv;
> -        if (bdrv_can_snapshot(bs))
> +        if (bdrv_can_snapshot(bs)) {
>              goto ok;
> +        }
>      }
>      return NULL;
>   ok:
> @@ -1674,12 +1659,26 @@ void do_savevm(Monitor *mon, const QDict *qdict)
>  #endif
>      const char *name = qdict_get_try_str(qdict, "name");
>  
> +    /* Verify if there is a device that doesn't support snapshots and is writable */
> +    QTAILQ_FOREACH(dinfo, &drives, next) {
> +        bs = dinfo->bdrv;
> +
> +        if (bdrv_is_removable(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));
> +            goto the_end;

cc1: warnings being treated as errors
savevm.c: In Funktion »do_savevm«:
savevm.c:1654: Fehler: »saved_vm_running« may be used uninitialized in
this function

return instead of goto the_end is probably the right thing to do here.

Kevin

On Fri, Jun 4, 2010 at 2:28 PM, Kevin Wolf <kwolf@redhat.com> wrote:
>> @@ -1674,12 +1659,26 @@ void do_savevm(Monitor *mon, const QDict *qdict)
>>  #endif
>>      const char *name = qdict_get_try_str(qdict, "name");
>>
>> +    /* Verify if there is a device that doesn't support snapshots and is writable */
>> +    QTAILQ_FOREACH(dinfo, &drives, next) {
>> +        bs = dinfo->bdrv;
>> +
>> +        if (bdrv_is_removable(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));
>> +            goto the_end;
>
> cc1: warnings being treated as errors
> savevm.c: In Funktion »do_savevm«:
> savevm.c:1654: Fehler: »saved_vm_running« may be used uninitialized in
> this function
>
> return instead of goto the_end is probably the right thing to do here.
>

Strange. This warning did not happen with me.

Miguel