Commit 53b080fa authored by Peter Maydell's avatar Peter Maydell
Browse files

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



Block layer patches for 2.10.0-rc2

# gpg: Signature made Tue 08 Aug 2017 14:56:15 BST
# gpg:                using RSA key 0x7F09B272C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>"
# Primary key fingerprint: DC3D EB15 9A9A F95D 3D74  56FE 7F09 B272 C88F 2FD6

* remotes/kevin/tags/for-upstream:
  block/nfs: fix mutex assertion in nfs_file_close()
  qemu-iotests: Test reopen between read-only and read-write
  qemu-io: Allow reopen read-write
  block: Set BDRV_O_ALLOW_RDWR during rw reopen
  block: Allow reopen rw without BDRV_O_ALLOW_RDWR
  block: Fix order in bdrv_replace_child()
  parallels: drop check that bdrv_truncate() is working
  parallels: respect error code of bdrv_getlength() in allocate_clusters()
  block: respect error code from bdrv_getlength in handle_aiocb_write_zeroes
  vmdk: Fix error handling/reporting of vmdk_check
  block/null: Remove 'filename' option
  block: drop bdrv_set_key from BlockDriver
  block/vhdx: check error return of bdrv_truncate()
  block/vhdx: check error return of bdrv_flush()
  block/vhdx: check for offset overflow to bdrv_truncate()
  block/vhdx: check error return of bdrv_getlength()
  quorum: Set sectors-count to 0 when reporting a flush error
  qemu-iotests/109: Fix lock race condition

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents b4174c4b 113fe792

block.c

+13 −7
Original line number Diff line number Diff line
@@ -246,7 +246,8 @@ bool bdrv_is_writable(BlockDriverState *bs) 
    return !bdrv_is_read_only(bs) && !(bs->open_flags & BDRV_O_INACTIVE);

}



int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only,

                           bool ignore_allow_rdw, Error **errp)

{

    /* Do not set read_only if copy_on_read is enabled */

    if (bs->copy_on_read && read_only) {
@@ -256,7 +257,9 @@ int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp) 
    }



    /* Do not clear read_only if it is prohibited */

    if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR)) {

    if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR) &&

        !ignore_allow_rdw)

    {

        error_setg(errp, "Node '%s' is read only",

                   bdrv_get_device_or_node_name(bs));

        return -EPERM;
@@ -269,7 +272,7 @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp) 
{

    int ret = 0;



    ret = bdrv_can_set_read_only(bs, read_only, errp);

    ret = bdrv_can_set_read_only(bs, read_only, false, errp);

    if (ret < 0) {

        return ret;

    }
@@ -1933,6 +1936,8 @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs) 
    BlockDriverState *old_bs = child->bs;

    uint64_t perm, shared_perm;



    bdrv_replace_child_noperm(child, new_bs);



    if (old_bs) {

        /* Update permissions for old node. This is guaranteed to succeed

         * because we're just taking a parent away, so we're loosening
@@ -1942,8 +1947,6 @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs) 
        bdrv_set_perm(old_bs, perm, shared_perm);

    }



    bdrv_replace_child_noperm(child, new_bs);



    if (new_bs) {

        bdrv_get_cumulative_perm(new_bs, &perm, &shared_perm);

        bdrv_set_perm(new_bs, perm, shared_perm);
@@ -2726,8 +2729,11 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue, 
    bdrv_join_options(bs, options, old_options);

    QDECREF(old_options);



    /* bdrv_open() masks this flag out */

    /* bdrv_open_inherit() sets and clears some additional flags internally */

    flags &= ~BDRV_O_PROTOCOL;

    if (flags & BDRV_O_RDWR) {

        flags |= BDRV_O_ALLOW_RDWR;

    }



    QLIST_FOREACH(child, &bs->children, next) {

        QDict *new_child_options;
@@ -2907,7 +2913,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue, 
     * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is

     * not set, or if the BDS still has copy_on_read enabled */

    read_only = !(reopen_state->flags & BDRV_O_RDWR);

    ret = bdrv_can_set_read_only(reopen_state->bs, read_only, &local_err);

    ret = bdrv_can_set_read_only(reopen_state->bs, read_only, true, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

        goto error;

block/file-posix.c

+7 −1
Original line number Diff line number Diff line
@@ -1339,6 +1339,9 @@ static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb) 
#if defined(CONFIG_FALLOCATE) || defined(CONFIG_XFS)

    BDRVRawState *s = aiocb->bs->opaque;

#endif

#ifdef CONFIG_FALLOCATE

    int64_t len;

#endif



    if (aiocb->aio_type & QEMU_AIO_BLKDEV) {

        return handle_aiocb_write_zeroes_block(aiocb);
@@ -1381,7 +1384,10 @@ static ssize_t handle_aiocb_write_zeroes(RawPosixAIOData *aiocb) 
#endif



#ifdef CONFIG_FALLOCATE

    if (s->has_fallocate && aiocb->aio_offset >= bdrv_getlength(aiocb->bs)) {

    /* Last resort: we are trying to extend the file with zeroed data. This

     * can be done via fallocate(fd, 0) */

    len = bdrv_getlength(aiocb->bs);

    if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {

        int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);

        if (ret == 0 || ret != -ENOTSUP) {

            return ret;

block/nfs.c

+8 −3
Original line number Diff line number Diff line
@@ -433,19 +433,23 @@ static void nfs_client_close(NFSClient *client) 
    if (client->context) {

        if (client->fh) {

            nfs_close(client->context, client->fh);

            client->fh = NULL;

        }

        aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),

                           false, NULL, NULL, NULL, NULL);

        nfs_destroy_context(client->context);

        client->context = NULL;

    }

    memset(client, 0, sizeof(NFSClient));

    g_free(client->path);

    qemu_mutex_destroy(&client->mutex);

    qapi_free_NFSServer(client->server);

    client->server = NULL;

}



static void nfs_file_close(BlockDriverState *bs)

{

    NFSClient *client = bs->opaque;

    nfs_client_close(client);

    qemu_mutex_destroy(&client->mutex);

}



static NFSServer *nfs_config(QDict *options, Error **errp)
@@ -498,6 +502,7 @@ static int64_t nfs_client_open(NFSClient *client, QDict *options, 
    struct stat st;

    char *file = NULL, *strp = NULL;



    qemu_mutex_init(&client->mutex);

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

    qemu_opts_absorb_qdict(opts, options, &local_err);

    if (local_err) {
@@ -660,7 +665,7 @@ static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags, 
    if (ret < 0) {

        return ret;

    }

    qemu_mutex_init(&client->mutex);



    bs->total_sectors = ret;

    ret = 0;

    return ret;

block/null.c

+26 −5
Original line number Diff line number Diff line
@@ -29,11 +29,6 @@ static QemuOptsList runtime_opts = { 
    .name = "null",

    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),

    .desc = {

        {

            .name = "filename",

            .type = QEMU_OPT_STRING,

            .help = "",

        },

        {

            .name = BLOCK_OPT_SIZE,

            .type = QEMU_OPT_SIZE,
@@ -54,6 +49,30 @@ static QemuOptsList runtime_opts = { 
    },

};



static void null_co_parse_filename(const char *filename, QDict *options,

                                   Error **errp)

{

    /* This functions only exists so that a null-co:// filename is accepted

     * with the null-co driver. */

    if (strcmp(filename, "null-co://")) {

        error_setg(errp, "The only allowed filename for this driver is "

                         "'null-co://'");

        return;

    }

}



static void null_aio_parse_filename(const char *filename, QDict *options,

                                    Error **errp)

{

    /* This functions only exists so that a null-aio:// filename is accepted

     * with the null-aio driver. */

    if (strcmp(filename, "null-aio://")) {

        error_setg(errp, "The only allowed filename for this driver is "

                         "'null-aio://'");

        return;

    }

}



static int null_file_open(BlockDriverState *bs, QDict *options, int flags,

                          Error **errp)

{
@@ -242,6 +261,7 @@ static BlockDriver bdrv_null_co = { 
    .instance_size          = sizeof(BDRVNullState),



    .bdrv_file_open         = null_file_open,

    .bdrv_parse_filename    = null_co_parse_filename,

    .bdrv_close             = null_close,

    .bdrv_getlength         = null_getlength,
@@ -261,6 +281,7 @@ static BlockDriver bdrv_null_aio = { 
    .instance_size          = sizeof(BDRVNullState),



    .bdrv_file_open         = null_file_open,

    .bdrv_parse_filename    = null_aio_parse_filename,

    .bdrv_close             = null_close,

    .bdrv_getlength         = null_getlength,

block/parallels.c

+7 −5
Original line number Diff line number Diff line
@@ -192,7 +192,7 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, 
                                 int nb_sectors, int *pnum)

{

    BDRVParallelsState *s = bs->opaque;

    int64_t pos, space, idx, to_allocate, i;

    int64_t pos, space, idx, to_allocate, i, len;



    pos = block_status(s, sector_num, nb_sectors, pnum);

    if (pos > 0) {
@@ -214,7 +214,11 @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num, 
    assert(idx < s->bat_size && idx + to_allocate <= s->bat_size);



    space = to_allocate * s->tracks;

    if (s->data_end + space > bdrv_getlength(bs->file->bs) >> BDRV_SECTOR_BITS) {

    len = bdrv_getlength(bs->file->bs);

    if (len < 0) {

        return len;

    }

    if (s->data_end + space > (len >> BDRV_SECTOR_BITS)) {

        int ret;

        space += s->prealloc_size;

        if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {
@@ -699,9 +703,7 @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags, 
        goto fail_options;

    }



    if (!(flags & BDRV_O_RESIZE) || !bdrv_has_zero_init(bs->file->bs) ||

            bdrv_truncate(bs->file, bdrv_getlength(bs->file->bs),

                          PREALLOC_MODE_OFF, NULL) != 0) {

    if (!bdrv_has_zero_init(bs->file->bs)) {

        s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;

    }