Commit 7ab74849 authored by Chunyan Liu's avatar Chunyan Liu Committed by Stefan Hajnoczi
Browse files

qed.c: replace QEMUOptionParameter with QemuOpts 



One extra change is to define QED_DEFAULT_CLUSTER_SIZE = 65536 instead
of 64 * 1024; because:
according to existing create_options, "cluster size" has default value =
QED_DEFAULT_CLUSTER_SIZE, after switching to create_opts, this has to be
stringized and set to .def_value_str. That is,
  .def_value_str = stringify(QED_DEFAULT_CLUSTER_SIZE),
so the QED_DEFAULT_CLUSTER_SIZE could not be a expression.

Reviewed-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: default avatarEric Blake <eblake@redhat.com>
Signed-off-by: default avatarDong Xu Wang <wdongxu@linux.vnet.ibm.com>
Signed-off-by: default avatarChunyan Liu <cyliu@suse.com>
Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
parent 1bd0e2d1

block/qed.c

+60 −54
Original line number Diff line number Diff line
@@ -641,55 +641,53 @@ out: 
    return ret;

}



static int bdrv_qed_create(const char *filename, QEMUOptionParameter *options,

                           Error **errp)

static int bdrv_qed_create(const char *filename, QemuOpts *opts, Error **errp)

{

    uint64_t image_size = 0;

    uint32_t cluster_size = QED_DEFAULT_CLUSTER_SIZE;

    uint32_t table_size = QED_DEFAULT_TABLE_SIZE;

    const char *backing_file = NULL;

    const char *backing_fmt = NULL;

    char *backing_file = NULL;

    char *backing_fmt = NULL;

    int ret;



    while (options && options->name) {

        if (!strcmp(options->name, BLOCK_OPT_SIZE)) {

            image_size = options->value.n;

        } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FILE)) {

            backing_file = options->value.s;

        } else if (!strcmp(options->name, BLOCK_OPT_BACKING_FMT)) {

            backing_fmt = options->value.s;

        } else if (!strcmp(options->name, BLOCK_OPT_CLUSTER_SIZE)) {

            if (options->value.n) {

                cluster_size = options->value.n;

            }

        } else if (!strcmp(options->name, BLOCK_OPT_TABLE_SIZE)) {

            if (options->value.n) {

                table_size = options->value.n;

            }

        }

        options++;

    }

    image_size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);

    backing_file = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);

    backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT);

    cluster_size = qemu_opt_get_size_del(opts,

                                         BLOCK_OPT_CLUSTER_SIZE,

                                         QED_DEFAULT_CLUSTER_SIZE);

    table_size = qemu_opt_get_size_del(opts, BLOCK_OPT_TABLE_SIZE,

                                       QED_DEFAULT_TABLE_SIZE);



    if (!qed_is_cluster_size_valid(cluster_size)) {

        error_setg(errp, "QED cluster size must be within range [%u, %u] "

                         "and power of 2",

                   QED_MIN_CLUSTER_SIZE, QED_MAX_CLUSTER_SIZE);

        return -EINVAL;

        ret = -EINVAL;

        goto finish;

    }

    if (!qed_is_table_size_valid(table_size)) {

        error_setg(errp, "QED table size must be within range [%u, %u] "

                         "and power of 2",

                   QED_MIN_TABLE_SIZE, QED_MAX_TABLE_SIZE);

        return -EINVAL;

        ret = -EINVAL;

        goto finish;

    }

    if (!qed_is_image_size_valid(image_size, cluster_size, table_size)) {

        error_setg(errp, "QED image size must be a non-zero multiple of "

                         "cluster size and less than %" PRIu64 " bytes",

                   qed_max_image_size(cluster_size, table_size));

        return -EINVAL;

        ret = -EINVAL;

        goto finish;

    }



    return qed_create(filename, cluster_size, image_size, table_size,

    ret = qed_create(filename, cluster_size, image_size, table_size,

                     backing_file, backing_fmt, errp);



finish:

    g_free(backing_file);

    g_free(backing_fmt);

    return ret;

}



typedef struct {
@@ -1616,43 +1614,51 @@ static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result, 
    return qed_check(s, result, !!fix);

}



static QEMUOptionParameter qed_create_options[] = {

static QemuOptsList qed_create_opts = {

    .name = "qed-create-opts",

    .head = QTAILQ_HEAD_INITIALIZER(qed_create_opts.head),

    .desc = {

        {

            .name = BLOCK_OPT_SIZE,

        .type = OPT_SIZE,

        .help = "Virtual disk size (in bytes)"

    }, {

            .type = QEMU_OPT_SIZE,

            .help = "Virtual disk size"

        },

        {

            .name = BLOCK_OPT_BACKING_FILE,

        .type = OPT_STRING,

            .type = QEMU_OPT_STRING,

            .help = "File name of a base image"

    }, {

        },

        {

            .name = BLOCK_OPT_BACKING_FMT,

        .type = OPT_STRING,

            .type = QEMU_OPT_STRING,

            .help = "Image format of the base image"

    }, {

        },

        {

            .name = BLOCK_OPT_CLUSTER_SIZE,

        .type = OPT_SIZE,

            .type = QEMU_OPT_SIZE,

            .help = "Cluster size (in bytes)",

        .value = { .n = QED_DEFAULT_CLUSTER_SIZE },

    }, {

            .def_value_str = stringify(QED_DEFAULT_CLUSTER_SIZE)

        },

        {

            .name = BLOCK_OPT_TABLE_SIZE,

        .type = OPT_SIZE,

            .type = QEMU_OPT_SIZE,

            .help = "L1/L2 table size (in clusters)"

        },

        { /* end of list */ }

    }

};



static BlockDriver bdrv_qed = {

    .format_name              = "qed",

    .instance_size            = sizeof(BDRVQEDState),

    .create_options           = qed_create_options,

    .create_opts              = &qed_create_opts,



    .bdrv_probe               = bdrv_qed_probe,

    .bdrv_rebind              = bdrv_qed_rebind,

    .bdrv_open                = bdrv_qed_open,

    .bdrv_close               = bdrv_qed_close,

    .bdrv_reopen_prepare      = bdrv_qed_reopen_prepare,

    .bdrv_create              = bdrv_qed_create,

    .bdrv_create2             = bdrv_qed_create,

    .bdrv_has_zero_init       = bdrv_has_zero_init_1,

    .bdrv_co_get_block_status = bdrv_qed_co_get_block_status,

    .bdrv_aio_readv           = bdrv_qed_aio_readv,

block/qed.h

+1 −2
Original line number Diff line number Diff line
@@ -43,7 +43,7 @@ 
 *

 * All fields are little-endian on disk.

 */



#define  QED_DEFAULT_CLUSTER_SIZE  65536

enum {

    QED_MAGIC = 'Q' | 'E' << 8 | 'D' << 16 | '\0' << 24,
@@ -69,7 +69,6 @@ enum { 
     */

    QED_MIN_CLUSTER_SIZE = 4 * 1024, /* in bytes */

    QED_MAX_CLUSTER_SIZE = 64 * 1024 * 1024,

    QED_DEFAULT_CLUSTER_SIZE = 64 * 1024,



    /* Allocated clusters are tracked using a 2-level pagetable.  Table size is

     * a multiple of clusters so large maximum image sizes can be supported