Commit 054914f6 authored by Peter Maydell's avatar Peter Maydell
Browse files

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



Block layer patches

# gpg: Signature made Mon 26 Jun 2017 14:07:32 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: (60 commits)
  qemu-img: don't shadow opts variable in img_dd()
  block: Do not strcmp() with NULL uri->scheme
  blkverify: Catch bs->exact_filename overflow
  blkdebug: Catch bs->exact_filename overflow
  fix: avoid an infinite loop or a dangling pointer problem in img_commit
  block: change variable names in BlockDriverState
  block: Remove bdrv_aio_readv/writev/flush()
  qed: Use bdrv_co_* for coroutine_fns
  qed: Add coroutine_fn to I/O path functions
  qed: Use a coroutine for need_check_timer
  qed: Simplify request handling
  qed: Use CoQueue for serialising allocations
  qed: Implement .bdrv_co_readv/writev
  qed: Remove recursion in qed_aio_next_io()
  qed: Remove ret argument from qed_aio_next_io()
  qed: Add return value to qed_aio_read/write_data()
  qed: Add return value to qed_aio_write_inplace/alloc()
  qed: Add return value to qed_aio_write_cow()
  qed: Add return value to qed_aio_write_main()
  qed: Add return value to qed_aio_write_l2_update()
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents b01a4fd3 704e41ba

block/Makefile.objs

+1 −1
Original line number Diff line number Diff line 
block-obj-y += raw-format.o qcow.o vdi.o vmdk.o cloop.o bochs.o vpc.o vvfat.o dmg.o

block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o

block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o

block-obj-y += qed.o qed-l2-cache.o qed-table.o qed-cluster.o

block-obj-y += qed-check.o

block-obj-y += vhdx.o vhdx-endian.o vhdx-log.o

block-obj-y += quorum.o

block/blkdebug.c

+25 −21
Original line number Diff line number Diff line
@@ -575,7 +575,7 @@ static int blkdebug_co_flush(BlockDriverState *bs) 
}



static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs,

                                                  int64_t offset, int count,

                                                  int64_t offset, int bytes,

                                                  BdrvRequestFlags flags)

{

    uint32_t align = MAX(bs->bl.request_alignment,
@@ -586,29 +586,29 @@ static int coroutine_fn blkdebug_co_pwrite_zeroes(BlockDriverState *bs, 
     * 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) {

    if (bytes < align) {

        assert(QEMU_IS_ALIGNED(offset, align) ||

               QEMU_IS_ALIGNED(offset + count, align) ||

               QEMU_IS_ALIGNED(offset + bytes, align) ||

               DIV_ROUND_UP(offset, align) ==

               DIV_ROUND_UP(offset + count, align));

               DIV_ROUND_UP(offset + bytes, align));

        return -ENOTSUP;

    }

    assert(QEMU_IS_ALIGNED(offset, align));

    assert(QEMU_IS_ALIGNED(count, align));

    assert(QEMU_IS_ALIGNED(bytes, align));

    if (bs->bl.max_pwrite_zeroes) {

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

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

    }



    err = rule_check(bs, offset, count);

    err = rule_check(bs, offset, bytes);

    if (err) {

        return err;

    }



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

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

}



static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs,

                                             int64_t offset, int count)

                                             int64_t offset, int bytes)

{

    uint32_t align = bs->bl.pdiscard_alignment;

    int err;
@@ -616,29 +616,29 @@ static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs, 
    /* 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) {

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

        assert(QEMU_IS_ALIGNED(offset, align) ||

               QEMU_IS_ALIGNED(offset + count, align) ||

               QEMU_IS_ALIGNED(offset + bytes, align) ||

               DIV_ROUND_UP(offset, align) ==

               DIV_ROUND_UP(offset + count, align));

               DIV_ROUND_UP(offset + bytes, 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(bytes, bs->bl.request_alignment));

    if (align && bytes >= align) {

        assert(QEMU_IS_ALIGNED(offset, align));

        assert(QEMU_IS_ALIGNED(count, align));

        assert(QEMU_IS_ALIGNED(bytes, align));

    }

    if (bs->bl.max_pdiscard) {

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

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

    }



    err = rule_check(bs, offset, count);

    err = rule_check(bs, offset, bytes);

    if (err) {

        return err;

    }



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

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

}



static void blkdebug_close(BlockDriverState *bs)
@@ -839,9 +839,13 @@ static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options) 
    }



    if (!force_json && bs->file->bs->exact_filename[0]) {

        snprintf(bs->exact_filename, sizeof(bs->exact_filename),

        int ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),

                           "blkdebug:%s:%s", s->config_file ?: "",

                           bs->file->bs->exact_filename);

        if (ret >= sizeof(bs->exact_filename)) {

            /* An overflow makes the filename unusable, so do not report any */

            bs->exact_filename[0] = 0;

        }

    }



    opts = qdict_new();

block/blkreplay.c

+4 −4
Original line number Diff line number Diff line
@@ -96,10 +96,10 @@ static int coroutine_fn blkreplay_co_pwritev(BlockDriverState *bs, 
}



static int coroutine_fn blkreplay_co_pwrite_zeroes(BlockDriverState *bs,

    int64_t offset, int count, BdrvRequestFlags flags)

    int64_t offset, int bytes, BdrvRequestFlags flags)

{

    uint64_t reqid = blkreplay_next_id();

    int ret = bdrv_co_pwrite_zeroes(bs->file, offset, count, flags);

    int ret = bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags);

    block_request_create(reqid, bs, qemu_coroutine_self());

    qemu_coroutine_yield();
@@ -107,10 +107,10 @@ static int coroutine_fn blkreplay_co_pwrite_zeroes(BlockDriverState *bs, 
}



static int coroutine_fn blkreplay_co_pdiscard(BlockDriverState *bs,

                                              int64_t offset, int count)

                                              int64_t offset, int bytes)

{

    uint64_t reqid = blkreplay_next_id();

    int ret = bdrv_co_pdiscard(bs->file->bs, offset, count);

    int ret = bdrv_co_pdiscard(bs->file->bs, offset, bytes);

    block_request_create(reqid, bs, qemu_coroutine_self());

    qemu_coroutine_yield();

block/blkverify.c

+8 −4
Original line number Diff line number Diff line
@@ -301,10 +301,14 @@ static void blkverify_refresh_filename(BlockDriverState *bs, QDict *options) 
    if (bs->file->bs->exact_filename[0]

        && s->test_file->bs->exact_filename[0])

    {

        snprintf(bs->exact_filename, sizeof(bs->exact_filename),

        int ret = snprintf(bs->exact_filename, sizeof(bs->exact_filename),

                           "blkverify:%s:%s",

                           bs->file->bs->exact_filename,

                           s->test_file->bs->exact_filename);

        if (ret >= sizeof(bs->exact_filename)) {

            /* An overflow makes the filename unusable, so do not report any */

            bs->exact_filename[0] = 0;

        }

    }

}

block/block-backend.c

+11 −11
Original line number Diff line number Diff line
@@ -1099,9 +1099,9 @@ int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf, 
}



int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,

                      int count, BdrvRequestFlags flags)

                      int bytes, BdrvRequestFlags flags)

{

    return blk_prw(blk, offset, NULL, count, blk_write_entry,

    return blk_prw(blk, offset, NULL, bytes, blk_write_entry,

                   flags | BDRV_REQ_ZERO_WRITE);

}
@@ -1311,10 +1311,10 @@ static void blk_aio_pdiscard_entry(void *opaque) 
}



BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk,

                             int64_t offset, int count,

                             int64_t offset, int bytes,

                             BlockCompletionFunc *cb, void *opaque)

{

    return blk_aio_prwv(blk, offset, count, NULL, blk_aio_pdiscard_entry, 0,

    return blk_aio_prwv(blk, offset, bytes, NULL, blk_aio_pdiscard_entry, 0,

                        cb, opaque);

}
@@ -1374,14 +1374,14 @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf, 
    return blk_aio_prwv(blk, req, 0, &qiov, blk_aio_ioctl_entry, 0, cb, opaque);

}



int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int count)

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

{

    int ret = blk_check_byte_request(blk, offset, count);

    int ret = blk_check_byte_request(blk, offset, bytes);

    if (ret < 0) {

        return ret;

    }



    return bdrv_co_pdiscard(blk_bs(blk), offset, count);

    return bdrv_co_pdiscard(blk_bs(blk), offset, bytes);

}



int blk_co_flush(BlockBackend *blk)
@@ -1760,9 +1760,9 @@ void *blk_aio_get(const AIOCBInfo *aiocb_info, BlockBackend *blk, 
}



int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,

                                      int count, BdrvRequestFlags flags)

                                      int bytes, BdrvRequestFlags flags)

{

    return blk_co_pwritev(blk, offset, count, NULL,

    return blk_co_pwritev(blk, offset, bytes, NULL,

                          flags | BDRV_REQ_ZERO_WRITE);

}
@@ -1789,9 +1789,9 @@ static void blk_pdiscard_entry(void *opaque) 
    rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, rwco->qiov->size);

}



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

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

{

    return blk_prw(blk, offset, NULL, count, blk_pdiscard_entry, 0);

    return blk_prw(blk, offset, NULL, bytes, blk_pdiscard_entry, 0);

}



int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,