Commit 2d40fa69 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging 



Block patches for 2.1.0-rc0

# gpg: Signature made Fri 27 Jun 2014 19:50:32 BST using RSA key ID C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"

* remotes/kevin/tags/for-upstream: (47 commits)
  iotests: Fix 083 for out-of-tree builds
  iotests: Drop Python version from 065's Shebang
  iotests: Use $PYTHON for Python scripts
  iotests: Source common.env
  configure: Enable out-of-tree iotests
  iotests: Allow out-of-tree run
  block.c: Don't return success for bdrv_append_temp_snapshot() failure
  qemu-iotests: Add TestRepairQuorum to 041 to test drive-mirror node-name mode.
  block: Add replaces argument to drive-mirror
  blockjob: Fix recent BLOCK_JOB_ERROR regression
  blockjob: Fix recent BLOCK_JOB_READY regression
  virtio-blk: Rename complete_request_early to complete_request_vring
  virtio-blk: Unify {non-,}dataplane's request handlings
  virtio-blk: Schedule BH in the right context
  virtio-blk: Export request handling functions to dataplane
  virtio-blk: Make request completion function virtual
  block: acquire AioContext in qmp_query_blockstats()
  block: make bdrv_query_stats() static
  virtio-blk: Fix and clean up the in_sg and out_sg check
  virtio-blk: Fill in VirtIOBlockReq.out in dataplane code
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents ac8076ac f5264553

block.c

+167 −149
Original line number Diff line number Diff line
@@ -831,7 +831,7 @@ static int bdrv_open_flags(BlockDriverState *bs, int flags) 
     * Clear flags that are internal to the block layer before opening the

     * image.

     */

    open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

    open_flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_PROTOCOL);



    /*

     * Snapshots should be writable.
@@ -928,6 +928,7 @@ static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, 
    bs->zero_beyond_eof = true;

    open_flags = bdrv_open_flags(bs, flags);

    bs->read_only = !(open_flags & BDRV_O_RDWR);

    bs->growable = !!(flags & BDRV_O_PROTOCOL);



    if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {

        error_setg(errp,
@@ -1005,94 +1006,124 @@ free_and_fail: 
    return ret;

}



static QDict *parse_json_filename(const char *filename, Error **errp)

{

    QObject *options_obj;

    QDict *options;

    int ret;



    ret = strstart(filename, "json:", &filename);

    assert(ret);



    options_obj = qobject_from_json(filename);

    if (!options_obj) {

        error_setg(errp, "Could not parse the JSON options");

        return NULL;

    }



    if (qobject_type(options_obj) != QTYPE_QDICT) {

        qobject_decref(options_obj);

        error_setg(errp, "Invalid JSON object given");

        return NULL;

    }



    options = qobject_to_qdict(options_obj);

    qdict_flatten(options);



    return options;

}



/*

 * Opens a file using a protocol (file, host_device, nbd, ...)

 *

 * options is an indirect pointer to a QDict of options to pass to the block

 * drivers, or pointer to NULL for an empty set of options. If this function

 * takes ownership of the QDict reference, it will set *options to NULL;

 * otherwise, it will contain unused/unrecognized options after this function

 * returns. Then, the caller is responsible for freeing it. If it intends to

 * reuse the QDict, QINCREF() should be called beforehand.

 * Fills in default options for opening images and converts the legacy

 * filename/flags pair to option QDict entries.

 */

static int bdrv_file_open(BlockDriverState *bs, const char *filename,

                          QDict **options, int flags, Error **errp)

static int bdrv_fill_options(QDict **options, const char **pfilename, int flags,

                             BlockDriver *drv, Error **errp)

{

    BlockDriver *drv;

    const char *filename = *pfilename;

    const char *drvname;

    bool protocol = flags & BDRV_O_PROTOCOL;

    bool parse_filename = false;

    Error *local_err = NULL;

    int ret;



    /* Parse json: pseudo-protocol */

    if (filename && g_str_has_prefix(filename, "json:")) {

        QDict *json_options = parse_json_filename(filename, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

            return -EINVAL;

        }



        /* Options given in the filename have lower priority than options

         * specified directly */

        qdict_join(*options, json_options, false);

        QDECREF(json_options);

        *pfilename = filename = NULL;

    }



    /* Fetch the file name from the options QDict if necessary */

    if (!filename) {

        filename = qdict_get_try_str(*options, "filename");

    } else if (filename && !qdict_haskey(*options, "filename")) {

    if (protocol && filename) {

        if (!qdict_haskey(*options, "filename")) {

            qdict_put(*options, "filename", qstring_from_str(filename));

            parse_filename = true;

        } else {

        error_setg(errp, "Can't specify 'file' and 'filename' options at the "

                   "same time");

        ret = -EINVAL;

        goto fail;

            error_setg(errp, "Can't specify 'file' and 'filename' options at "

                             "the same time");

            return -EINVAL;

        }

    }



    /* Find the right block driver */

    filename = qdict_get_try_str(*options, "filename");

    drvname = qdict_get_try_str(*options, "driver");



    if (drv) {

        if (drvname) {

        drv = bdrv_find_format(drvname);

        if (!drv) {

            error_setg(errp, "Unknown driver '%s'", drvname);

            error_setg(errp, "Driver specified twice");

            return -EINVAL;

        }

        qdict_del(*options, "driver");

    } else if (filename) {

        drvname = drv->format_name;

        qdict_put(*options, "driver", qstring_from_str(drvname));

    } else {

        if (!drvname && protocol) {

            if (filename) {

                drv = bdrv_find_protocol(filename, parse_filename);

                if (!drv) {

                    error_setg(errp, "Unknown protocol");

                    return -EINVAL;

                }



                drvname = drv->format_name;

                qdict_put(*options, "driver", qstring_from_str(drvname));

            } else {

                error_setg(errp, "Must specify either driver or file");

        drv = NULL;

                return -EINVAL;

            }



        } else if (drvname) {

            drv = bdrv_find_format(drvname);

            if (!drv) {

        /* errp has been set already */

        ret = -ENOENT;

        goto fail;

                error_setg(errp, "Unknown driver '%s'", drvname);

                return -ENOENT;

            }

        }

    }



    assert(drv || !protocol);



    /* Parse the filename and open it */

    if (drv->bdrv_parse_filename && parse_filename) {

    /* Driver-specific filename parsing */

    if (drv && drv->bdrv_parse_filename && parse_filename) {

        drv->bdrv_parse_filename(filename, *options, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

            ret = -EINVAL;

            goto fail;

            return -EINVAL;

        }



        if (!drv->bdrv_needs_filename) {

            qdict_del(*options, "filename");

        } else {

            filename = qdict_get_str(*options, "filename");

        }

        }



    if (!drv->bdrv_file_open) {

        ret = bdrv_open(&bs, filename, NULL, *options, flags, drv, &local_err);

        *options = NULL;

    } else {

        ret = bdrv_open_common(bs, NULL, *options, flags, drv, &local_err);

    }

    if (ret < 0) {

        error_propagate(errp, local_err);

        goto fail;

    }



    bs->growable = 1;

    return 0;



fail:

    return ret;

}



void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd)
@@ -1162,6 +1193,13 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *options, Error **errp) 
        bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX);

    }



    if (!bs->drv || !bs->drv->supports_backing) {

        ret = -EINVAL;

        error_setg(errp, "Driver doesn't support backing files");

        QDECREF(options);

        goto free_exit;

    }



    backing_hd = bdrv_new("", errp);



    if (bs->backing_format[0] != '\0') {
@@ -1240,7 +1278,7 @@ done: 
    return ret;

}



void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)

int bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp)

{

    /* TODO: extra byte is a hack to ensure MAX_PATH space on Windows. */

    char *tmp_filename = g_malloc0(PATH_MAX + 1);
@@ -1258,6 +1296,7 @@ void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp) 
    /* Get the required size from the image */

    total_size = bdrv_getlength(bs);

    if (total_size < 0) {

        ret = total_size;

        error_setg_errno(errp, -total_size, "Could not get image size");

        goto out;

    }
@@ -1304,33 +1343,7 @@ void bdrv_append_temp_snapshot(BlockDriverState *bs, int flags, Error **errp) 


out:

    g_free(tmp_filename);

}



static QDict *parse_json_filename(const char *filename, Error **errp)

{

    QObject *options_obj;

    QDict *options;

    int ret;



    ret = strstart(filename, "json:", &filename);

    assert(ret);



    options_obj = qobject_from_json(filename);

    if (!options_obj) {

        error_setg(errp, "Could not parse the JSON options");

        return NULL;

    }



    if (qobject_type(options_obj) != QTYPE_QDICT) {

        qobject_decref(options_obj);

        error_setg(errp, "Invalid JSON object given");

        return NULL;

    }



    options = qobject_to_qdict(options_obj);

    qdict_flatten(options);



    return options;

    return ret;

}



/*
@@ -1396,38 +1409,36 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, 
        options = qdict_new();

    }



    if (filename && g_str_has_prefix(filename, "json:")) {

        QDict *json_options = parse_json_filename(filename, &local_err);

    ret = bdrv_fill_options(&options, &filename, flags, drv, &local_err);

    if (local_err) {

        goto fail;

    }



    /* Find the right image format driver */

    drv = NULL;

    drvname = qdict_get_try_str(options, "driver");

    if (drvname) {

        drv = bdrv_find_format(drvname);

        qdict_del(options, "driver");

        if (!drv) {

            error_setg(errp, "Unknown driver: '%s'", drvname);

            ret = -EINVAL;

            goto fail;

        }

    }



        /* Options given in the filename have lower priority than options

         * specified directly */

        qdict_join(options, json_options, false);

        QDECREF(json_options);

        filename = NULL;

    assert(drvname || !(flags & BDRV_O_PROTOCOL));

    if (drv && !drv->bdrv_file_open) {

        /* If the user explicitly wants a format driver here, we'll need to add

         * another layer for the protocol in bs->file */

        flags &= ~BDRV_O_PROTOCOL;

    }



    bs->options = options;

    options = qdict_clone_shallow(options);



    if (flags & BDRV_O_PROTOCOL) {

        assert(!drv);

        ret = bdrv_file_open(bs, filename, &options, flags & ~BDRV_O_PROTOCOL,

                             &local_err);

        if (!ret) {

            drv = bs->drv;

            goto done;

        } else if (bs->drv) {

            goto close_and_fail;

        } else {

            goto fail;

        }

    }



    /* Open image file without format layer */

    if ((flags & BDRV_O_PROTOCOL) == 0) {

        if (flags & BDRV_O_RDWR) {

            flags |= BDRV_O_ALLOW_RDWR;

        }
@@ -1443,30 +1454,17 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, 
        if (ret < 0) {

            goto fail;

        }



    /* Find the right image format driver */

    drvname = qdict_get_try_str(options, "driver");

    if (drvname) {

        drv = bdrv_find_format(drvname);

        qdict_del(options, "driver");

        if (!drv) {

            error_setg(errp, "Invalid driver: '%s'", drvname);

            ret = -EINVAL;

            goto fail;

        }

    }



    if (!drv) {

        if (file) {

    /* Image format probing */

    if (!drv && file) {

        ret = find_image_format(file, filename, &drv, &local_err);

        } else {

            error_setg(errp, "Must specify either driver or file");

            ret = -EINVAL;

        if (ret < 0) {

            goto fail;

        }

    }



    if (!drv) {

    } else if (!drv) {

        error_setg(errp, "Must specify either driver or file");

        ret = -EINVAL;

        goto fail;

    }
@@ -1495,15 +1493,12 @@ int bdrv_open(BlockDriverState **pbs, const char *filename, 
    /* For snapshot=on, create a temporary qcow2 overlay. bs points to the

     * temporary snapshot afterwards. */

    if (snapshot_flags) {

        bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);

        ret = bdrv_append_temp_snapshot(bs, snapshot_flags, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

            goto close_and_fail;

        }

    }





done:

    /* Check if any unknown options were used */

    if (options && (qdict_size(options) != 0)) {

        const QDictEntry *entry = qdict_first(options);
@@ -3489,9 +3484,7 @@ int bdrv_truncate(BlockDriverState *bs, int64_t offset) 
        return -ENOTSUP;

    if (bs->read_only)

        return -EACCES;

    if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_RESIZE, NULL)) {

        return -EBUSY;

    }



    ret = drv->bdrv_truncate(bs, offset);

    if (ret == 0) {

        ret = refresh_total_sectors(bs, offset >> BDRV_SECTOR_BITS);
@@ -5774,3 +5767,28 @@ bool bdrv_is_first_non_filter(BlockDriverState *candidate) 


    return false;

}



BlockDriverState *check_to_replace_node(const char *node_name, Error **errp)

{

    BlockDriverState *to_replace_bs = bdrv_find_node(node_name);

    if (!to_replace_bs) {

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

        return NULL;

    }



    if (bdrv_op_is_blocked(to_replace_bs, BLOCK_OP_TYPE_REPLACE, errp)) {

        return NULL;

    }



    /* We don't want arbitrary node of the BDS chain to be replaced only the top

     * most non filter in order to prevent data corruption.

     * Another benefit is that this tests exclude backing files which are

     * blocked by the backing blockers.

     */

    if (!bdrv_is_first_non_filter(to_replace_bs)) {

        error_setg(errp, "Only top most non filter can be replaced");

        return NULL;

    }



    return to_replace_bs;

}

block/cow.c

+1 −0
Original line number Diff line number Diff line
@@ -414,6 +414,7 @@ static BlockDriver bdrv_cow = { 
    .bdrv_close     = cow_close,

    .bdrv_create    = cow_create,

    .bdrv_has_zero_init     = bdrv_has_zero_init_1,

    .supports_backing       = true,



    .bdrv_read              = cow_co_read,

    .bdrv_write             = cow_co_write,

block/mirror.c

+57 −14
Original line number Diff line number Diff line
@@ -32,6 +32,12 @@ typedef struct MirrorBlockJob { 
    RateLimit limit;

    BlockDriverState *target;

    BlockDriverState *base;

    /* The name of the graph node to replace */

    char *replaces;

    /* The BDS to replace */

    BlockDriverState *to_replace;

    /* Used to block operations on the drive-mirror-replace target */

    Error *replace_blocker;

    bool is_none_mode;

    BlockdevOnError on_source_error, on_target_error;

    bool synced;
@@ -324,9 +330,18 @@ static void coroutine_fn mirror_run(void *opaque) 
    }



    s->common.len = bdrv_getlength(bs);

    if (s->common.len <= 0) {

    if (s->common.len < 0) {

        ret = s->common.len;

        goto immediate_exit;

    } else if (s->common.len == 0) {

        /* Report BLOCK_JOB_READY and wait for complete. */

        block_job_event_ready(&s->common);

        s->synced = true;

        while (!block_job_is_cancelled(&s->common) && !s->should_complete) {

            block_job_yield(&s->common);

        }

        s->common.cancelled = false;

        goto immediate_exit;

    }



    length = DIV_ROUND_UP(s->common.len, s->granularity);
@@ -491,10 +506,14 @@ immediate_exit: 
    bdrv_release_dirty_bitmap(bs, s->dirty_bitmap);

    bdrv_iostatus_disable(s->target);

    if (s->should_complete && ret == 0) {

        if (bdrv_get_flags(s->target) != bdrv_get_flags(s->common.bs)) {

            bdrv_reopen(s->target, bdrv_get_flags(s->common.bs), NULL);

        BlockDriverState *to_replace = s->common.bs;

        if (s->to_replace) {

            to_replace = s->to_replace;

        }

        if (bdrv_get_flags(s->target) != bdrv_get_flags(to_replace)) {

            bdrv_reopen(s->target, bdrv_get_flags(to_replace), NULL);

        }

        bdrv_swap(s->target, s->common.bs);

        bdrv_swap(s->target, to_replace);

        if (s->common.driver->job_type == BLOCK_JOB_TYPE_COMMIT) {

            /* drop the bs loop chain formed by the swap: break the loop then

             * trigger the unref from the top one */
@@ -503,6 +522,12 @@ immediate_exit: 
            bdrv_unref(p);

        }

    }

    if (s->to_replace) {

        bdrv_op_unblock_all(s->to_replace, s->replace_blocker);

        error_free(s->replace_blocker);

        bdrv_unref(s->to_replace);

    }

    g_free(s->replaces);

    bdrv_unref(s->target);

    block_job_completed(&s->common, ret);

}
@@ -541,6 +566,20 @@ static void mirror_complete(BlockJob *job, Error **errp) 
        return;

    }



    /* check the target bs is not blocked and block all operations on it */

    if (s->replaces) {

        s->to_replace = check_to_replace_node(s->replaces, &local_err);

        if (!s->to_replace) {

            error_propagate(errp, local_err);

            return;

        }



        error_setg(&s->replace_blocker,

                   "block device is in use by block-job-complete");

        bdrv_op_block_all(s->to_replace, s->replace_blocker);

        bdrv_ref(s->to_replace);

    }



    s->should_complete = true;

    block_job_resume(job);

}
@@ -563,6 +602,7 @@ static const BlockJobDriver commit_active_job_driver = { 
};



static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target,

                             const char *replaces,

                             int64_t speed, int64_t granularity,

                             int64_t buf_size,

                             BlockdevOnError on_source_error,
@@ -601,6 +641,7 @@ static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target, 
        return;

    }



    s->replaces = g_strdup(replaces);

    s->on_source_error = on_source_error;

    s->on_target_error = on_target_error;

    s->target = target;
@@ -622,6 +663,7 @@ static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target, 
}



void mirror_start(BlockDriverState *bs, BlockDriverState *target,

                  const char *replaces,

                  int64_t speed, int64_t granularity, int64_t buf_size,

                  MirrorSyncMode mode, BlockdevOnError on_source_error,

                  BlockdevOnError on_target_error,
@@ -633,7 +675,8 @@ void mirror_start(BlockDriverState *bs, BlockDriverState *target, 


    is_none_mode = mode == MIRROR_SYNC_MODE_NONE;

    base = mode == MIRROR_SYNC_MODE_TOP ? bs->backing_hd : NULL;

    mirror_start_job(bs, target, speed, granularity, buf_size,

    mirror_start_job(bs, target, replaces,

                     speed, granularity, buf_size,

                     on_source_error, on_target_error, cb, opaque, errp,

                     &mirror_job_driver, is_none_mode, base);

}
@@ -681,7 +724,7 @@ void commit_active_start(BlockDriverState *bs, BlockDriverState *base, 
    }



    bdrv_ref(base);

    mirror_start_job(bs, base, speed, 0, 0,

    mirror_start_job(bs, base, NULL, speed, 0, 0,

                     on_error, on_error, cb, opaque, &local_err,

                     &commit_active_job_driver, false, base);

    if (local_err) {

block/nfs.c

+16 −6
Original line number Diff line number Diff line
@@ -304,17 +304,27 @@ static int64_t nfs_client_open(NFSClient *client, const char *filename, 


    qp = query_params_parse(uri->query);

    for (i = 0; i < qp->n; i++) {

        unsigned long long val;

        if (!qp->p[i].value) {

            error_setg(errp, "Value for NFS parameter expected: %s",

                       qp->p[i].name);

            goto fail;

        }

        if (!strncmp(qp->p[i].name, "uid", 3)) {

            nfs_set_uid(client->context, atoi(qp->p[i].value));

        } else if (!strncmp(qp->p[i].name, "gid", 3)) {

            nfs_set_gid(client->context, atoi(qp->p[i].value));

        } else if (!strncmp(qp->p[i].name, "tcp-syncnt", 10)) {

            nfs_set_tcp_syncnt(client->context, atoi(qp->p[i].value));

        if (parse_uint_full(qp->p[i].value, &val, 0)) {

            error_setg(errp, "Illegal value for NFS parameter: %s",

                       qp->p[i].name);

            goto fail;

        }

        if (!strcmp(qp->p[i].name, "uid")) {

            nfs_set_uid(client->context, val);

        } else if (!strcmp(qp->p[i].name, "gid")) {

            nfs_set_gid(client->context, val);

        } else if (!strcmp(qp->p[i].name, "tcp-syncnt")) {

            nfs_set_tcp_syncnt(client->context, val);

#ifdef LIBNFS_FEATURE_READAHEAD

        } else if (!strcmp(qp->p[i].name, "readahead")) {

            nfs_set_readahead(client->context, val);

#endif

        } else {

            error_setg(errp, "Unknown NFS parameter name: %s",

                       qp->p[i].name);

block/qapi.c

+5 −1
Original line number Diff line number Diff line
@@ -293,7 +293,7 @@ void bdrv_query_info(BlockDriverState *bs, 
    qapi_free_BlockInfo(info);

}



BlockStats *bdrv_query_stats(const BlockDriverState *bs)

static BlockStats *bdrv_query_stats(const BlockDriverState *bs)

{

    BlockStats *s;
@@ -360,7 +360,11 @@ BlockStatsList *qmp_query_blockstats(Error **errp) 


     while ((bs = bdrv_next(bs))) {

        BlockStatsList *info = g_malloc0(sizeof(*info));

        AioContext *ctx = bdrv_get_aio_context(bs);



        aio_context_acquire(ctx);

        info->value = bdrv_query_stats(bs);

        aio_context_release(ctx);



        *p_next = info;

        p_next = &info->next;