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

Merge remote-tracking branch 'remotes/maxreitz/tags/pull-block-2019-07-02' into staging 



Block patches for 4.1-rc0:
- The stream job no longer relies on a fixed base node
- The rbd block driver can now accomodate growing formats like qcow2

# gpg: Signature made Tue 02 Jul 2019 02:56:06 BST
# gpg:                using RSA key 91BEB60A30DB3E8857D11829F407DB0061D5CF40
# gpg:                issuer "mreitz@redhat.com"
# gpg: Good signature from "Max Reitz <mreitz@redhat.com>" [full]
# Primary key fingerprint: 91BE B60A 30DB 3E88 57D1  1829 F407 DB00 61D5 CF40

* remotes/maxreitz/tags/pull-block-2019-07-02:
  block/stream: introduce a bottom node
  block/stream: refactor stream_run: drop goto
  block: include base when checking image chain for block allocation
  block/rbd: increase dynamically the image size

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 8ef53cdb c624b015

block/commit.c

+1 −1
Original line number Diff line number Diff line
@@ -174,7 +174,7 @@ static int coroutine_fn commit_run(Job *job, Error **errp) 
            break;

        }

        /* Copy if allocated above the base */

        ret = bdrv_is_allocated_above(blk_bs(s->top), blk_bs(s->base),

        ret = bdrv_is_allocated_above(blk_bs(s->top), blk_bs(s->base), false,

                                      offset, COMMIT_BUFFER_SIZE, &n);

        copy = (ret == 1);

        trace_commit_one_iteration(s, offset, n, ret);

block/io.c

+15 −6
Original line number Diff line number Diff line
@@ -2295,10 +2295,11 @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset, 
/*

 * Given an image chain: ... -> [BASE] -> [INTER1] -> [INTER2] -> [TOP]

 *

 * Return true if (a prefix of) the given range is allocated in any image

 * between BASE and TOP (inclusive).  BASE can be NULL to check if the given

 * offset is allocated in any image of the chain.  Return false otherwise,

 * or negative errno on failure.

 * Return 1 if (a prefix of) the given range is allocated in any image

 * between BASE and TOP (BASE is only included if include_base is set).

 * BASE can be NULL to check if the given offset is allocated in any

 * image of the chain.  Return 0 otherwise, or negative errno on

 * failure.

 *

 * 'pnum' is set to the number of bytes (including and immediately

 * following the specified offset) that are known to be in the same
@@ -2310,17 +2311,21 @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset, 
 */

int bdrv_is_allocated_above(BlockDriverState *top,

                            BlockDriverState *base,

                            int64_t offset, int64_t bytes, int64_t *pnum)

                            bool include_base, int64_t offset,

                            int64_t bytes, int64_t *pnum)

{

    BlockDriverState *intermediate;

    int ret;

    int64_t n = bytes;



    assert(base || !include_base);



    intermediate = top;

    while (intermediate && intermediate != base) {

    while (include_base || intermediate != base) {

        int64_t pnum_inter;

        int64_t size_inter;



        assert(intermediate);

        ret = bdrv_is_allocated(intermediate, offset, bytes, &pnum_inter);

        if (ret < 0) {

            return ret;
@@ -2339,6 +2344,10 @@ int bdrv_is_allocated_above(BlockDriverState *top, 
            n = pnum_inter;

        }



        if (intermediate == base) {

            break;

        }



        intermediate = backing_bs(intermediate);

    }

block/mirror.c

+1 −1
Original line number Diff line number Diff line
@@ -808,7 +808,7 @@ static int coroutine_fn mirror_dirty_init(MirrorBlockJob *s) 
            return 0;

        }



        ret = bdrv_is_allocated_above(bs, base, offset, bytes, &count);

        ret = bdrv_is_allocated_above(bs, base, false, offset, bytes, &count);

        if (ret < 0) {

            return ret;

        }

block/qcow2.c

+2 −1
Original line number Diff line number Diff line
@@ -2148,7 +2148,8 @@ static bool is_unallocated(BlockDriverState *bs, int64_t offset, int64_t bytes) 
{

    int64_t nr;

    return !bytes ||

        (!bdrv_is_allocated_above(bs, NULL, offset, bytes, &nr) && nr == bytes);

        (!bdrv_is_allocated_above(bs, NULL, false, offset, bytes, &nr) &&

         nr == bytes);

}



static bool is_zero_cow(BlockDriverState *bs, QCowL2Meta *m)

block/rbd.c

+39 −3
Original line number Diff line number Diff line
@@ -103,6 +103,7 @@ typedef struct BDRVRBDState { 
    rbd_image_t image;

    char *image_name;

    char *snap;

    uint64_t image_size;

} BDRVRBDState;



static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
@@ -778,6 +779,14 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags, 
        goto failed_open;

    }



    r = rbd_get_size(s->image, &s->image_size);

    if (r < 0) {

        error_setg_errno(errp, -r, "error getting image size from %s",

                         s->image_name);

        rbd_close(s->image);

        goto failed_open;

    }



    /* If we are using an rbd snapshot, we must be r/o, otherwise

     * leave as-is */

    if (s->snap != NULL) {
@@ -834,6 +843,22 @@ static void qemu_rbd_close(BlockDriverState *bs) 
    rados_shutdown(s->cluster);

}



/* Resize the RBD image and update the 'image_size' with the current size */

static int qemu_rbd_resize(BlockDriverState *bs, uint64_t size)

{

    BDRVRBDState *s = bs->opaque;

    int r;



    r = rbd_resize(s->image, size);

    if (r < 0) {

        return r;

    }



    s->image_size = size;



    return 0;

}



static const AIOCBInfo rbd_aiocb_info = {

    .aiocb_size = sizeof(RBDAIOCB),

};
@@ -935,13 +960,25 @@ static BlockAIOCB *rbd_start_aio(BlockDriverState *bs, 
    }



    switch (cmd) {

    case RBD_AIO_WRITE:

    case RBD_AIO_WRITE: {

        /*

         * RBD APIs don't allow us to write more than actual size, so in order

         * to support growing images, we resize the image before write

         * operations that exceed the current size.

         */

        if (off + size > s->image_size) {

            r = qemu_rbd_resize(bs, off + size);

            if (r < 0) {

                goto failed_completion;

            }

        }

#ifdef LIBRBD_SUPPORTS_IOVEC

            r = rbd_aio_writev(s->image, qiov->iov, qiov->niov, off, c);

#else

            r = rbd_aio_write(s->image, off, size, rcb->buf, c);

#endif

        break;

    }

    case RBD_AIO_READ:

#ifdef LIBRBD_SUPPORTS_IOVEC

            r = rbd_aio_readv(s->image, qiov->iov, qiov->niov, off, c);
@@ -1052,7 +1089,6 @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs, 
                                             PreallocMode prealloc,

                                             Error **errp)

{

    BDRVRBDState *s = bs->opaque;

    int r;



    if (prealloc != PREALLOC_MODE_OFF) {
@@ -1061,7 +1097,7 @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs, 
        return -ENOTSUP;

    }



    r = rbd_resize(s->image, offset);

    r = qemu_rbd_resize(bs, offset);

    if (r < 0) {

        error_setg_errno(errp, -r, "Failed to resize file");

        return r;