Commit d2628b1e authored by Peter Maydell's avatar Peter Maydell
Browse files

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



Block layer patches:

- file-posix: Mitigate file fragmentation with extent size hints
- Tighten qemu-img rules on missing backing format
- qemu-img map: Don't limit block status request size
- Fix crash with virtio-scsi and iothreads

# gpg: Signature made Tue 14 Jul 2020 14:24:19 BST
# gpg:                using RSA key DC3DEB159A9AF95D3D7456FE7F09B272C88F2FD6
# gpg:                issuer "kwolf@redhat.com"
# 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:
  block: Avoid stale pointer dereference in blk_get_aio_context()
  qemu-img: Deprecate use of -b without -F
  block: Add support to warn on backing file change without format
  iotests: Specify explicit backing format where sensible
  qcow2: Deprecate use of qemu-img amend to change backing file
  block: Error if backing file fails during creation without -u
  qcow: Tolerate backing_fmt=
  vmdk: Add trivial backing_fmt support
  sheepdog: Add trivial backing_fmt support
  block: Finish deprecation of 'qemu-img convert -n -o'
  qemu-img: Flush stdout before before potential stderr messages
  file-posix: Mitigate file fragmentation with extent size hints
  iotests/059: Filter out disk size with more standard filter
  qemu-img map: Don't limit block status request size
  iotests: Simplify _filter_img_create() a bit

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

block.c

+39 −14
Original line number Diff line number Diff line
@@ -1206,7 +1206,8 @@ static int bdrv_backing_update_filename(BdrvChild *c, BlockDriverState *base, 
    }



    ret = bdrv_change_backing_file(parent, filename,

                                   base->drv ? base->drv->format_name : "");

                                   base->drv ? base->drv->format_name : "",

                                   false);

    if (ret < 0) {

        error_setg_errno(errp, -ret, "Could not update backing file link");

    }
@@ -4680,8 +4681,8 @@ int bdrv_check(BlockDriverState *bs, 
 *            image file header

 * -ENOTSUP - format driver doesn't support changing the backing file

 */

int bdrv_change_backing_file(BlockDriverState *bs,

    const char *backing_file, const char *backing_fmt)

int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,

                             const char *backing_fmt, bool warn)

{

    BlockDriver *drv = bs->drv;

    int ret;
@@ -4695,6 +4696,12 @@ int bdrv_change_backing_file(BlockDriverState *bs, 
        return -EINVAL;

    }



    if (warn && backing_file && !backing_fmt) {

        warn_report("Deprecated use of backing file without explicit "

                    "backing format, use of this image requires "

                    "potentially unsafe format probing");

    }



    if (drv->bdrv_change_backing_file != NULL) {

        ret = drv->bdrv_change_backing_file(bs, backing_file, backing_fmt);

    } else {
@@ -6128,18 +6135,30 @@ void bdrv_img_create(const char *filename, const char *fmt, 
        bs = bdrv_open(full_backing, NULL, backing_options, back_flags,

                       &local_err);

        g_free(full_backing);

        if (!bs && size != -1) {

            /* Couldn't open BS, but we have a size, so it's nonfatal */

            warn_reportf_err(local_err,

                            "Could not verify backing image. "

                            "This may become an error in future versions.\n");

            local_err = NULL;

        } else if (!bs) {

            /* Couldn't open bs, do not have size */

            error_append_hint(&local_err,

                              "Could not open backing image to determine size.\n");

        if (!bs) {

            error_append_hint(&local_err, "Could not open backing image.\n");

            goto out;

        } else {

            if (!backing_fmt) {

                warn_report("Deprecated use of backing file without explicit "

                            "backing format (detected format of %s)",

                            bs->drv->format_name);

                if (bs->drv != &bdrv_raw) {

                    /*

                     * A probe of raw deserves the most attention:

                     * leaving the backing format out of the image

                     * will ensure bs->probed is set (ensuring we

                     * don't accidentally commit into the backing

                     * file), and allow more spots to warn the users

                     * to fix their toolchain when opening this image

                     * later.  For other images, we can safely record

                     * the format that we probed.

                     */

                    backing_fmt = bs->drv->format_name;

                    qemu_opt_set(opts, BLOCK_OPT_BACKING_FMT, backing_fmt,

                                 NULL);

                }

            }

            if (size == -1) {

                /* Opened BS, have no size */

                size = bdrv_getlength(bs);
@@ -6153,7 +6172,12 @@ void bdrv_img_create(const char *filename, const char *fmt, 
            }

            bdrv_unref(bs);

        }

    } /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */

        /* (backing_file && !(flags & BDRV_O_NO_BACKING)) */

    } else if (backing_file && !backing_fmt) {

        warn_report("Deprecated use of unopened backing file without "

                    "explicit backing format, use of this image requires "

                    "potentially unsafe format probing");

    }



    if (size == -1) {

        error_setg(errp, "Image creation needs a size parameter");
@@ -6164,6 +6188,7 @@ void bdrv_img_create(const char *filename, const char *fmt, 
        printf("Formatting '%s', fmt=%s ", filename, fmt);

        qemu_opts_print(opts, " ");

        puts("");

        fflush(stdout);

    }



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

block/block-backend.c

+3 −1
Original line number Diff line number Diff line
@@ -808,6 +808,7 @@ void blk_remove_bs(BlockBackend *blk) 
{

    ThrottleGroupMember *tgm = &blk->public.throttle_group_member;

    BlockDriverState *bs;

    BdrvChild *root;



    notifier_list_notify(&blk->remove_bs_notifiers, blk);

    if (tgm->throttle_state) {
@@ -825,8 +826,9 @@ void blk_remove_bs(BlockBackend *blk) 
     * to avoid that and a potential QEMU crash.

     */

    blk_drain(blk);

    bdrv_root_unref_child(blk->root);

    root = blk->root;

    blk->root = NULL;

    bdrv_root_unref_child(root);

}



/*

block/file-posix.c

+44 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include "block/block_int.h"

#include "qemu/module.h"

#include "qemu/option.h"

#include "qemu/units.h"

#include "trace.h"

#include "block/thread-pool.h"

#include "qemu/iov.h"
@@ -2318,6 +2319,14 @@ raw_co_create(BlockdevCreateOptions *options, Error **errp) 
    if (!file_opts->has_preallocation) {

        file_opts->preallocation = PREALLOC_MODE_OFF;

    }

    if (!file_opts->has_extent_size_hint) {

        file_opts->extent_size_hint = 1 * MiB;

    }

    if (file_opts->extent_size_hint > UINT32_MAX) {

        result = -EINVAL;

        error_setg(errp, "Extent size hint is too large");

        goto out;

    }



    /* Create file */

    fd = qemu_open(file_opts->filename, O_RDWR | O_CREAT | O_BINARY, 0644);
@@ -2375,6 +2384,27 @@ raw_co_create(BlockdevCreateOptions *options, Error **errp) 
        }

#endif

    }

#ifdef FS_IOC_FSSETXATTR

    /*

     * Try to set the extent size hint. Failure is not fatal, and a warning is

     * only printed if the option was explicitly specified.

     */

    {

        struct fsxattr attr;

        result = ioctl(fd, FS_IOC_FSGETXATTR, &attr);

        if (result == 0) {

            attr.fsx_xflags |= FS_XFLAG_EXTSIZE;

            attr.fsx_extsize = file_opts->extent_size_hint;

            result = ioctl(fd, FS_IOC_FSSETXATTR, &attr);

        }

        if (result < 0 && file_opts->has_extent_size_hint &&

            file_opts->extent_size_hint)

        {

            warn_report("Failed to set extent size hint: %s",

                        strerror(errno));

        }

    }

#endif



    /* Resize and potentially preallocate the file to the desired

     * final size */
@@ -2410,6 +2440,8 @@ static int coroutine_fn raw_co_create_opts(BlockDriver *drv, 
{

    BlockdevCreateOptions options;

    int64_t total_size = 0;

    int64_t extent_size_hint = 0;

    bool has_extent_size_hint = false;

    bool nocow = false;

    PreallocMode prealloc;

    char *buf = NULL;
@@ -2421,6 +2453,11 @@ static int coroutine_fn raw_co_create_opts(BlockDriver *drv, 
    /* Read out options */

    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),

                          BDRV_SECTOR_SIZE);

    if (qemu_opt_get(opts, BLOCK_OPT_EXTENT_SIZE_HINT)) {

        has_extent_size_hint = true;

        extent_size_hint =

            qemu_opt_get_size_del(opts, BLOCK_OPT_EXTENT_SIZE_HINT, -1);

    }

    nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);

    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);

    prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
@@ -2440,6 +2477,8 @@ static int coroutine_fn raw_co_create_opts(BlockDriver *drv, 
            .preallocation      = prealloc,

            .has_nocow          = true,

            .nocow              = nocow,

            .has_extent_size_hint = has_extent_size_hint,

            .extent_size_hint   = extent_size_hint,

        },

    };

    return raw_co_create(&options, errp);
@@ -2930,6 +2969,11 @@ static QemuOptsList raw_create_opts = { 
#endif

                    ", full)"

        },

        {

            .name = BLOCK_OPT_EXTENT_SIZE_HINT,

            .type = QEMU_OPT_SIZE,

            .help = "Extent size hint for the image file, 0 to disable"

        },

        { /* end of list */ }

    }

};

block/qcow.c

+19 −1
Original line number Diff line number Diff line
@@ -938,10 +938,11 @@ static int coroutine_fn qcow_co_create_opts(BlockDriver *drv, 
{

    BlockdevCreateOptions *create_options = NULL;

    BlockDriverState *bs = NULL;

    QDict *qdict;

    QDict *qdict = NULL;

    Visitor *v;

    const char *val;

    int ret;

    char *backing_fmt;



    static const QDictRenames opt_renames[] = {

        { BLOCK_OPT_BACKING_FILE,       "backing-file" },
@@ -949,6 +950,17 @@ static int coroutine_fn qcow_co_create_opts(BlockDriver *drv, 
        { NULL, NULL },

    };



    /*

     * We can't actually store a backing format, but can check that

     * the user's request made sense.

     */

    backing_fmt = qemu_opt_get_del(opts, BLOCK_OPT_BACKING_FMT);

    if (backing_fmt && !bdrv_find_format(backing_fmt)) {

        error_setg(errp, "unrecognized backing format '%s'", backing_fmt);

        ret = -EINVAL;

        goto fail;

    }



    /* Parse options and convert legacy syntax */

    qdict = qemu_opts_to_qdict_filtered(opts, NULL, &qcow_create_opts, true);
@@ -1012,6 +1024,7 @@ static int coroutine_fn qcow_co_create_opts(BlockDriver *drv, 


    ret = 0;

fail:

    g_free(backing_fmt);

    qobject_unref(qdict);

    bdrv_unref(bs);

    qapi_free_BlockdevCreateOptions(create_options);
@@ -1146,6 +1159,11 @@ static QemuOptsList qcow_create_opts = { 
            .type = QEMU_OPT_STRING,

            .help = "File name of a base image"

        },

        {

            .name = BLOCK_OPT_BACKING_FMT,

            .type = QEMU_OPT_STRING,

            .help = "Format of the backing image",

        },

        {

            .name = BLOCK_OPT_ENCRYPT,

            .type = QEMU_OPT_BOOL,

block/qcow2.c

+6 −1
Original line number Diff line number Diff line
@@ -3627,7 +3627,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp) 
        }



        ret = bdrv_change_backing_file(blk_bs(blk), qcow2_opts->backing_file,

                                       backing_format);

                                       backing_format, false);

        if (ret < 0) {

            error_setg_errno(errp, -ret, "Could not assign backing file '%s' "

                             "with format '%s'", qcow2_opts->backing_file,
@@ -5511,6 +5511,11 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, 
    }



    if (backing_file || backing_format) {

        if (g_strcmp0(backing_file, s->image_backing_file) ||

            g_strcmp0(backing_format, s->image_backing_format)) {

            warn_report("Deprecated use of amend to alter the backing file; "

                        "use qemu-img rebase instead");

        }

        ret = qcow2_change_backing_file(bs,

                    backing_file ?: s->image_backing_file,

                    backing_format ?: s->image_backing_format);