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

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



Block layer patches:

- vmdk: Support for blockdev-create
- block: Apply auto-read-only for ro-whitelist drivers
- virtio-scsi: Fixes related to attaching/detaching iothreads
- scsi-disk: Fixed erroneously detected multipath setup with multiple
  disks created with node-names. Added device_id property.
- block: Fix hangs in synchronous APIs with iothreads
- block: Fix invalidate_cache error path for parent activation
- block-backend, mirror, qcow2, vpc, vdi, qemu-iotests:
  Minor fixes and code improvements

# gpg: Signature made Fri 01 Feb 2019 15:23:10 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: (27 commits)
  scsi-disk: Add device_id property
  scsi-disk: Don't use empty string as device id
  qtest.py: Wait for the result of qtest commands
  block: Fix invalidate_cache error path for parent activation
  iotests/236: fix transaction kwarg order
  iotests: Filter second BLOCK_JOB_ERROR from 229
  virtio-scsi: Forbid devices with different iothreads sharing a blockdev
  scsi-disk: Acquire the AioContext in scsi_*_realize()
  virtio-scsi: Move BlockBackend back to the main AioContext on unplug
  block: Eliminate the S_1KiB, S_2KiB, ... macros
  block: Remove blk_attach_dev_legacy() / legacy_dev code
  block: Apply auto-read-only for ro-whitelist drivers
  uuid: Make qemu_uuid_bswap() take and return a QemuUUID
  block/vdi: Don't take address of fields in packed structs
  block/vpc: Don't take address of fields in packed structs
  vmdk: Reject excess extents in blockdev-create
  iotests: Add VMDK tests for blockdev-create
  iotests: Filter cid numbers in VMDK extent info
  vmdk: Implement .bdrv_co_create callback
  vmdk: Refactor vmdk_create_extent
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents e83d7428 7471a649

block.c

+18 −9
Original line number Diff line number Diff line
@@ -1438,14 +1438,20 @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file, 
    bs->read_only = !(bs->open_flags & BDRV_O_RDWR);



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

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

            ret = bdrv_apply_auto_read_only(bs, NULL, NULL);

        } else {

            ret = -ENOTSUP;

        }

        if (ret < 0) {

            error_setg(errp,

                       !bs->read_only && bdrv_is_whitelisted(drv, true)

                       ? "Driver '%s' can only be used for read-only devices"

                       : "Driver '%s' is not whitelisted",

                       drv->format_name);

        ret = -ENOTSUP;

            goto fail_opts;

        }

    }



    /* bdrv_new() and bdrv_close() make it so */

    assert(atomic_read(&bs->copy_on_read) == 0);
@@ -3725,6 +3731,7 @@ static void bdrv_check_co_entry(void *opaque) 
{

    CheckCo *cco = opaque;

    cco->ret = bdrv_co_check(cco->bs, cco->res, cco->fix);

    aio_wait_kick();

}



int bdrv_check(BlockDriverState *bs,
@@ -3743,7 +3750,7 @@ int bdrv_check(BlockDriverState *bs, 
        bdrv_check_co_entry(&cco);

    } else {

        co = qemu_coroutine_create(bdrv_check_co_entry, &cco);

        qemu_coroutine_enter(co);

        bdrv_coroutine_enter(bs, co);

        BDRV_POLL_WHILE(bs, cco.ret == -EINPROGRESS);

    }
@@ -4690,6 +4697,7 @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs, 
        if (parent->role->activate) {

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

            if (local_err) {

                bs->open_flags |= BDRV_O_INACTIVE;

                error_propagate(errp, local_err);

                return;

            }
@@ -4708,6 +4716,7 @@ static void coroutine_fn bdrv_invalidate_cache_co_entry(void *opaque) 
    InvalidateCacheCo *ico = opaque;

    bdrv_co_invalidate_cache(ico->bs, ico->errp);

    ico->done = true;

    aio_wait_kick();

}



void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
@@ -4724,7 +4733,7 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 
        bdrv_invalidate_cache_co_entry(&ico);

    } else {

        co = qemu_coroutine_create(bdrv_invalidate_cache_co_entry, &ico);

        qemu_coroutine_enter(co);

        bdrv_coroutine_enter(bs, co);

        BDRV_POLL_WHILE(bs, !ico.done);

    }

}

block/blklogwrites.c

+2 −3
Original line number Diff line number Diff line
@@ -295,10 +295,9 @@ static void blk_log_writes_refresh_filename(BlockDriverState *bs, 
        qdict_put_str(opts, "driver", "blklogwrites");



        qobject_ref(bs->file->bs->full_open_options);

        qdict_put_obj(opts, "file", QOBJECT(bs->file->bs->full_open_options));

        qdict_put(opts, "file", bs->file->bs->full_open_options);

        qobject_ref(s->log_file->bs->full_open_options);

        qdict_put_obj(opts, "log",

                      QOBJECT(s->log_file->bs->full_open_options));

        qdict_put(opts, "log", s->log_file->bs->full_open_options);

        qdict_put_int(opts, "log-sector-size", s->sectorsize);



        bs->full_open_options = opts;

block/block-backend.c

+14 −45
Original line number Diff line number Diff line
@@ -47,9 +47,7 @@ struct BlockBackend { 
    QTAILQ_ENTRY(BlockBackend) monitor_link; /* for monitor_block_backends */

    BlockBackendPublic public;



    void *dev;                  /* attached device model, if any */

    bool legacy_dev;            /* true if dev is not a DeviceState */

    /* TODO change to DeviceState when all users are qdevified */

    DeviceState *dev;           /* attached device model, if any */

    const BlockDevOps *dev_ops;

    void *dev_opaque;
@@ -836,7 +834,11 @@ void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm) 
    *shared_perm = blk->shared_perm;

}



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

/*

 * Attach device model @dev to @blk.

 * Return 0 on success, -EBUSY when a device model is attached already.

 */

int blk_attach_dev(BlockBackend *blk, DeviceState *dev)

{

    if (blk->dev) {

        return -EBUSY;
@@ -851,40 +853,16 @@ static int blk_do_attach_dev(BlockBackend *blk, void *dev) 


    blk_ref(blk);

    blk->dev = dev;

    blk->legacy_dev = false;

    blk_iostatus_reset(blk);



    return 0;

}



/*

 * Attach device model @dev to @blk.

 * Return 0 on success, -EBUSY when a device model is attached already.

 */

int blk_attach_dev(BlockBackend *blk, DeviceState *dev)

{

    return blk_do_attach_dev(blk, dev);

}



/*

 * Attach device model @dev to @blk.

 * @blk must not have a device model attached already.

 * TODO qdevified devices don't use this, remove when devices are qdevified

 */

void blk_attach_dev_legacy(BlockBackend *blk, void *dev)

{

    if (blk_do_attach_dev(blk, dev) < 0) {

        abort();

    }

    blk->legacy_dev = true;

}



/*

 * Detach device model @dev from @blk.

 * @dev must be currently attached to @blk.

 */

void blk_detach_dev(BlockBackend *blk, void *dev)

/* TODO change to DeviceState *dev when all users are qdevified */

void blk_detach_dev(BlockBackend *blk, DeviceState *dev)

{

    assert(blk->dev == dev);

    blk->dev = NULL;
@@ -898,8 +876,7 @@ void blk_detach_dev(BlockBackend *blk, void *dev) 
/*

 * Return the device model attached to @blk if any, else null.

 */

void *blk_get_attached_dev(BlockBackend *blk)

/* TODO change to return DeviceState * when all users are qdevified */

DeviceState *blk_get_attached_dev(BlockBackend *blk)

{

    return blk->dev;

}
@@ -908,10 +885,7 @@ void *blk_get_attached_dev(BlockBackend *blk) 
 * device attached to the BlockBackend. */

char *blk_get_attached_dev_id(BlockBackend *blk)

{

    DeviceState *dev;



    assert(!blk->legacy_dev);

    dev = blk->dev;

    DeviceState *dev = blk->dev;



    if (!dev) {

        return g_strdup("");
@@ -949,11 +923,6 @@ BlockBackend *blk_by_dev(void *dev) 
void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops,

                     void *opaque)

{

    /* All drivers that use blk_set_dev_ops() are qdevified and we want to keep

     * it that way, so we can assume blk->dev, if present, is a DeviceState if

     * blk->dev_ops is set. Non-device users may use dev_ops without device. */

    assert(!blk->legacy_dev);



    blk->dev_ops = ops;

    blk->dev_opaque = opaque;
@@ -979,8 +948,6 @@ void blk_dev_change_media_cb(BlockBackend *blk, bool load, Error **errp) 
        bool tray_was_open, tray_is_open;

        Error *local_err = NULL;



        assert(!blk->legacy_dev);



        tray_was_open = blk_dev_is_tray_open(blk);

        blk->dev_ops->change_media_cb(blk->dev_opaque, load, &local_err);

        if (local_err) {
@@ -1220,6 +1187,7 @@ static void blk_read_entry(void *opaque) 


    rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, qiov->size,

                              qiov, rwco->flags);

    aio_wait_kick();

}



static void blk_write_entry(void *opaque)
@@ -1229,6 +1197,7 @@ static void blk_write_entry(void *opaque) 


    rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, qiov->size,

                               qiov, rwco->flags);

    aio_wait_kick();

}



static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
@@ -1540,6 +1509,7 @@ static void blk_ioctl_entry(void *opaque) 


    rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,

                             qiov->iov[0].iov_base);

    aio_wait_kick();

}



int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
@@ -1586,6 +1556,7 @@ static void blk_flush_entry(void *opaque) 
{

    BlkRwCo *rwco = opaque;

    rwco->ret = blk_co_flush(rwco->blk);

    aio_wait_kick();

}



int blk_flush(BlockBackend *blk)
@@ -1779,9 +1750,6 @@ void blk_eject(BlockBackend *blk, bool eject_flag) 
    BlockDriverState *bs = blk_bs(blk);

    char *id;



    /* blk_eject is only called by qdevified devices */

    assert(!blk->legacy_dev);



    if (bs) {

        bdrv_eject(bs, eject_flag);

    }
@@ -2018,6 +1986,7 @@ static void blk_pdiscard_entry(void *opaque) 
    QEMUIOVector *qiov = rwco->iobuf;



    rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, qiov->size);

    aio_wait_kick();

}



int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes)

block/io.c

+7 −1
Original line number Diff line number Diff line
@@ -806,6 +806,7 @@ static void coroutine_fn bdrv_rw_co_entry(void *opaque) 
                                    rwco->qiov->size, rwco->qiov,

                                    rwco->flags);

    }

    aio_wait_kick();

}



/*
@@ -2279,6 +2280,7 @@ static void coroutine_fn bdrv_block_status_above_co_entry(void *opaque) 
                                           data->offset, data->bytes,

                                           data->pnum, data->map, data->file);

    data->done = true;

    aio_wait_kick();

}



/*
@@ -2438,6 +2440,7 @@ static void coroutine_fn bdrv_co_rw_vmstate_entry(void *opaque) 
{

    BdrvVmstateCo *co = opaque;

    co->ret = bdrv_co_rw_vmstate(co->bs, co->qiov, co->pos, co->is_read);

    aio_wait_kick();

}



static inline int
@@ -2559,6 +2562,7 @@ static void coroutine_fn bdrv_flush_co_entry(void *opaque) 
    FlushCo *rwco = opaque;



    rwco->ret = bdrv_co_flush(rwco->bs);

    aio_wait_kick();

}



int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
@@ -2704,6 +2708,7 @@ static void coroutine_fn bdrv_pdiscard_co_entry(void *opaque) 
    DiscardCo *rwco = opaque;



    rwco->ret = bdrv_co_pdiscard(rwco->child, rwco->offset, rwco->bytes);

    aio_wait_kick();

}



int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int bytes)
@@ -3217,6 +3222,7 @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque) 
    TruncateCo *tco = opaque;

    tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->prealloc,

                                tco->errp);

    aio_wait_kick();

}



int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc,
@@ -3236,7 +3242,7 @@ int bdrv_truncate(BdrvChild *child, int64_t offset, PreallocMode prealloc, 
        bdrv_truncate_co_entry(&tco);

    } else {

        co = qemu_coroutine_create(bdrv_truncate_co_entry, &tco);

        qemu_coroutine_enter(co);

        bdrv_coroutine_enter(child->bs, co);

        BDRV_POLL_WHILE(child->bs, tco.ret == NOT_DONE);

    }

block/mirror.c

+11 −0
Original line number Diff line number Diff line
@@ -1612,6 +1612,14 @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs, 
        goto fail;

    }



    ret = block_job_add_bdrv(&s->common, "source", bs, 0,

                             BLK_PERM_WRITE_UNCHANGED | BLK_PERM_WRITE |

                             BLK_PERM_CONSISTENT_READ,

                             errp);

    if (ret < 0) {

        goto fail;

    }



    /* Required permissions are already taken with blk_new() */

    block_job_add_bdrv(&s->common, "target", target, 0, BLK_PERM_ALL,

                       &error_abort);
@@ -1649,6 +1657,9 @@ fail: 
        g_free(s->replaces);

        blk_unref(s->target);

        bs_opaque->job = NULL;

        if (s->dirty_bitmap) {

            bdrv_release_dirty_bitmap(bs, s->dirty_bitmap);

        }

        job_early_fail(&s->common.job);

    }