Commit 341ebc2f authored by John Snow's avatar John Snow Committed by Kevin Wolf
Browse files

qmp: Add block-dirty-bitmap-add and block-dirty-bitmap-remove 



The new command pair is added to manage a user created dirty bitmap. The
dirty bitmap's name is mandatory and must be unique for the same device,
but different devices can have bitmaps with the same names.

The granularity is an optional field. If it is not specified, we will
choose a default granularity based on the cluster size if available,
clamped to between 4K and 64K to mirror how the 'mirror' code was
already choosing granularity. If we do not have cluster size info
available, we choose 64K. This code has been factored out into a helper
shared with block/mirror.

This patch also introduces the 'block_dirty_bitmap_lookup' helper,
which takes a device name and a dirty bitmap name and validates the
lookup, returning NULL and setting errp if there is a problem with
either field. This helper will be re-used in future patches in this
series.

The types added to block-core.json will be re-used in future patches
in this series, see:
'qapi: Add transaction support to block-dirty-bitmap-{add, enable, disable}'

Signed-off-by: default avatarJohn Snow <jsnow@redhat.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
Reviewed-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: default avatarEric Blake <eblake@redhat.com>
Message-id: 1429314609-29776-5-git-send-email-jsnow@redhat.com
Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent 5fba6c0e

block.c

+20 −0
Original line number Diff line number Diff line
@@ -5596,6 +5596,26 @@ int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector 
    }

}



/**

 * Chooses a default granularity based on the existing cluster size,

 * but clamped between [4K, 64K]. Defaults to 64K in the case that there

 * is no cluster size information available.

 */

uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs)

{

    BlockDriverInfo bdi;

    uint32_t granularity;



    if (bdrv_get_info(bs, &bdi) >= 0 && bdi.cluster_size > 0) {

        granularity = MAX(4096, bdi.cluster_size);

        granularity = MIN(65536, granularity);

    } else {

        granularity = 65536;

    }



    return granularity;

}



void bdrv_dirty_iter_init(BlockDriverState *bs,

                          BdrvDirtyBitmap *bitmap, HBitmapIter *hbi)

{

block/mirror.c

+1 −9
Original line number Diff line number Diff line
@@ -668,15 +668,7 @@ static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target, 
    MirrorBlockJob *s;



    if (granularity == 0) {

        /* Choose the default granularity based on the target file's cluster

         * size, clamped between 4k and 64k.  */

        BlockDriverInfo bdi;

        if (bdrv_get_info(target, &bdi) >= 0 && bdi.cluster_size != 0) {

            granularity = MAX(4096, bdi.cluster_size);

            granularity = MIN(65536, granularity);

        } else {

            granularity = 65536;

        }

        granularity = bdrv_get_default_bitmap_granularity(target);

    }



    assert ((granularity & (granularity - 1)) == 0);

blockdev.c

+117 −0
Original line number Diff line number Diff line
@@ -1164,6 +1164,68 @@ out_aio_context: 
    return NULL;

}



/**

 * block_dirty_bitmap_lookup:

 * Return a dirty bitmap (if present), after validating

 * the node reference and bitmap names.

 *

 * @node: The name of the BDS node to search for bitmaps

 * @name: The name of the bitmap to search for

 * @pbs: Output pointer for BDS lookup, if desired. Can be NULL.

 * @paio: Output pointer for aio_context acquisition, if desired. Can be NULL.

 * @errp: Output pointer for error information. Can be NULL.

 *

 * @return: A bitmap object on success, or NULL on failure.

 */

static BdrvDirtyBitmap *block_dirty_bitmap_lookup(const char *node,

                                                  const char *name,

                                                  BlockDriverState **pbs,

                                                  AioContext **paio,

                                                  Error **errp)

{

    BlockDriverState *bs;

    BdrvDirtyBitmap *bitmap;

    AioContext *aio_context;



    if (!node) {

        error_setg(errp, "Node cannot be NULL");

        return NULL;

    }

    if (!name) {

        error_setg(errp, "Bitmap name cannot be NULL");

        return NULL;

    }

    bs = bdrv_lookup_bs(node, node, NULL);

    if (!bs) {

        error_setg(errp, "Node '%s' not found", node);

        return NULL;

    }



    aio_context = bdrv_get_aio_context(bs);

    aio_context_acquire(aio_context);



    bitmap = bdrv_find_dirty_bitmap(bs, name);

    if (!bitmap) {

        error_setg(errp, "Dirty bitmap '%s' not found", name);

        goto fail;

    }



    if (pbs) {

        *pbs = bs;

    }

    if (paio) {

        *paio = aio_context;

    } else {

        aio_context_release(aio_context);

    }



    return bitmap;



 fail:

    aio_context_release(aio_context);

    return NULL;

}



/* New and old BlockDriverState structs for atomic group operations */



typedef struct BlkTransactionState BlkTransactionState;
@@ -1954,6 +2016,61 @@ void qmp_block_set_io_throttle(const char *device, int64_t bps, int64_t bps_rd, 
    aio_context_release(aio_context);

}



void qmp_block_dirty_bitmap_add(const char *node, const char *name,

                                bool has_granularity, uint32_t granularity,

                                Error **errp)

{

    AioContext *aio_context;

    BlockDriverState *bs;



    if (!name || name[0] == '\0') {

        error_setg(errp, "Bitmap name cannot be empty");

        return;

    }



    bs = bdrv_lookup_bs(node, node, errp);

    if (!bs) {

        return;

    }



    aio_context = bdrv_get_aio_context(bs);

    aio_context_acquire(aio_context);



    if (has_granularity) {

        if (granularity < 512 || !is_power_of_2(granularity)) {

            error_setg(errp, "Granularity must be power of 2 "

                             "and at least 512");

            goto out;

        }

    } else {

        /* Default to cluster size, if available: */

        granularity = bdrv_get_default_bitmap_granularity(bs);

    }



    bdrv_create_dirty_bitmap(bs, granularity, name, errp);



 out:

    aio_context_release(aio_context);

}



void qmp_block_dirty_bitmap_remove(const char *node, const char *name,

                                   Error **errp)

{

    AioContext *aio_context;

    BlockDriverState *bs;

    BdrvDirtyBitmap *bitmap;



    bitmap = block_dirty_bitmap_lookup(node, name, &bs, &aio_context, errp);

    if (!bitmap || !bs) {

        return;

    }



    bdrv_dirty_bitmap_make_anon(bs, bitmap);

    bdrv_release_dirty_bitmap(bs, bitmap);



    aio_context_release(aio_context);

}



int hmp_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data)

{

    const char *id = qdict_get_str(qdict, "id");

include/block/block.h

+1 −0
Original line number Diff line number Diff line
@@ -459,6 +459,7 @@ BdrvDirtyBitmap *bdrv_find_dirty_bitmap(BlockDriverState *bs, 
void bdrv_dirty_bitmap_make_anon(BlockDriverState *bs, BdrvDirtyBitmap *bitmap);

void bdrv_release_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap);

BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs);

uint32_t bdrv_get_default_bitmap_granularity(BlockDriverState *bs);

int bdrv_get_dirty(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, int64_t sector);

void bdrv_set_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap,

                           int64_t cur_sector, int nr_sectors);

qapi/block-core.json

+55 −0
Original line number Diff line number Diff line
@@ -959,6 +959,61 @@ 
            '*buf-size': 'int', '*on-source-error': 'BlockdevOnError',

            '*on-target-error': 'BlockdevOnError' } }



##

# @BlockDirtyBitmap

#

# @node: name of device/node which the bitmap is tracking

#

# @name: name of the dirty bitmap

#

# Since 2.4

##

{ 'type': 'BlockDirtyBitmap',

  'data': { 'node': 'str', 'name': 'str' } }



##

# @BlockDirtyBitmapAdd

#

# @node: name of device/node which the bitmap is tracking

#

# @name: name of the dirty bitmap

#

# @granularity: #optional the bitmap granularity, default is 64k for

#               block-dirty-bitmap-add

#

# Since 2.4

##

{ 'type': 'BlockDirtyBitmapAdd',

  'data': { 'node': 'str', 'name': 'str', '*granularity': 'uint32' } }



##

# @block-dirty-bitmap-add

#

# Create a dirty bitmap with a name on the node

#

# Returns: nothing on success

#          If @node is not a valid block device or node, DeviceNotFound

#          If @name is already taken, GenericError with an explanation

#

# Since 2.4

##

{ 'command': 'block-dirty-bitmap-add',

  'data': 'BlockDirtyBitmapAdd' }



##

# @block-dirty-bitmap-remove

#

# Remove a dirty bitmap on the node

#

# Returns: nothing on success

#          If @node is not a valid block device or node, DeviceNotFound

#          If @name is not found, GenericError with an explanation

#

# Since 2.4

##

{ 'command': 'block-dirty-bitmap-remove',

  'data': 'BlockDirtyBitmap' }



##

# @block_set_io_throttle:

#