Commit 49780a58 authored by Peter Maydell's avatar Peter Maydell
Browse files

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



Block layer patches:

- Relax restrictions for blockdev-snapshot (allows libvirt to do live
  storage migration with blockdev-mirror)
- luks: Delete created files when block_crypto_co_create_opts_luks fails
- Fix memleaks in qmp_object_add

# gpg: Signature made Wed 11 Mar 2020 15:38:59 GMT
# gpg:                using RSA key 7F09B272C88F2FD6
# gpg: Good signature from "Kevin Wolf <kwolf@redhat.com>" [full]
# Primary key fingerprint: DC3D EB15 9A9A F95D 3D74  56FE 7F09 B272 C88F 2FD6

* remotes/kevin/tags/for-upstream:
  qemu-iotests: adding LUKS cleanup for non-UTF8 secret error
  crypto.c: cleanup created file when block_crypto_co_create_opts_luks fails
  block.c: adding bdrv_co_delete_file
  block: introducing 'bdrv_co_delete_file' interface
  tests/qemu-iotests: Fix socket_scm_helper build path
  qapi: Add '@allow-write-only-overlay' feature for 'blockdev-snapshot'
  iotests: Add iothread cases to 155
  block: Fix cross-AioContext blockdev-snapshot
  iotests: Test mirror with temporarily disabled target backing file
  iotests: Fix run_job() with use_log=False
  block: Relax restrictions for blockdev-snapshot
  block: Make bdrv_get_cumulative_perm() public
  qom-qmp-cmds: fix two memleaks in qmp_object_add

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 10b11400 8bb3b023

block.c

+29 −4
Original line number Diff line number Diff line
@@ -668,6 +668,32 @@ int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp) 
    }

}



int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)

{

    Error *local_err = NULL;

    int ret;



    assert(bs != NULL);



    if (!bs->drv) {

        error_setg(errp, "Block node '%s' is not opened", bs->filename);

        return -ENOMEDIUM;

    }



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

        error_setg(errp, "Driver '%s' does not support image deletion",

                   bs->drv->format_name);

        return -ENOTSUP;

    }



    ret = bs->drv->bdrv_co_delete_file(bs, &local_err);

    if (ret < 0) {

        error_propagate(errp, local_err);

    }



    return ret;

}



/**

 * Try to get @bs's logical and physical block size.

 * On success, store them in @bsz struct and return 0.
@@ -1872,8 +1898,6 @@ static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q, 
                                 bool *tighten_restrictions, Error **errp);

static void bdrv_child_abort_perm_update(BdrvChild *c);

static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);

static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,

                                     uint64_t *shared_perm);



typedef struct BlockReopenQueueEntry {

     bool prepared;
@@ -2097,7 +2121,7 @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms, 
    }

}



static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,

void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,

                              uint64_t *shared_perm)

{

    BdrvChild *c;
@@ -4367,6 +4391,7 @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to, 
    bdrv_ref(from);



    assert(qemu_get_current_aio_context() == qemu_get_aio_context());

    assert(bdrv_get_aio_context(from) == bdrv_get_aio_context(to));

    bdrv_drained_begin(from);



    /* Put all parents into @list and calculate their cumulative permissions */

block/crypto.c

+18 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include "qapi/error.h"

#include "qemu/module.h"

#include "qemu/option.h"

#include "qemu/cutils.h"

#include "crypto.h"



typedef struct BlockCrypto BlockCrypto;
@@ -657,6 +658,23 @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename, 


    ret = 0;

fail:

    /*

     * If an error occurred, delete 'filename'. Even if the file existed

     * beforehand, it has been truncated and corrupted in the process.

     */

    if (ret && bs) {

        Error *local_delete_err = NULL;

        int r_del = bdrv_co_delete_file(bs, &local_delete_err);

        /*

         * ENOTSUP will happen if the block driver doesn't support

         * the 'bdrv_co_delete_file' interface. This is a predictable

         * scenario and shouldn't be reported back to the user.

         */

        if ((r_del < 0) && (r_del != -ENOTSUP)) {

            error_report_err(local_delete_err);

        }

    }



    bdrv_unref(bs);

    qapi_free_QCryptoBlockCreateOptions(create_opts);

    qobject_unref(cryptoopts);

block/file-posix.c

+23 −0
Original line number Diff line number Diff line
@@ -2445,6 +2445,28 @@ static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts, 
    return raw_co_create(&options, errp);

}



static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,

                                           Error **errp)

{

    struct stat st;

    int ret;



    if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {

        error_setg_errno(errp, ENOENT, "%s is not a regular file",

                         bs->filename);

        return -ENOENT;

    }



    ret = unlink(bs->filename);

    if (ret < 0) {

        ret = -errno;

        error_setg_errno(errp, -ret, "Error when deleting file %s",

                         bs->filename);

    }



    return ret;

}



/*

 * Find allocation range in @bs around offset @start.

 * May change underlying file descriptor's file offset.
@@ -3075,6 +3097,7 @@ BlockDriver bdrv_file = { 
    .bdrv_co_block_status = raw_co_block_status,

    .bdrv_co_invalidate_cache = raw_co_invalidate_cache,

    .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,

    .bdrv_co_delete_file = raw_co_delete_file,



    .bdrv_co_preadv         = raw_co_preadv,

    .bdrv_co_pwritev        = raw_co_pwritev,

blockdev.c

+8 −22
Original line number Diff line number Diff line
@@ -1470,8 +1470,7 @@ static void external_snapshot_prepare(BlkActionState *common, 
                             DO_UPCAST(ExternalSnapshotState, common, common);

    TransactionAction *action = common->action;

    AioContext *aio_context;

    AioContext *old_context;

    int ret;

    uint64_t perm, shared;



    /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar

     * purpose but a different set of parameters */
@@ -1586,16 +1585,17 @@ static void external_snapshot_prepare(BlkActionState *common, 
        goto out;

    }



    if (bdrv_has_blk(state->new_bs)) {

    /*

     * Allow attaching a backing file to an overlay that's already in use only

     * if the parents don't assume that they are already seeing a valid image.

     * (Specifically, allow it as a mirror target, which is write-only access.)

     */

    bdrv_get_cumulative_perm(state->new_bs, &perm, &shared);

    if (perm & BLK_PERM_CONSISTENT_READ) {

        error_setg(errp, "The overlay is already in use");

        goto out;

    }



    if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,

                           errp)) {

        goto out;

    }



    if (state->new_bs->backing != NULL) {

        error_setg(errp, "The overlay already has a backing image");

        goto out;
@@ -1606,20 +1606,6 @@ static void external_snapshot_prepare(BlkActionState *common, 
        goto out;

    }



    /* Honor bdrv_try_set_aio_context() context acquisition requirements. */

    old_context = bdrv_get_aio_context(state->new_bs);

    aio_context_release(aio_context);

    aio_context_acquire(old_context);



    ret = bdrv_try_set_aio_context(state->new_bs, aio_context, errp);



    aio_context_release(old_context);

    aio_context_acquire(aio_context);



    if (ret < 0) {

        goto out;

    }



    /* This removes our old bs and adds the new bs. This is an operation that

     * can fail, so we need to do it in .prepare; undoing it for abort is

     * always possible. */

include/block/block.h

+1 −0
Original line number Diff line number Diff line
@@ -363,6 +363,7 @@ bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base, 
int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,

                              Error **errp);

void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base);

int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp);





typedef struct BdrvCheckResult {