[v13,10/14] qmp: Add command 'blockdev-backup'

Similar to drive-backup, but this command uses a device id as target
instead of creating/opening an image file.

Also add blocker on target bs, since the target is also a named device
now.

Add check and report error for bs == target which became possible but is
an illegal case with introduction of blockdev-backup.

Signed-off-by: Fam Zheng <famz@redhat.com>
---
 block/backup.c   | 26 ++++++++++++++++++++++++++
 blockdev.c       | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 qapi-schema.json | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 qmp-commands.hx  | 44 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 166 insertions(+)

The Wednesday 29 Jan 2014 à 13:07:37 (+0800), Fam Zheng wrote :
> Similar to drive-backup, but this command uses a device id as target
> instead of creating/opening an image file.
> 
> Also add blocker on target bs, since the target is also a named device
> now.
> 
> Add check and report error for bs == target which became possible but is
> an illegal case with introduction of blockdev-backup.
> 
> Signed-off-by: Fam Zheng <famz@redhat.com>
> ---
>  block/backup.c   | 26 ++++++++++++++++++++++++++
>  blockdev.c       | 47 +++++++++++++++++++++++++++++++++++++++++++++++
>  qapi-schema.json | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
>  qmp-commands.hx  | 44 ++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 166 insertions(+)
> 
> diff --git a/block/backup.c b/block/backup.c
> index 15a2e55..ea46340 100644
> --- a/block/backup.c
> +++ b/block/backup.c
> @@ -344,6 +344,7 @@ static void coroutine_fn backup_run(void *opaque)
>      hbitmap_free(job->bitmap);
>  
>      bdrv_iostatus_disable(target);
> +    bdrv_op_unblock_all(target, job->common.blocker);
>      bdrv_unref(target);
>  
>      block_job_completed(&job->common, ret);
> @@ -362,6 +363,11 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
>      assert(target);
>      assert(cb);
>  
> +    if (bs == target) {
> +        error_setg(errp, "Source and target cannot be the same");
> +        return;
> +    }
> +
>      if ((on_source_error == BLOCKDEV_ON_ERROR_STOP ||
>           on_source_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
>          !bdrv_iostatus_is_enabled(bs)) {
> @@ -369,6 +375,24 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
>          return;
>      }
>  
> +    if (!bdrv_is_inserted(bs)) {
> +        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, bs->device_name);
> +        return;
> +    }
> +
> +    if (!bdrv_is_inserted(target)) {
> +        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, target->device_name);
> +        return;
> +    }
> +
> +    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
> +        return;
> +    }
> +
> +    if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) {
> +        return;
> +    }
> +
>      len = bdrv_getlength(bs);
>      if (len < 0) {
>          error_setg_errno(errp, -len, "unable to get length for '%s'",
> @@ -382,6 +406,8 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
>          return;
>      }
>  
> +    bdrv_op_block_all(target, job->common.blocker);
> +
>      job->on_source_error = on_source_error;
>      job->on_target_error = on_target_error;
>      job->target = target;
> diff --git a/blockdev.c b/blockdev.c
> index ffaa6a9..b346cc1 100644
> --- a/blockdev.c
> +++ b/blockdev.c
> @@ -1940,6 +1940,8 @@ void qmp_drive_backup(const char *device, const char *target,
>          return;
>      }
>  
> +    /* Although backup_run has this check too, we need to use bs->drv below, so
> +     * do an early check redundantly. */
>      if (!bdrv_is_inserted(bs)) {
>          error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
>          return;
> @@ -1956,6 +1958,7 @@ void qmp_drive_backup(const char *device, const char *target,
>          }
>      }
>  
> +    /* Early check to avoid creating target */
>      if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
>          return;
>      }
> @@ -2019,6 +2022,50 @@ BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
>      return bdrv_named_nodes_list();
>  }
>  
> +void qmp_blockdev_backup(const char *device, const char *target,
> +                         enum MirrorSyncMode sync,
> +                         bool has_speed, int64_t speed,
> +                         bool has_on_source_error,
> +                         BlockdevOnError on_source_error,
> +                         bool has_on_target_error,
> +                         BlockdevOnError on_target_error,
> +                         Error **errp)
> +{
> +    BlockDriverState *bs;
> +    BlockDriverState *target_bs;
> +    Error *local_err = NULL;
> +
> +    if (!has_speed) {
> +        speed = 0;
> +    }
> +    if (!has_on_source_error) {
> +        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
> +    }
> +    if (!has_on_target_error) {
> +        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
> +    }
> +
> +    bs = bdrv_find(device);
This and the qmp prototype should be upgraded to the new device and node-name
alternative and make use of bdrv_lookup_bs().

> +    if (!bs) {
> +        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
> +        return;
> +    }
> +
> +    target_bs = bdrv_find(target);
> +    if (!target_bs) {
> +        error_set(errp, QERR_DEVICE_NOT_FOUND, target);
> +        return;
> +    }
> +
> +    bdrv_ref(target_bs);
> +    backup_start(bs, target_bs, speed, sync, on_source_error, on_target_error,
> +                 block_job_cb, bs, &local_err);
> +    if (local_err != NULL) {
> +        bdrv_unref(target_bs);
> +        error_propagate(errp, local_err);
> +    }
> +}
> +
>  #define DEFAULT_MIRROR_BUF_SIZE   (10 << 20)
>  
>  void qmp_drive_mirror(const char *device, const char *target,
> diff --git a/qapi-schema.json b/qapi-schema.json
> index 05ced9d..a92e1be 100644
> --- a/qapi-schema.json
> +++ b/qapi-schema.json
> @@ -1840,6 +1840,40 @@
>              '*on-target-error': 'BlockdevOnError' } }
>  
>  ##
> +# @BlockdevBackup
> +#
> +# @device: the name of the device which should be copied.
> +#
> +# @target: the name of the backup target device.
> +#
> +# @sync: what parts of the disk image should be copied to the destination
> +#        (all the disk, only the sectors allocated in the topmost image, or
> +#        only new I/O).
> +#
> +# @speed: #optional the maximum speed, in bytes per second.
> +#
> +# @on-source-error: #optional the action to take on an error on the source,
> +#                   default 'report'.  'stop' and 'enospc' can only be used
> +#                   if the block device supports io-status (see BlockInfo).
> +#
> +# @on-target-error: #optional the action to take on an error on the target,
> +#                   default 'report' (no limitations, since this applies to
> +#                   a different block device than @device).
> +#
> +# Note that @on-source-error and @on-target-error only affect background I/O.
> +# If an error occurs during a guest write request, the device's rerror/werror
> +# actions will be used.
> +#
> +# Since: 2.0
> +##
> +{ 'type': 'BlockdevBackup',
> +  'data': { 'device': 'str', 'target': 'str',
'*device': 'str', '*node-name': str,

I don't know if it's necessary for target.

> +            'sync': 'MirrorSyncMode',
> +            '*speed': 'int',
> +            '*on-source-error': 'BlockdevOnError',
> +            '*on-target-error': 'BlockdevOnError' } }
> +
> +##
>  # @Abort
>  #
>  # This action can be used to test transaction failure.
> @@ -2048,6 +2082,21 @@
>  { 'command': 'query-named-block-nodes', 'returns': [ 'BlockDeviceInfo' ] }
>  
>  ##
> +# @blockdev-backup
> +#
> +# Block device version for drive-backup command. Use existing device as target
> +# of backup.
> +#
> +# For the arguments, see the documentation of BlockdevBackup.
> +#
> +# Returns: Nothing on success.
> +#          If @device or @target is not a valid block device, DeviceNotFound.
> +#
> +# Since 2.0
> +##
> +{ 'command': 'blockdev-backup', 'data': 'BlockdevBackup' }
> +
> +##
>  # @drive-mirror
>  #
>  # Start mirroring a block device's writes to a new destination.
> diff --git a/qmp-commands.hx b/qmp-commands.hx
> index cce6b81..c3ee46a 100644
> --- a/qmp-commands.hx
> +++ b/qmp-commands.hx
> @@ -1054,6 +1054,50 @@ Example:
>                                                 "sync": "full",
>                                                 "target": "backup.img" } }
>  <- { "return": {} }
> +
> +EQMP
> +
> +    {
> +        .name       = "blockdev-backup",
> +        .args_type  = "sync:s,device:B,target:B,speed:i?,"
> +                      "on-source-error:s?,on-target-error:s?",
> +        .mhandler.cmd_new = qmp_marshal_input_blockdev_backup,
> +    },
> +
> +SQMP
> +blockdev-backup
> +------------
> +
> +The device version of drive-backup: this command takes a existing named device
> +as backup target.
> +
> +Arguments:
> +
> +- "device": the name of the device which should be copied.
> +            (json-string)
> +- "target": the target of the new image. If the file exists, or if it is a
> +            device, the existing file/device will be used as the new
> +            destination.  If it does not exist, a new file will be created.
> +            (json-string)
> +- "sync": what parts of the disk image should be copied to the destination;
> +          possibilities include "full" for all the disk, "top" for only the
> +          sectors allocated in the topmost image, or "none" to only replicate
> +          new I/O (MirrorSyncMode).
> +- "speed": the maximum speed, in bytes per second (json-int, optional)
> +- "on-source-error": the action to take on an error on the source, default
> +                     'report'.  'stop' and 'enospc' can only be used
> +                     if the block device supports io-status.
> +                     (BlockdevOnError, optional)
> +- "on-target-error": the action to take on an error on the target, default
> +                     'report' (no limitations, since this applies to
> +                     a different block device than device).
> +                     (BlockdevOnError, optional)
> +
> +Example:
> +-> { "execute": "blockdev-backup", "arguments": { "device": "src-id",
> +                                                  "target": "tgt-id" } }
> +<- { "return": {} }
> +
>  EQMP
>  
>      {
> -- 
> 1.8.5.3
> 
>

On Thu, 02/13 14:48, Benoît Canet wrote:
> The Wednesday 29 Jan 2014 à 13:07:37 (+0800), Fam Zheng wrote :
> > Similar to drive-backup, but this command uses a device id as target
> > instead of creating/opening an image file.
> > 
> > Also add blocker on target bs, since the target is also a named device
> > now.
> > 
> > Add check and report error for bs == target which became possible but is
> > an illegal case with introduction of blockdev-backup.
> > 
> > Signed-off-by: Fam Zheng <famz@redhat.com>
> > ---
> >  block/backup.c   | 26 ++++++++++++++++++++++++++
> >  blockdev.c       | 47 +++++++++++++++++++++++++++++++++++++++++++++++
> >  qapi-schema.json | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
> >  qmp-commands.hx  | 44 ++++++++++++++++++++++++++++++++++++++++++++
> >  4 files changed, 166 insertions(+)
> > 
> > diff --git a/block/backup.c b/block/backup.c
> > index 15a2e55..ea46340 100644
> > --- a/block/backup.c
> > +++ b/block/backup.c
> > @@ -344,6 +344,7 @@ static void coroutine_fn backup_run(void *opaque)
> >      hbitmap_free(job->bitmap);
> >  
> >      bdrv_iostatus_disable(target);
> > +    bdrv_op_unblock_all(target, job->common.blocker);
> >      bdrv_unref(target);
> >  
> >      block_job_completed(&job->common, ret);
> > @@ -362,6 +363,11 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
> >      assert(target);
> >      assert(cb);
> >  
> > +    if (bs == target) {
> > +        error_setg(errp, "Source and target cannot be the same");
> > +        return;
> > +    }
> > +
> >      if ((on_source_error == BLOCKDEV_ON_ERROR_STOP ||
> >           on_source_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
> >          !bdrv_iostatus_is_enabled(bs)) {
> > @@ -369,6 +375,24 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
> >          return;
> >      }
> >  
> > +    if (!bdrv_is_inserted(bs)) {
> > +        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, bs->device_name);
> > +        return;
> > +    }
> > +
> > +    if (!bdrv_is_inserted(target)) {
> > +        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, target->device_name);
> > +        return;
> > +    }
> > +
> > +    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
> > +        return;
> > +    }
> > +
> > +    if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) {
> > +        return;
> > +    }
> > +
> >      len = bdrv_getlength(bs);
> >      if (len < 0) {
> >          error_setg_errno(errp, -len, "unable to get length for '%s'",
> > @@ -382,6 +406,8 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
> >          return;
> >      }
> >  
> > +    bdrv_op_block_all(target, job->common.blocker);
> > +
> >      job->on_source_error = on_source_error;
> >      job->on_target_error = on_target_error;
> >      job->target = target;
> > diff --git a/blockdev.c b/blockdev.c
> > index ffaa6a9..b346cc1 100644
> > --- a/blockdev.c
> > +++ b/blockdev.c
> > @@ -1940,6 +1940,8 @@ void qmp_drive_backup(const char *device, const char *target,
> >          return;
> >      }
> >  
> > +    /* Although backup_run has this check too, we need to use bs->drv below, so
> > +     * do an early check redundantly. */
> >      if (!bdrv_is_inserted(bs)) {
> >          error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
> >          return;
> > @@ -1956,6 +1958,7 @@ void qmp_drive_backup(const char *device, const char *target,
> >          }
> >      }
> >  
> > +    /* Early check to avoid creating target */
> >      if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
> >          return;
> >      }
> > @@ -2019,6 +2022,50 @@ BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
> >      return bdrv_named_nodes_list();
> >  }
> >  
> > +void qmp_blockdev_backup(const char *device, const char *target,
> > +                         enum MirrorSyncMode sync,
> > +                         bool has_speed, int64_t speed,
> > +                         bool has_on_source_error,
> > +                         BlockdevOnError on_source_error,
> > +                         bool has_on_target_error,
> > +                         BlockdevOnError on_target_error,
> > +                         Error **errp)
> > +{
> > +    BlockDriverState *bs;
> > +    BlockDriverState *target_bs;
> > +    Error *local_err = NULL;
> > +
> > +    if (!has_speed) {
> > +        speed = 0;
> > +    }
> > +    if (!has_on_source_error) {
> > +        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
> > +    }
> > +    if (!has_on_target_error) {
> > +        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
> > +    }
> > +
> > +    bs = bdrv_find(device);
> This and the qmp prototype should be upgraded to the new device and node-name
> alternative and make use of bdrv_lookup_bs().
> 

Can we do it later in a separate patch?

Fam

The Monday 17 Feb 2014 à 21:32:51 (+0800), Fam Zheng wrote :
> On Thu, 02/13 14:48, Benoît Canet wrote:
> > The Wednesday 29 Jan 2014 à 13:07:37 (+0800), Fam Zheng wrote :
> > > Similar to drive-backup, but this command uses a device id as target
> > > instead of creating/opening an image file.
> > > 
> > > Also add blocker on target bs, since the target is also a named device
> > > now.
> > > 
> > > Add check and report error for bs == target which became possible but is
> > > an illegal case with introduction of blockdev-backup.
> > > 
> > > Signed-off-by: Fam Zheng <famz@redhat.com>
> > > ---
> > >  block/backup.c   | 26 ++++++++++++++++++++++++++
> > >  blockdev.c       | 47 +++++++++++++++++++++++++++++++++++++++++++++++
> > >  qapi-schema.json | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
> > >  qmp-commands.hx  | 44 ++++++++++++++++++++++++++++++++++++++++++++
> > >  4 files changed, 166 insertions(+)
> > > 
> > > diff --git a/block/backup.c b/block/backup.c
> > > index 15a2e55..ea46340 100644
> > > --- a/block/backup.c
> > > +++ b/block/backup.c
> > > @@ -344,6 +344,7 @@ static void coroutine_fn backup_run(void *opaque)
> > >      hbitmap_free(job->bitmap);
> > >  
> > >      bdrv_iostatus_disable(target);
> > > +    bdrv_op_unblock_all(target, job->common.blocker);
> > >      bdrv_unref(target);
> > >  
> > >      block_job_completed(&job->common, ret);
> > > @@ -362,6 +363,11 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
> > >      assert(target);
> > >      assert(cb);
> > >  
> > > +    if (bs == target) {
> > > +        error_setg(errp, "Source and target cannot be the same");
> > > +        return;
> > > +    }
> > > +
> > >      if ((on_source_error == BLOCKDEV_ON_ERROR_STOP ||
> > >           on_source_error == BLOCKDEV_ON_ERROR_ENOSPC) &&
> > >          !bdrv_iostatus_is_enabled(bs)) {
> > > @@ -369,6 +375,24 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
> > >          return;
> > >      }
> > >  
> > > +    if (!bdrv_is_inserted(bs)) {
> > > +        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, bs->device_name);
> > > +        return;
> > > +    }
> > > +
> > > +    if (!bdrv_is_inserted(target)) {
> > > +        error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, target->device_name);
> > > +        return;
> > > +    }
> > > +
> > > +    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
> > > +        return;
> > > +    }
> > > +
> > > +    if (bdrv_op_is_blocked(target, BLOCK_OP_TYPE_BACKUP_TARGET, errp)) {
> > > +        return;
> > > +    }
> > > +
> > >      len = bdrv_getlength(bs);
> > >      if (len < 0) {
> > >          error_setg_errno(errp, -len, "unable to get length for '%s'",
> > > @@ -382,6 +406,8 @@ void backup_start(BlockDriverState *bs, BlockDriverState *target,
> > >          return;
> > >      }
> > >  
> > > +    bdrv_op_block_all(target, job->common.blocker);
> > > +
> > >      job->on_source_error = on_source_error;
> > >      job->on_target_error = on_target_error;
> > >      job->target = target;
> > > diff --git a/blockdev.c b/blockdev.c
> > > index ffaa6a9..b346cc1 100644
> > > --- a/blockdev.c
> > > +++ b/blockdev.c
> > > @@ -1940,6 +1940,8 @@ void qmp_drive_backup(const char *device, const char *target,
> > >          return;
> > >      }
> > >  
> > > +    /* Although backup_run has this check too, we need to use bs->drv below, so
> > > +     * do an early check redundantly. */
> > >      if (!bdrv_is_inserted(bs)) {
> > >          error_set(errp, QERR_DEVICE_HAS_NO_MEDIUM, device);
> > >          return;
> > > @@ -1956,6 +1958,7 @@ void qmp_drive_backup(const char *device, const char *target,
> > >          }
> > >      }
> > >  
> > > +    /* Early check to avoid creating target */
> > >      if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_BACKUP_SOURCE, errp)) {
> > >          return;
> > >      }
> > > @@ -2019,6 +2022,50 @@ BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
> > >      return bdrv_named_nodes_list();
> > >  }
> > >  
> > > +void qmp_blockdev_backup(const char *device, const char *target,
> > > +                         enum MirrorSyncMode sync,
> > > +                         bool has_speed, int64_t speed,
> > > +                         bool has_on_source_error,
> > > +                         BlockdevOnError on_source_error,
> > > +                         bool has_on_target_error,
> > > +                         BlockdevOnError on_target_error,
> > > +                         Error **errp)
> > > +{
> > > +    BlockDriverState *bs;
> > > +    BlockDriverState *target_bs;
> > > +    Error *local_err = NULL;
> > > +
> > > +    if (!has_speed) {
> > > +        speed = 0;
> > > +    }
> > > +    if (!has_on_source_error) {
> > > +        on_source_error = BLOCKDEV_ON_ERROR_REPORT;
> > > +    }
> > > +    if (!has_on_target_error) {
> > > +        on_target_error = BLOCKDEV_ON_ERROR_REPORT;
> > > +    }
> > > +
> > > +    bs = bdrv_find(device);
> > This and the qmp prototype should be upgraded to the new device and node-name
> > alternative and make use of bdrv_lookup_bs().
> > 
> 
> Can we do it later in a separate patch?
sure.

> 
> Fam
>