Commit 84219c5a authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging 



Block pull request

# gpg: Signature made Mon 16 Jun 2014 12:22:22 BST using RSA key ID 81AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>"
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>"

* remotes/stefanha/tags/block-pull-request: (39 commits)
  QemuOpts: cleanup tmp 'allocated' member from QemuOptsList
  cleanup QEMUOptionParameter
  vpc.c: replace QEMUOptionParameter with QemuOpts
  vmdk.c: replace QEMUOptionParameter with QemuOpts
  vhdx.c: replace QEMUOptionParameter with QemuOpts
  vdi.c: replace QEMUOptionParameter with QemuOpts
  ssh.c: replace QEMUOptionParameter with QemuOpts
  sheepdog.c: replace QEMUOptionParameter with QemuOpts
  rbd.c: replace QEMUOptionParameter with QemuOpts
  raw_bsd.c: replace QEMUOptionParameter with QemuOpts
  raw-win32.c: replace QEMUOptionParameter with QemuOpts
  raw-posix.c: replace QEMUOptionParameter with QemuOpts
  qed.c: replace QEMUOptionParameter with QemuOpts
  qcow2.c: replace QEMUOptionParameter with QemuOpts
  QemuOpts: export qemu_opt_find
  qcow.c: replace QEMUOptionParameter with QemuOpts
  nfs.c: replace QEMUOptionParameter with QemuOpts
  iscsi.c: replace QEMUOptionParameter with QemuOpts
  gluster.c: replace QEMUOptionParameter with QemuOpts
  cow.c: replace QEMUOptionParameter with QemuOpts
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 0bbac626 98d896d9

block.c

+47 −52
Original line number Diff line number Diff line
@@ -424,7 +424,7 @@ BlockDriver *bdrv_find_whitelisted_format(const char *format_name, 
typedef struct CreateCo {

    BlockDriver *drv;

    char *filename;

    QEMUOptionParameter *options;

    QemuOpts *opts;

    int ret;

    Error *err;

} CreateCo;
@@ -437,7 +437,7 @@ static void coroutine_fn bdrv_create_co_entry(void *opaque) 
    CreateCo *cco = opaque;

    assert(cco->drv);



    ret = cco->drv->bdrv_create(cco->filename, cco->options, &local_err);

    ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);

    if (local_err) {

        error_propagate(&cco->err, local_err);

    }
@@ -445,7 +445,7 @@ static void coroutine_fn bdrv_create_co_entry(void *opaque) 
}



int bdrv_create(BlockDriver *drv, const char* filename,

    QEMUOptionParameter *options, Error **errp)

                QemuOpts *opts, Error **errp)

{

    int ret;
@@ -453,7 +453,7 @@ int bdrv_create(BlockDriver *drv, const char* filename, 
    CreateCo cco = {

        .drv = drv,

        .filename = g_strdup(filename),

        .options = options,

        .opts = opts,

        .ret = NOT_DONE,

        .err = NULL,

    };
@@ -489,8 +489,7 @@ out: 
    return ret;

}



int bdrv_create_file(const char* filename, QEMUOptionParameter *options,

                     Error **errp)

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

{

    BlockDriver *drv;

    Error *local_err = NULL;
@@ -502,7 +501,7 @@ int bdrv_create_file(const char* filename, QEMUOptionParameter *options, 
        return -ENOENT;

    }



    ret = bdrv_create(drv, filename, options, &local_err);

    ret = bdrv_create(drv, filename, opts, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

    }
@@ -1247,7 +1246,7 @@ void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp) 
    char *tmp_filename = g_malloc0(PATH_MAX + 1);

    int64_t total_size;

    BlockDriver *bdrv_qcow2;

    QEMUOptionParameter *create_options;

    QemuOpts *opts = NULL;

    QDict *snapshot_options;

    BlockDriverState *bs_snapshot;

    Error *local_err;
@@ -1272,13 +1271,11 @@ void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp) 
    }



    bdrv_qcow2 = bdrv_find_format("qcow2");

    create_options = parse_option_parameters("", bdrv_qcow2->create_options,

                                             NULL);



    set_option_parameter_int(create_options, BLOCK_OPT_SIZE, total_size);



    ret = bdrv_create(bdrv_qcow2, tmp_filename, create_options, &local_err);

    free_option_parameters(create_options);

    opts = qemu_opts_create(bdrv_qcow2->create_opts, NULL, 0,

                            &error_abort);

    qemu_opt_set_number(opts, BLOCK_OPT_SIZE, total_size);

    ret = bdrv_create(bdrv_qcow2, tmp_filename, opts, &local_err);

    qemu_opts_del(opts);

    if (ret < 0) {

        error_setg_errno(errp, -ret, "Could not create temporary overlay "

                         "'%s': %s", tmp_filename,
@@ -5519,8 +5516,10 @@ void bdrv_img_create(const char *filename, const char *fmt, 
                     char *options, uint64_t img_size, int flags,

                     Error **errp, bool quiet)

{

    QEMUOptionParameter *param = NULL, *create_options = NULL;

    QEMUOptionParameter *backing_fmt, *backing_file, *size;

    QemuOptsList *create_opts = NULL;

    QemuOpts *opts = NULL;

    const char *backing_fmt, *backing_file;

    int64_t size;

    BlockDriver *drv, *proto_drv;

    BlockDriver *backing_drv = NULL;

    Error *local_err = NULL;
@@ -5539,28 +5538,23 @@ void bdrv_img_create(const char *filename, const char *fmt, 
        return;

    }



    create_options = append_option_parameters(create_options,

                                              drv->create_options);

    create_options = append_option_parameters(create_options,

                                              proto_drv->create_options);

    create_opts = qemu_opts_append(create_opts, drv->create_opts);

    create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);



    /* Create parameter list with default values */

    param = parse_option_parameters("", create_options, param);



    set_option_parameter_int(param, BLOCK_OPT_SIZE, img_size);

    opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);

    qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size);



    /* Parse -o options */

    if (options) {

        param = parse_option_parameters(options, create_options, param);

        if (param == NULL) {

            error_setg(errp, "Invalid options for file format '%s'.", fmt);

        if (qemu_opts_do_parse(opts, options, NULL) != 0) {

            error_setg(errp, "Invalid options for file format '%s'", fmt);

            goto out;

        }

    }



    if (base_filename) {

        if (set_option_parameter(param, BLOCK_OPT_BACKING_FILE,

                                 base_filename)) {

        if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename)) {

            error_setg(errp, "Backing file not supported for file format '%s'",

                       fmt);

            goto out;
@@ -5568,37 +5562,37 @@ void bdrv_img_create(const char *filename, const char *fmt, 
    }



    if (base_fmt) {

        if (set_option_parameter(param, BLOCK_OPT_BACKING_FMT, base_fmt)) {

        if (qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, base_fmt)) {

            error_setg(errp, "Backing file format not supported for file "

                             "format '%s'", fmt);

            goto out;

        }

    }



    backing_file = get_option_parameter(param, BLOCK_OPT_BACKING_FILE);

    if (backing_file && backing_file->value.s) {

        if (!strcmp(filename, backing_file->value.s)) {

    backing_file = qemu_opt_get(opts, BLOCK_OPT_BACKING_FILE);

    if (backing_file) {

        if (!strcmp(filename, backing_file)) {

            error_setg(errp, "Error: Trying to create an image with the "

                             "same filename as the backing file");

            goto out;

        }

    }



    backing_fmt = get_option_parameter(param, BLOCK_OPT_BACKING_FMT);

    if (backing_fmt && backing_fmt->value.s) {

        backing_drv = bdrv_find_format(backing_fmt->value.s);

    backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);

    if (backing_fmt) {

        backing_drv = bdrv_find_format(backing_fmt);

        if (!backing_drv) {

            error_setg(errp, "Unknown backing file format '%s'",

                       backing_fmt->value.s);

                       backing_fmt);

            goto out;

        }

    }



    // The size for the image must always be specified, with one exception:

    // If we are using a backing file, we can obtain the size from there

    size = get_option_parameter(param, BLOCK_OPT_SIZE);

    if (size && size->value.n == -1) {

        if (backing_file && backing_file->value.s) {

    size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);

    if (size == -1) {

        if (backing_file) {

            BlockDriverState *bs;

            uint64_t size;

            char buf[32];
@@ -5609,11 +5603,11 @@ void bdrv_img_create(const char *filename, const char *fmt, 
                flags & ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);



            bs = NULL;

            ret = bdrv_open(&bs, backing_file->value.s, NULL, NULL, back_flags,

            ret = bdrv_open(&bs, backing_file, NULL, NULL, back_flags,

                            backing_drv, &local_err);

            if (ret < 0) {

                error_setg_errno(errp, -ret, "Could not open '%s': %s",

                                 backing_file->value.s,

                                 backing_file,

                                 error_get_pretty(local_err));

                error_free(local_err);

                local_err = NULL;
@@ -5623,7 +5617,7 @@ void bdrv_img_create(const char *filename, const char *fmt, 
            size *= 512;



            snprintf(buf, sizeof(buf), "%" PRId64, size);

            set_option_parameter(param, BLOCK_OPT_SIZE, buf);

            qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size);



            bdrv_unref(bs);

        } else {
@@ -5634,16 +5628,18 @@ void bdrv_img_create(const char *filename, const char *fmt, 


    if (!quiet) {

        printf("Formatting '%s', fmt=%s ", filename, fmt);

        print_option_parameters(param);

        qemu_opts_print(opts);

        puts("");

    }

    ret = bdrv_create(drv, filename, param, &local_err);



    ret = bdrv_create(drv, filename, opts, &local_err);



    if (ret == -EFBIG) {

        /* This is generally a better message than whatever the driver would

         * deliver (especially because of the cluster_size_hint), since that

         * is most probably not much different from "image too large". */

        const char *cluster_size_hint = "";

        if (get_option_parameter(create_options, BLOCK_OPT_CLUSTER_SIZE)) {

        if (qemu_opt_get_size(opts, BLOCK_OPT_CLUSTER_SIZE, 0)) {

            cluster_size_hint = " (try using a larger cluster size)";

        }

        error_setg(errp, "The image size is too large for file format '%s'"
@@ -5653,9 +5649,8 @@ void bdrv_img_create(const char *filename, const char *fmt, 
    }



out:

    free_option_parameters(create_options);

    free_option_parameters(param);



    qemu_opts_del(opts);

    qemu_opts_free(create_opts);

    if (local_err) {

        error_propagate(errp, local_err);

    }
@@ -5731,12 +5726,12 @@ void bdrv_add_before_write_notifier(BlockDriverState *bs, 
    notifier_with_return_list_add(&bs->before_write_notifiers, notifier);

}



int bdrv_amend_options(BlockDriverState *bs, QEMUOptionParameter *options)

int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts)

{

    if (bs->drv->bdrv_amend_options == NULL) {

    if (!bs->drv->bdrv_amend_options) {

        return -ENOTSUP;

    }

    return bs->drv->bdrv_amend_options(bs, options);

    return bs->drv->bdrv_amend_options(bs, opts);

}



/* This function will be called by the bdrv_recurse_is_first_non_filter method

block/cow.c

+25 −27
Original line number Diff line number Diff line
@@ -324,31 +324,24 @@ static void cow_close(BlockDriverState *bs) 
{

}



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

                      Error **errp)

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

{

    struct cow_header_v2 cow_header;

    struct stat st;

    int64_t image_sectors = 0;

    const char *image_filename = NULL;

    char *image_filename = NULL;

    Error *local_err = NULL;

    int ret;

    BlockDriverState *cow_bs;



    /* Read out options */

    while (options && options->name) {

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

            image_sectors = options->value.n / 512;

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

            image_filename = options->value.s;

        }

        options++;

    }

    image_sectors = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0) / 512;

    image_filename = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FILE);



    ret = bdrv_create_file(filename, options, &local_err);

    ret = bdrv_create_file(filename, opts, &local_err);

    if (ret < 0) {

        error_propagate(errp, local_err);

        return ret;

        goto exit;

    }



    cow_bs = NULL;
@@ -356,7 +349,7 @@ static int cow_create(const char *filename, QEMUOptionParameter *options, 
                    BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err);

    if (ret < 0) {

        error_propagate(errp, local_err);

        return ret;

        goto exit;

    }



    memset(&cow_header, 0, sizeof(cow_header));
@@ -389,22 +382,27 @@ static int cow_create(const char *filename, QEMUOptionParameter *options, 
    }



exit:

    g_free(image_filename);

    bdrv_unref(cow_bs);

    return ret;

}



static QEMUOptionParameter cow_create_options[] = {

static QemuOptsList cow_create_opts = {

    .name = "cow-create-opts",

    .head = QTAILQ_HEAD_INITIALIZER(cow_create_opts.head),

    .desc = {

        {

            .name = BLOCK_OPT_SIZE,

        .type = OPT_SIZE,

            .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"

        },

    { NULL }

        { /* end of list */ }

    }

};



static BlockDriver bdrv_cow = {
@@ -421,7 +419,7 @@ static BlockDriver bdrv_cow = { 
    .bdrv_write             = cow_co_write,

    .bdrv_co_get_block_status   = cow_co_get_block_status,



    .create_options = cow_create_options,

    .create_opts    = &cow_create_opts,

};



static void bdrv_cow_init(void)

block/curl.c

+3 −6
Original line number Diff line number Diff line
@@ -440,11 +440,9 @@ static void curl_detach_aio_context(BlockDriverState *bs) 
            curl_easy_cleanup(s->states[i].curl);

            s->states[i].curl = NULL;

        }

        if (s->states[i].orig_buf) {

        g_free(s->states[i].orig_buf);

        s->states[i].orig_buf = NULL;

    }

    }

    if (s->multi) {

        curl_multi_cleanup(s->multi);

        s->multi = NULL;
@@ -638,7 +636,6 @@ static void curl_readv_bh_cb(void *p) 
    acb->end = (acb->nb_sectors * SECTOR_SIZE);



    state->buf_off = 0;

    if (state->orig_buf)

    g_free(state->orig_buf);

    state->buf_start = start;

    state->buf_len = acb->end + s->readahead_size;

block/gluster.c

+38 −35
Original line number Diff line number Diff line
@@ -478,13 +478,14 @@ static inline int qemu_gluster_zerofill(struct glfs_fd *fd, int64_t offset, 
#endif



static int qemu_gluster_create(const char *filename,

        QEMUOptionParameter *options, Error **errp)

                               QemuOpts *opts, Error **errp)

{

    struct glfs *glfs;

    struct glfs_fd *fd;

    int ret = 0;

    int prealloc = 0;

    int64_t total_size = 0;

    char *tmp = NULL;

    GlusterConf *gconf = g_malloc0(sizeof(GlusterConf));



    glfs = qemu_gluster_init(gconf, filename, errp);
@@ -493,25 +494,22 @@ static int qemu_gluster_create(const char *filename, 
        goto out;

    }



    while (options && options->name) {

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

            total_size = options->value.n / BDRV_SECTOR_SIZE;

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

            if (!options->value.s || !strcmp(options->value.s, "off")) {

    total_size =

        qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0) / BDRV_SECTOR_SIZE;



    tmp = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);

    if (!tmp || !strcmp(tmp, "off")) {

        prealloc = 0;

            } else if (!strcmp(options->value.s, "full") &&

    } else if (!strcmp(tmp, "full") &&

               gluster_supports_zerofill()) {

        prealloc = 1;

    } else {

        error_setg(errp, "Invalid preallocation mode: '%s'"

            " or GlusterFS doesn't support zerofill API",

                           options->value.s);

            tmp);

        ret = -EINVAL;

        goto out;

    }

        }

        options++;

    }



    fd = glfs_creat(glfs, gconf->image,

        O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRUSR | S_IWUSR);
@@ -532,6 +530,7 @@ static int qemu_gluster_create(const char *filename, 
        }

    }

out:

    g_free(tmp);

    qemu_gluster_gconf_free(gconf);

    if (glfs) {

        glfs_fini(glfs);
@@ -698,18 +697,22 @@ static int qemu_gluster_has_zero_init(BlockDriverState *bs) 
    return 0;

}



static QEMUOptionParameter qemu_gluster_create_options[] = {

static QemuOptsList qemu_gluster_create_opts = {

    .name = "qemu-gluster-create-opts",

    .head = QTAILQ_HEAD_INITIALIZER(qemu_gluster_create_opts.head),

    .desc = {

        {

            .name = BLOCK_OPT_SIZE,

        .type = OPT_SIZE,

            .type = QEMU_OPT_SIZE,

            .help = "Virtual disk size"

        },

        {

            .name = BLOCK_OPT_PREALLOC,

        .type = OPT_STRING,

            .type = QEMU_OPT_STRING,

            .help = "Preallocation mode (allowed values: off, full)"

        },

    { NULL }

        { /* end of list */ }

    }

};



static BlockDriver bdrv_gluster = {
@@ -736,7 +739,7 @@ static BlockDriver bdrv_gluster = { 
#ifdef CONFIG_GLUSTERFS_ZEROFILL

    .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,

#endif

    .create_options               = qemu_gluster_create_options,

    .create_opts                  = &qemu_gluster_create_opts,

};



static BlockDriver bdrv_gluster_tcp = {
@@ -763,7 +766,7 @@ static BlockDriver bdrv_gluster_tcp = { 
#ifdef CONFIG_GLUSTERFS_ZEROFILL

    .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,

#endif

    .create_options               = qemu_gluster_create_options,

    .create_opts                  = &qemu_gluster_create_opts,

};



static BlockDriver bdrv_gluster_unix = {
@@ -790,7 +793,7 @@ static BlockDriver bdrv_gluster_unix = { 
#ifdef CONFIG_GLUSTERFS_ZEROFILL

    .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,

#endif

    .create_options               = qemu_gluster_create_options,

    .create_opts                  = &qemu_gluster_create_opts,

};



static BlockDriver bdrv_gluster_rdma = {
@@ -817,7 +820,7 @@ static BlockDriver bdrv_gluster_rdma = { 
#ifdef CONFIG_GLUSTERFS_ZEROFILL

    .bdrv_co_write_zeroes         = qemu_gluster_co_write_zeroes,

#endif

    .create_options               = qemu_gluster_create_options,

    .create_opts                  = &qemu_gluster_create_opts,

};



static void bdrv_gluster_init(void)

block/iscsi.c

+16 −20
Original line number Diff line number Diff line
@@ -1434,9 +1434,7 @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags, 


out:

    qemu_opts_del(opts);

    if (initiator_name != NULL) {

    g_free(initiator_name);

    }

    if (iscsi_url != NULL) {

        iscsi_destroy_url(iscsi_url);

    }
@@ -1532,8 +1530,7 @@ static int iscsi_truncate(BlockDriverState *bs, int64_t offset) 
    return 0;

}



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

                        Error **errp)

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

{

    int ret = 0;

    int64_t total_size = 0;
@@ -1544,13 +1541,8 @@ static int iscsi_create(const char *filename, QEMUOptionParameter *options, 
    bs = bdrv_new("", &error_abort);



    /* Read out options */

    while (options && options->name) {

        if (!strcmp(options->name, "size")) {

            total_size = options->value.n / BDRV_SECTOR_SIZE;

        }

        options++;

    }



    total_size =

        qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0) / BDRV_SECTOR_SIZE;

    bs->opaque = g_malloc0(sizeof(struct IscsiLun));

    iscsilun = bs->opaque;
@@ -1592,13 +1584,17 @@ static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi) 
    return 0;

}



static QEMUOptionParameter iscsi_create_options[] = {

static QemuOptsList iscsi_create_opts = {

    .name = "iscsi-create-opts",

    .head = QTAILQ_HEAD_INITIALIZER(iscsi_create_opts.head),

    .desc = {

        {

            .name = BLOCK_OPT_SIZE,

        .type = OPT_SIZE,

            .type = QEMU_OPT_SIZE,

            .help = "Virtual disk size"

        },

    { NULL }

        { /* end of list */ }

    }

};



static BlockDriver bdrv_iscsi = {
@@ -1610,7 +1606,7 @@ static BlockDriver bdrv_iscsi = { 
    .bdrv_file_open  = iscsi_open,

    .bdrv_close      = iscsi_close,

    .bdrv_create     = iscsi_create,

    .create_options  = iscsi_create_options,

    .create_opts     = &iscsi_create_opts,

    .bdrv_reopen_prepare  = iscsi_reopen_prepare,



    .bdrv_getlength  = iscsi_getlength,