Commit 3753e255 authored by Stefan Hajnoczi's avatar Stefan Hajnoczi
Browse files

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



Block layer patches

# gpg: Signature made Thu 11 May 2017 10:31:37 AM EDT
# 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

* kwolf/tags/for-upstream: (58 commits)
  MAINTAINERS: Add qemu-progress to the block layer
  qcow2: Discard/zero clusters by byte count
  qcow2: Assert that cluster operations are aligned
  qcow2: Optimize write zero of unaligned tail cluster
  iotests: Add test 179 to cover write zeroes with unmap
  iotests: Improve _filter_qemu_img_map
  qcow2: Optimize zero_single_l2() to minimize L2 churn
  qcow2: Make distinction between zero cluster types obvious
  qcow2: Name typedef for cluster type
  qcow2: Correctly report status of preallocated zero clusters
  block: Update comments on BDRV_BLOCK_* meanings
  qcow2: Use consistent switch indentation
  qcow2: Nicer variable names in qcow2_update_snapshot_refcount()
  tests: Add coverage for recent block geometry fixes
  blkdebug: Add ability to override unmap geometries
  blkdebug: Simplify override logic
  blkdebug: Add pass-through write_zero and discard support
  blkdebug: Refactor error injection
  blkdebug: Sanity check block layer guarantees
  qemu-io: Switch 'map' output to byte-based reporting
  ...

Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
parents ecc1f5ad d541e201

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -1170,6 +1170,7 @@ F: include/block/ 
F: qemu-img*

F: qemu-io*

F: tests/qemu-iotests/

F: util/qemu-progress.c

T: git git://repo.or.cz/qemu/kevin.git block



Block I/O path

block.c

+111 −16
Original line number Diff line number Diff line
@@ -192,11 +192,20 @@ void path_combine(char *dest, int dest_size, 
    }

}



/* Returns whether the image file is opened as read-only. Note that this can

 * return false and writing to the image file is still not possible because the

 * image is inactivated. */

bool bdrv_is_read_only(BlockDriverState *bs)

{

    return bs->read_only;

}



/* Returns whether the image file can be written to right now */

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)

{

    /* Do not set read_only if copy_on_read is enabled */
@@ -762,6 +771,13 @@ static void bdrv_child_cb_drained_end(BdrvChild *child) 
    bdrv_drained_end(bs);

}



static int bdrv_child_cb_inactivate(BdrvChild *child)

{

    BlockDriverState *bs = child->opaque;

    assert(bs->open_flags & BDRV_O_INACTIVE);

    return 0;

}



/*

 * Returns the options and flags that a temporary snapshot should get, based on

 * the originally requested flags (the originally requested image will have
@@ -800,6 +816,7 @@ static void bdrv_inherited_options(int *child_flags, QDict *child_options, 
     * the parent. */

    qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);

    qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);

    qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);



    /* Inherit the read-only option from the parent if it's not set */

    qdict_copy_default(child_options, parent_options, BDRV_OPT_READ_ONLY);
@@ -821,6 +838,7 @@ const BdrvChildRole child_file = { 
    .inherit_options = bdrv_inherited_options,

    .drained_begin   = bdrv_child_cb_drained_begin,

    .drained_end     = bdrv_child_cb_drained_end,

    .inactivate      = bdrv_child_cb_inactivate,

};



/*
@@ -842,6 +860,7 @@ const BdrvChildRole child_format = { 
    .inherit_options = bdrv_inherited_fmt_options,

    .drained_begin   = bdrv_child_cb_drained_begin,

    .drained_end     = bdrv_child_cb_drained_end,

    .inactivate      = bdrv_child_cb_inactivate,

};



static void bdrv_backing_attach(BdrvChild *c)
@@ -908,6 +927,7 @@ static void bdrv_backing_options(int *child_flags, QDict *child_options, 
     * which is only applied on the top level (BlockBackend) */

    qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_DIRECT);

    qdict_copy_default(child_options, parent_options, BDRV_OPT_CACHE_NO_FLUSH);

    qdict_copy_default(child_options, parent_options, BDRV_OPT_FORCE_SHARE);



    /* backing files always opened read-only */

    qdict_set_default_str(child_options, BDRV_OPT_READ_ONLY, "on");
@@ -926,6 +946,7 @@ const BdrvChildRole child_backing = { 
    .inherit_options = bdrv_backing_options,

    .drained_begin   = bdrv_child_cb_drained_begin,

    .drained_end     = bdrv_child_cb_drained_end,

    .inactivate      = bdrv_child_cb_inactivate,

};



static int bdrv_open_flags(BlockDriverState *bs, int flags)
@@ -1150,6 +1171,11 @@ QemuOptsList bdrv_runtime_opts = { 
            .type = QEMU_OPT_STRING,

            .help = "discard operation (ignore/off, unmap/on)",

        },

        {

            .name = BDRV_OPT_FORCE_SHARE,

            .type = QEMU_OPT_BOOL,

            .help = "always accept other writers (default: off)",

        },

        { /* end of list */ }

    },

};
@@ -1189,6 +1215,16 @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file, 
    drv = bdrv_find_format(driver_name);

    assert(drv != NULL);



    bs->force_share = qemu_opt_get_bool(opts, BDRV_OPT_FORCE_SHARE, false);



    if (bs->force_share && (bs->open_flags & BDRV_O_RDWR)) {

        error_setg(errp,

                   BDRV_OPT_FORCE_SHARE

                   "=on can only be used with read-only images");

        ret = -EINVAL;

        goto fail_opts;

    }



    if (file != NULL) {

        filename = blk_bs(file)->filename;

    } else {
@@ -1448,6 +1484,22 @@ static int bdrv_child_check_perm(BdrvChild *c, uint64_t perm, uint64_t shared, 
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_child_perm(BlockDriverState *bs, BlockDriverState *child_bs,

                            BdrvChild *c,

                            const BdrvChildRole *role,

                            uint64_t parent_perm, uint64_t parent_shared,

                            uint64_t *nperm, uint64_t *nshared)

{

    if (bs->drv && bs->drv->bdrv_child_perm) {

        bs->drv->bdrv_child_perm(bs, c, role,

                                 parent_perm, parent_shared,

                                 nperm, nshared);

    }

    if (child_bs && child_bs->force_share) {

        *nshared = BLK_PERM_ALL;

    }

}



/*

 * Check whether permissions on this node can be changed in a way that

 * @cumulative_perms and @cumulative_shared_perms are the new cumulative
@@ -1467,7 +1519,7 @@ static int bdrv_check_perm(BlockDriverState *bs, uint64_t cumulative_perms, 


    /* Write permissions never work with read-only images */

    if ((cumulative_perms & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED)) &&

        bdrv_is_read_only(bs))

        !bdrv_is_writable(bs))

    {

        error_setg(errp, "Block node is read-only");

        return -EPERM;
@@ -1492,7 +1544,7 @@ static int bdrv_check_perm(BlockDriverState *bs, uint64_t cumulative_perms, 
    /* Check all children */

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

        uint64_t cur_perm, cur_shared;

        drv->bdrv_child_perm(bs, c, c->role,

        bdrv_child_perm(bs, c->bs, c, c->role,

                        cumulative_perms, cumulative_shared_perms,

                        &cur_perm, &cur_shared);

        ret = bdrv_child_check_perm(c, cur_perm, cur_shared, ignore_children,
@@ -1554,7 +1606,7 @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms, 
    /* Update all children */

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

        uint64_t cur_perm, cur_shared;

        drv->bdrv_child_perm(bs, c, c->role,

        bdrv_child_perm(bs, c->bs, c, c->role,

                        cumulative_perms, cumulative_shared_perms,

                        &cur_perm, &cur_shared);

        bdrv_child_set_perm(c, cur_perm, cur_shared);
@@ -1586,7 +1638,7 @@ static char *bdrv_child_user_desc(BdrvChild *c) 
    return g_strdup("another user");

}



static char *bdrv_perm_names(uint64_t perm)

char *bdrv_perm_names(uint64_t perm)

{

    struct perm_name {

        uint64_t perm;
@@ -1752,7 +1804,7 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c, 
        bdrv_filter_default_perms(bs, c, role, perm, shared, &perm, &shared);



        /* Format drivers may touch metadata even if the guest doesn't write */

        if (!bdrv_is_read_only(bs)) {

        if (bdrv_is_writable(bs)) {

            perm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;

        }
@@ -1778,6 +1830,10 @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c, 
                  BLK_PERM_WRITE_UNCHANGED;

    }



    if (bs->open_flags & BDRV_O_INACTIVE) {

        shared |= BLK_PERM_WRITE | BLK_PERM_RESIZE;

    }



    *nperm = perm;

    *nshared = shared;

}
@@ -1891,7 +1947,7 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs, 


    assert(parent_bs->drv);

    assert(bdrv_get_aio_context(parent_bs) == bdrv_get_aio_context(child_bs));

    parent_bs->drv->bdrv_child_perm(parent_bs, NULL, child_role,

    bdrv_child_perm(parent_bs, child_bs, NULL, child_role,

                    perm, shared_perm, &perm, &shared_perm);



    child = bdrv_root_attach_child(child_bs, child_name, child_role,
@@ -3916,7 +3972,8 @@ void bdrv_init_with_whitelist(void) 


void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)

{

    BdrvChild *child;

    BdrvChild *child, *parent;

    uint64_t perm, shared_perm;

    Error *local_err = NULL;

    int ret;
@@ -3952,6 +4009,26 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 
        error_setg_errno(errp, -ret, "Could not refresh total sector count");

        return;

    }



    /* Update permissions, they may differ for inactive nodes */

    bdrv_get_cumulative_perm(bs, &perm, &shared_perm);

    ret = bdrv_check_perm(bs, perm, shared_perm, NULL, &local_err);

    if (ret < 0) {

        bs->open_flags |= BDRV_O_INACTIVE;

        error_propagate(errp, local_err);

        return;

    }

    bdrv_set_perm(bs, perm, shared_perm);



    QLIST_FOREACH(parent, &bs->parents, next_parent) {

        if (parent->role->activate) {

            parent->role->activate(parent, &local_err);

            if (local_err) {

                error_propagate(errp, local_err);

                return;

            }

        }

    }

}



void bdrv_invalidate_cache_all(Error **errp)
@@ -3976,7 +4053,7 @@ void bdrv_invalidate_cache_all(Error **errp) 
static int bdrv_inactivate_recurse(BlockDriverState *bs,

                                   bool setting_flag)

{

    BdrvChild *child;

    BdrvChild *child, *parent;

    int ret;



    if (!setting_flag && bs->drv->bdrv_inactivate) {
@@ -3986,6 +4063,27 @@ static int bdrv_inactivate_recurse(BlockDriverState *bs, 
        }

    }



    if (setting_flag) {

        uint64_t perm, shared_perm;



        bs->open_flags |= BDRV_O_INACTIVE;



        QLIST_FOREACH(parent, &bs->parents, next_parent) {

            if (parent->role->inactivate) {

                ret = parent->role->inactivate(parent);

                if (ret < 0) {

                    bs->open_flags &= ~BDRV_O_INACTIVE;

                    return ret;

                }

            }

        }



        /* Update permissions, they may differ for inactive nodes */

        bdrv_get_cumulative_perm(bs, &perm, &shared_perm);

        bdrv_check_perm(bs, perm, shared_perm, NULL, &error_abort);

        bdrv_set_perm(bs, perm, shared_perm);

    }



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

        ret = bdrv_inactivate_recurse(child->bs, setting_flag);

        if (ret < 0) {
@@ -3993,9 +4091,6 @@ static int bdrv_inactivate_recurse(BlockDriverState *bs, 
        }

    }



    if (setting_flag) {

        bs->open_flags |= BDRV_O_INACTIVE;

    }

    return 0;

}

block/blkdebug.c

+217 −47
Original line number Diff line number Diff line 
/*

 * Block protocol for I/O error injection

 *

 * Copyright (C) 2016-2017 Red Hat, Inc.

 * Copyright (c) 2010 Kevin Wolf <kwolf@redhat.com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -37,7 +38,12 @@ 
typedef struct BDRVBlkdebugState {

    int state;

    int new_state;

    int align;

    uint64_t align;

    uint64_t max_transfer;

    uint64_t opt_write_zero;

    uint64_t max_write_zero;

    uint64_t opt_discard;

    uint64_t max_discard;



    /* For blkdebug_refresh_filename() */

    char *config_file;
@@ -342,6 +348,31 @@ static QemuOptsList runtime_opts = { 
            .type = QEMU_OPT_SIZE,

            .help = "Required alignment in bytes",

        },

        {

            .name = "max-transfer",

            .type = QEMU_OPT_SIZE,

            .help = "Maximum transfer size in bytes",

        },

        {

            .name = "opt-write-zero",

            .type = QEMU_OPT_SIZE,

            .help = "Optimum write zero alignment in bytes",

        },

        {

            .name = "max-write-zero",

            .type = QEMU_OPT_SIZE,

            .help = "Maximum write zero size in bytes",

        },

        {

            .name = "opt-discard",

            .type = QEMU_OPT_SIZE,

            .help = "Optimum discard alignment in bytes",

        },

        {

            .name = "max-discard",

            .type = QEMU_OPT_SIZE,

            .help = "Maximum discard size in bytes",

        },

        { /* end of list */ }

    },

};
@@ -352,8 +383,8 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 
    BDRVBlkdebugState *s = bs->opaque;

    QemuOpts *opts;

    Error *local_err = NULL;

    uint64_t align;

    int ret;

    uint64_t align;



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

    qemu_opts_absorb_qdict(opts, options, &local_err);
@@ -382,19 +413,69 @@ static int blkdebug_open(BlockDriverState *bs, QDict *options, int flags, 
        goto out;

    }



    /* Set request alignment */

    align = qemu_opt_get_size(opts, "align", 0);

    if (align < INT_MAX && is_power_of_2(align)) {

        s->align = align;

    } else if (align) {

        error_setg(errp, "Invalid alignment");

    bs->supported_write_flags = BDRV_REQ_FUA &

        bs->file->bs->supported_write_flags;

    bs->supported_zero_flags = (BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP) &

        bs->file->bs->supported_zero_flags;

    ret = -EINVAL;



    /* Set alignment overrides */

    s->align = qemu_opt_get_size(opts, "align", 0);

    if (s->align && (s->align >= INT_MAX || !is_power_of_2(s->align))) {

        error_setg(errp, "Cannot meet constraints with align %" PRIu64,

                   s->align);

        goto out;

    }

    align = MAX(s->align, bs->file->bs->bl.request_alignment);



    ret = 0;

    s->max_transfer = qemu_opt_get_size(opts, "max-transfer", 0);

    if (s->max_transfer &&

        (s->max_transfer >= INT_MAX ||

         !QEMU_IS_ALIGNED(s->max_transfer, align))) {

        error_setg(errp, "Cannot meet constraints with max-transfer %" PRIu64,

                   s->max_transfer);

        goto out;

    }



    s->opt_write_zero = qemu_opt_get_size(opts, "opt-write-zero", 0);

    if (s->opt_write_zero &&

        (s->opt_write_zero >= INT_MAX ||

         !QEMU_IS_ALIGNED(s->opt_write_zero, align))) {

        error_setg(errp, "Cannot meet constraints with opt-write-zero %" PRIu64,

                   s->opt_write_zero);

        goto out;

    }



    s->max_write_zero = qemu_opt_get_size(opts, "max-write-zero", 0);

    if (s->max_write_zero &&

        (s->max_write_zero >= INT_MAX ||

         !QEMU_IS_ALIGNED(s->max_write_zero,

                          MAX(s->opt_write_zero, align)))) {

        error_setg(errp, "Cannot meet constraints with max-write-zero %" PRIu64,

                   s->max_write_zero);

        goto out;

    }



    s->opt_discard = qemu_opt_get_size(opts, "opt-discard", 0);

    if (s->opt_discard &&

        (s->opt_discard >= INT_MAX ||

         !QEMU_IS_ALIGNED(s->opt_discard, align))) {

        error_setg(errp, "Cannot meet constraints with opt-discard %" PRIu64,

                   s->opt_discard);

        goto out;

    }



    s->max_discard = qemu_opt_get_size(opts, "max-discard", 0);

    if (s->max_discard &&

        (s->max_discard >= INT_MAX ||

         !QEMU_IS_ALIGNED(s->max_discard,

                          MAX(s->opt_discard, align)))) {

        error_setg(errp, "Cannot meet constraints with max-discard %" PRIu64,

                   s->max_discard);

        goto out;

    }



    ret = 0;

out:

    if (ret < 0) {

        g_free(s->config_file);
@@ -403,11 +484,30 @@ out: 
    return ret;

}



static int inject_error(BlockDriverState *bs, BlkdebugRule *rule)

static int rule_check(BlockDriverState *bs, uint64_t offset, uint64_t bytes)

{

    BDRVBlkdebugState *s = bs->opaque;

    int error = rule->options.inject.error;

    bool immediately = rule->options.inject.immediately;

    BlkdebugRule *rule = NULL;

    int error;

    bool immediately;



    QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {

        uint64_t inject_offset = rule->options.inject.offset;



        if (inject_offset == -1 ||

            (bytes && inject_offset >= offset &&

             inject_offset < offset + bytes))

        {

            break;

        }

    }



    if (!rule || !rule->options.inject.error) {

        return 0;

    }



    immediately = rule->options.inject.immediately;

    error = rule->options.inject.error;



    if (rule->options.inject.once) {

        QSIMPLEQ_REMOVE(&s->active_rules, rule, BlkdebugRule, active_next);
@@ -426,21 +526,18 @@ static int coroutine_fn 
blkdebug_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,

                   QEMUIOVector *qiov, int flags)

{

    BDRVBlkdebugState *s = bs->opaque;

    BlkdebugRule *rule = NULL;



    QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {

        uint64_t inject_offset = rule->options.inject.offset;

    int err;



        if (inject_offset == -1 ||

            (inject_offset >= offset && inject_offset < offset + bytes))

        {

            break;

        }

    /* Sanity check block layer guarantees */

    assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));

    assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));

    if (bs->bl.max_transfer) {

        assert(bytes <= bs->bl.max_transfer);

    }



    if (rule && rule->options.inject.error) {

        return inject_error(bs, rule);

    err = rule_check(bs, offset, bytes);

    if (err) {

        return err;

    }



    return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
@@ -450,21 +547,18 @@ static int coroutine_fn 
blkdebug_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes,

                    QEMUIOVector *qiov, int flags)

{

    BDRVBlkdebugState *s = bs->opaque;

    BlkdebugRule *rule = NULL;



    QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {

        uint64_t inject_offset = rule->options.inject.offset;

    int err;



        if (inject_offset == -1 ||

            (inject_offset >= offset && inject_offset < offset + bytes))

        {

            break;

        }

    /* Sanity check block layer guarantees */

    assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));

    assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_alignment));

    if (bs->bl.max_transfer) {

        assert(bytes <= bs->bl.max_transfer);

    }



    if (rule && rule->options.inject.error) {

        return inject_error(bs, rule);

    err = rule_check(bs, offset, bytes);

    if (err) {

        return err;

    }



    return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
@@ -472,22 +566,81 @@ blkdebug_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes, 


static int blkdebug_co_flush(BlockDriverState *bs)

{

    BDRVBlkdebugState *s = bs->opaque;

    BlkdebugRule *rule = NULL;

    int err = rule_check(bs, 0, 0);



    QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {

        if (rule->options.inject.offset == -1) {

            break;

    if (err) {

        return err;

    }



    return bdrv_co_flush(bs->file->bs);

}



static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs,

                                                  int64_t offset, int count,

                                                  BdrvRequestFlags flags)

{

    uint32_t align = MAX(bs->bl.request_alignment,

                         bs->bl.pwrite_zeroes_alignment);

    int err;



    /* Only pass through requests that are larger than requested

     * preferred alignment (so that we test the fallback to writes on

     * unaligned portions), and check that the block layer never hands

     * us anything unaligned that crosses an alignment boundary.  */

    if (count < align) {

        assert(QEMU_IS_ALIGNED(offset, align) ||

               QEMU_IS_ALIGNED(offset + count, align) ||

               DIV_ROUND_UP(offset, align) ==

               DIV_ROUND_UP(offset + count, align));

        return -ENOTSUP;

    }

    assert(QEMU_IS_ALIGNED(offset, align));

    assert(QEMU_IS_ALIGNED(count, align));

    if (bs->bl.max_pwrite_zeroes) {

        assert(count <= bs->bl.max_pwrite_zeroes);

    }



    if (rule && rule->options.inject.error) {

        return inject_error(bs, rule);

    err = rule_check(bs, offset, count);

    if (err) {

        return err;

    }



    return bdrv_co_flush(bs->file->bs);

    return bdrv_co_pwrite_zeroes(bs->file, offset, count, flags);

}



static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs,

                                             int64_t offset, int count)

{

    uint32_t align = bs->bl.pdiscard_alignment;

    int err;



    /* Only pass through requests that are larger than requested

     * minimum alignment, and ensure that unaligned requests do not

     * cross optimum discard boundaries. */

    if (count < bs->bl.request_alignment) {

        assert(QEMU_IS_ALIGNED(offset, align) ||

               QEMU_IS_ALIGNED(offset + count, align) ||

               DIV_ROUND_UP(offset, align) ==

               DIV_ROUND_UP(offset + count, align));

        return -ENOTSUP;

    }

    assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment));

    assert(QEMU_IS_ALIGNED(count, bs->bl.request_alignment));

    if (align && count >= align) {

        assert(QEMU_IS_ALIGNED(offset, align));

        assert(QEMU_IS_ALIGNED(count, align));

    }

    if (bs->bl.max_pdiscard) {

        assert(count <= bs->bl.max_pdiscard);

    }



    err = rule_check(bs, offset, count);

    if (err) {

        return err;

    }



    return bdrv_co_pdiscard(bs->file->bs, offset, count);

}



static void blkdebug_close(BlockDriverState *bs)

{
@@ -715,6 +868,21 @@ static void blkdebug_refresh_limits(BlockDriverState *bs, Error **errp) 
    if (s->align) {

        bs->bl.request_alignment = s->align;

    }

    if (s->max_transfer) {

        bs->bl.max_transfer = s->max_transfer;

    }

    if (s->opt_write_zero) {

        bs->bl.pwrite_zeroes_alignment = s->opt_write_zero;

    }

    if (s->max_write_zero) {

        bs->bl.max_pwrite_zeroes = s->max_write_zero;

    }

    if (s->opt_discard) {

        bs->bl.pdiscard_alignment = s->opt_discard;

    }

    if (s->max_discard) {

        bs->bl.max_pdiscard = s->max_discard;

    }

}



static int blkdebug_reopen_prepare(BDRVReopenState *reopen_state,
@@ -742,6 +910,8 @@ static BlockDriver bdrv_blkdebug = { 
    .bdrv_co_preadv         = blkdebug_co_preadv,

    .bdrv_co_pwritev        = blkdebug_co_pwritev,

    .bdrv_co_flush_to_disk  = blkdebug_co_flush,

    .bdrv_co_pwrite_zeroes  = blkdebug_co_pwrite_zeroes,

    .bdrv_co_pdiscard       = blkdebug_co_pdiscard,



    .bdrv_debug_event           = blkdebug_debug_event,

    .bdrv_debug_breakpoint      = blkdebug_debug_breakpoint,

block/block-backend.c

+53 −28
Original line number Diff line number Diff line
@@ -130,6 +130,56 @@ static const char *blk_root_get_name(BdrvChild *child) 
    return blk_name(child->opaque);

}



/*

 * Notifies the user of the BlockBackend that migration has completed. qdev

 * devices can tighten their permissions in response (specifically revoke

 * shared write permissions that we needed for storage migration).

 *

 * If an error is returned, the VM cannot be allowed to be resumed.

 */

static void blk_root_activate(BdrvChild *child, Error **errp)

{

    BlockBackend *blk = child->opaque;

    Error *local_err = NULL;



    if (!blk->disable_perm) {

        return;

    }



    blk->disable_perm = false;



    blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);

    if (local_err) {

        error_propagate(errp, local_err);

        blk->disable_perm = true;

        return;

    }

}



static int blk_root_inactivate(BdrvChild *child)

{

    BlockBackend *blk = child->opaque;



    if (blk->disable_perm) {

        return 0;

    }



    /* Only inactivate BlockBackends for guest devices (which are inactive at

     * this point because the VM is stopped) and unattached monitor-owned

     * BlockBackends. If there is still any other user like a block job, then

     * we simply can't inactivate the image. */

    if (!blk->dev && !blk->name[0]) {

        return -EPERM;

    }



    blk->disable_perm = true;

    if (blk->root) {

        bdrv_child_try_set_perm(blk->root, 0, BLK_PERM_ALL, &error_abort);

    }



    return 0;

}



static const BdrvChildRole child_root = {

    .inherit_options    = blk_root_inherit_options,
@@ -140,6 +190,9 @@ static const BdrvChildRole child_root = { 


    .drained_begin      = blk_root_drained_begin,

    .drained_end        = blk_root_drained_end,



    .activate           = blk_root_activate,

    .inactivate         = blk_root_inactivate,

};



/*
@@ -601,34 +654,6 @@ void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm) 
    *shared_perm = blk->shared_perm;

}



/*

 * Notifies the user of all BlockBackends that migration has completed. qdev

 * devices can tighten their permissions in response (specifically revoke

 * shared write permissions that we needed for storage migration).

 *

 * If an error is returned, the VM cannot be allowed to be resumed.

 */

void blk_resume_after_migration(Error **errp)

{

    BlockBackend *blk;

    Error *local_err = NULL;



    for (blk = blk_all_next(NULL); blk; blk = blk_all_next(blk)) {

        if (!blk->disable_perm) {

            continue;

        }



        blk->disable_perm = false;



        blk_set_perm(blk, blk->perm, blk->shared_perm, &local_err);

        if (local_err) {

            error_propagate(errp, local_err);

            blk->disable_perm = true;

            return;

        }

    }

}



static int blk_do_attach_dev(BlockBackend *blk, void *dev)

{

    if (blk->dev) {

block/file-posix.c

+247 −1

File changed.

Preview size limit exceeded, changes collapsed.