Commit 704e41ba authored by Kevin Wolf's avatar Kevin Wolf
Browse files

Merge remote-tracking branch 'mreitz/tags/pull-block-2017-06-26' into queue-block 



Block patches for the block queue

# gpg: Signature made Mon Jun 26 14:56:24 2017 CEST
# gpg:                using RSA key 0xF407DB0061D5CF40
# gpg: Good signature from "Max Reitz <mreitz@redhat.com>"
# Primary key fingerprint: 91BE B60A 30DB 3E88 57D1  1829 F407 DB00 61D5 CF40

* mreitz/tags/pull-block-2017-06-26:
  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

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parents c5f1ad42 2a245709

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,

block/file-posix.c

+17 −17
Original line number Diff line number Diff line
@@ -1485,7 +1485,7 @@ static int aio_worker(void *arg) 


static int paio_submit_co(BlockDriverState *bs, int fd,

                          int64_t offset, QEMUIOVector *qiov,

                          int count, int type)

                          int bytes, int type)

{

    RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);

    ThreadPool *pool;
@@ -1494,22 +1494,22 @@ static int paio_submit_co(BlockDriverState *bs, int fd, 
    acb->aio_type = type;

    acb->aio_fildes = fd;



    acb->aio_nbytes = count;

    acb->aio_nbytes = bytes;

    acb->aio_offset = offset;



    if (qiov) {

        acb->aio_iov = qiov->iov;

        acb->aio_niov = qiov->niov;

        assert(qiov->size == count);

        assert(qiov->size == bytes);

    }



    trace_paio_submit_co(offset, count, type);

    trace_paio_submit_co(offset, bytes, type);

    pool = aio_get_thread_pool(bdrv_get_aio_context(bs));

    return thread_pool_submit_co(pool, aio_worker, acb);

}



static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd,

        int64_t offset, QEMUIOVector *qiov, int count,

        int64_t offset, QEMUIOVector *qiov, int bytes,

        BlockCompletionFunc *cb, void *opaque, int type)

{

    RawPosixAIOData *acb = g_new(RawPosixAIOData, 1);
@@ -1519,7 +1519,7 @@ static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd, 
    acb->aio_type = type;

    acb->aio_fildes = fd;



    acb->aio_nbytes = count;

    acb->aio_nbytes = bytes;

    acb->aio_offset = offset;



    if (qiov) {
@@ -1528,7 +1528,7 @@ static BlockAIOCB *paio_submit(BlockDriverState *bs, int fd, 
        assert(qiov->size == acb->aio_nbytes);

    }



    trace_paio_submit(acb, opaque, offset, count, type);

    trace_paio_submit(acb, opaque, offset, bytes, type);

    pool = aio_get_thread_pool(bdrv_get_aio_context(bs));

    return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);

}
@@ -2109,26 +2109,26 @@ static int64_t coroutine_fn raw_co_get_block_status(BlockDriverState *bs, 
}



static coroutine_fn BlockAIOCB *raw_aio_pdiscard(BlockDriverState *bs,

    int64_t offset, int count,

    int64_t offset, int bytes,

    BlockCompletionFunc *cb, void *opaque)

{

    BDRVRawState *s = bs->opaque;



    return paio_submit(bs, s->fd, offset, NULL, count,

    return paio_submit(bs, s->fd, offset, NULL, bytes,

                       cb, opaque, QEMU_AIO_DISCARD);

}



static int coroutine_fn raw_co_pwrite_zeroes(

    BlockDriverState *bs, int64_t offset,

    int count, BdrvRequestFlags flags)

    int bytes, BdrvRequestFlags flags)

{

    BDRVRawState *s = bs->opaque;



    if (!(flags & BDRV_REQ_MAY_UNMAP)) {

        return paio_submit_co(bs, s->fd, offset, NULL, count,

        return paio_submit_co(bs, s->fd, offset, NULL, bytes,

                              QEMU_AIO_WRITE_ZEROES);

    } else if (s->discard_zeroes) {

        return paio_submit_co(bs, s->fd, offset, NULL, count,

        return paio_submit_co(bs, s->fd, offset, NULL, bytes,

                              QEMU_AIO_DISCARD);

    }

    return -ENOTSUP;
@@ -2560,7 +2560,7 @@ static int fd_open(BlockDriverState *bs) 
}



static coroutine_fn BlockAIOCB *hdev_aio_pdiscard(BlockDriverState *bs,

    int64_t offset, int count,

    int64_t offset, int bytes,

    BlockCompletionFunc *cb, void *opaque)

{

    BDRVRawState *s = bs->opaque;
@@ -2568,12 +2568,12 @@ static coroutine_fn BlockAIOCB *hdev_aio_pdiscard(BlockDriverState *bs, 
    if (fd_open(bs) < 0) {

        return NULL;

    }

    return paio_submit(bs, s->fd, offset, NULL, count,

    return paio_submit(bs, s->fd, offset, NULL, bytes,

                       cb, opaque, QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);

}



static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,

    int64_t offset, int count, BdrvRequestFlags flags)

    int64_t offset, int bytes, BdrvRequestFlags flags)

{

    BDRVRawState *s = bs->opaque;

    int rc;
@@ -2583,10 +2583,10 @@ static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs, 
        return rc;

    }

    if (!(flags & BDRV_REQ_MAY_UNMAP)) {

        return paio_submit_co(bs, s->fd, offset, NULL, count,

        return paio_submit_co(bs, s->fd, offset, NULL, bytes,

                              QEMU_AIO_WRITE_ZEROES|QEMU_AIO_BLKDEV);

    } else if (s->discard_zeroes) {

        return paio_submit_co(bs, s->fd, offset, NULL, count,

        return paio_submit_co(bs, s->fd, offset, NULL, bytes,

                              QEMU_AIO_DISCARD|QEMU_AIO_BLKDEV);

    }

    return -ENOTSUP;