Commit 365fed51 authored by Eric Blake's avatar Eric Blake Committed by Max Reitz
Browse files

qed: Simplify backing reads 



The other four drivers that support backing files (qcow, qcow2,
parallels, vmdk) all rely on the block layer to populate zeroes when
reading beyond EOF of a short backing file.  We can simplify the qed
code by doing likewise.

Signed-off-by: default avatarEric Blake <eblake@redhat.com>
Reviewed-by: default avatarVladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200528094405.145708-11-vsementsov@virtuozzo.com>
Signed-off-by: default avatarMax Reitz <mreitz@redhat.com>
parent a2adbbf6

block/qed.c

+6 −58
Original line number Diff line number Diff line
@@ -849,56 +849,18 @@ static BDRVQEDState *acb_to_s(QEDAIOCB *acb) 
 * @s:              QED state

 * @pos:            Byte position in device

 * @qiov:           Destination I/O vector

 * @backing_qiov:   Possibly shortened copy of qiov, to be allocated here

 * @cb:             Completion function

 * @opaque:         User data for completion function

 *

 * This function reads qiov->size bytes starting at pos from the backing file.

 * If there is no backing file then zeroes are read.

 */

static int coroutine_fn qed_read_backing_file(BDRVQEDState *s, uint64_t pos,

                                              QEMUIOVector *qiov,

                                              QEMUIOVector **backing_qiov)

                                              QEMUIOVector *qiov)

{

    uint64_t backing_length = 0;

    size_t size;

    int ret;



    /* If there is a backing file, get its length.  Treat the absence of a

     * backing file like a zero length backing file.

     */

    if (s->bs->backing) {

        int64_t l = bdrv_getlength(s->bs->backing->bs);

        if (l < 0) {

            return l;

        }

        backing_length = l;

    }



    /* Zero all sectors if reading beyond the end of the backing file */

    if (pos >= backing_length ||

        pos + qiov->size > backing_length) {

        qemu_iovec_memset(qiov, 0, 0, qiov->size);

    }



    /* Complete now if there are no backing file sectors to read */

    if (pos >= backing_length) {

        return 0;

    }



    /* If the read straddles the end of the backing file, shorten it */

    size = MIN((uint64_t)backing_length - pos, qiov->size);



    assert(*backing_qiov == NULL);

    *backing_qiov = g_new(QEMUIOVector, 1);

    qemu_iovec_init(*backing_qiov, qiov->niov);

    qemu_iovec_concat(*backing_qiov, qiov, 0, size);



        BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);

    ret = bdrv_co_preadv(s->bs->backing, pos, size, *backing_qiov, 0);

    if (ret < 0) {

        return ret;

        return bdrv_co_preadv(s->bs->backing, pos, qiov->size, qiov, 0);

    }

    qemu_iovec_memset(qiov, 0, 0, qiov->size);

    return 0;

}
@@ -915,7 +877,6 @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s, 
                                                   uint64_t offset)

{

    QEMUIOVector qiov;

    QEMUIOVector *backing_qiov = NULL;

    int ret;



    /* Skip copy entirely if there is no work to do */
@@ -925,13 +886,7 @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s, 


    qemu_iovec_init_buf(&qiov, qemu_blockalign(s->bs, len), len);



    ret = qed_read_backing_file(s, pos, &qiov, &backing_qiov);



    if (backing_qiov) {

        qemu_iovec_destroy(backing_qiov);

        g_free(backing_qiov);

        backing_qiov = NULL;

    }

    ret = qed_read_backing_file(s, pos, &qiov);



    if (ret) {

        goto out;
@@ -1339,8 +1294,7 @@ static int coroutine_fn qed_aio_read_data(void *opaque, int ret, 
        qemu_iovec_memset(&acb->cur_qiov, 0, 0, acb->cur_qiov.size);

        r = 0;

    } else if (ret != QED_CLUSTER_FOUND) {

        r = qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov,

                                  &acb->backing_qiov);

        r = qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov);

    } else {

        BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);

        r = bdrv_co_preadv(bs->file, offset, acb->cur_qiov.size,
@@ -1365,12 +1319,6 @@ static int coroutine_fn qed_aio_next_io(QEDAIOCB *acb) 
    while (1) {

        trace_qed_aio_next_io(s, acb, 0, acb->cur_pos + acb->cur_qiov.size);



        if (acb->backing_qiov) {

            qemu_iovec_destroy(acb->backing_qiov);

            g_free(acb->backing_qiov);

            acb->backing_qiov = NULL;

        }



        acb->qiov_offset += acb->cur_qiov.size;

        acb->cur_pos += acb->cur_qiov.size;

        qemu_iovec_reset(&acb->cur_qiov);

block/qed.h

+0 −1
Original line number Diff line number Diff line
@@ -140,7 +140,6 @@ typedef struct QEDAIOCB { 


    /* Current cluster scatter-gather list */

    QEMUIOVector cur_qiov;

    QEMUIOVector *backing_qiov;

    uint64_t cur_pos;               /* position on block device, in bytes */

    uint64_t cur_cluster;           /* cluster offset in image file */

    unsigned int cur_nclusters;     /* number of clusters being accessed */