Commit 58e2e17d 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 05 Mar 2018 17:45:51 GMT
# gpg:                using RSA key 7F09B272C88F2FD6
# 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: (38 commits)
  block: Fix NULL dereference on empty drive error
  qcow2: Replace align_offset() with ROUND_UP()
  block/ssh: Add basic .bdrv_truncate()
  block/ssh: Make ssh_grow_file() blocking
  block/ssh: Pull ssh_grow_file() from ssh_create()
  qemu-img: Make resize error message more general
  qcow2: make qcow2_co_create2() a coroutine_fn
  block: rename .bdrv_create() to .bdrv_co_create_opts()
  Revert "IDE: Do not flush empty CDROM drives"
  block: test blk_aio_flush() with blk->root == NULL
  block: add BlockBackend->in_flight counter
  block: extract AIO_WAIT_WHILE() from BlockDriverState
  aio: rename aio_context_in_iothread() to in_aio_context_home_thread()
  docs: document how to use the l2-cache-entry-size parameter
  specs/qcow2: Fix documentation of the compressed cluster descriptor
  iotest 033: add misaligned write-zeroes test via truncate
  block: fix write with zero flag set and iovector provided
  block: Drop unused .bdrv_co_get_block_status()
  vvfat: Switch to .bdrv_co_block_status()
  vpc: Switch to .bdrv_co_block_status()
  ...

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

# Conflicts:
#	include/block/block.h
parents e1ee9ee1 bfe1a14c

block.c

+8 −3
Original line number Diff line number Diff line
@@ -418,7 +418,7 @@ static void coroutine_fn bdrv_create_co_entry(void *opaque) 
    CreateCo *cco = opaque;

    assert(cco->drv);



    ret = cco->drv->bdrv_create(cco->filename, cco->opts, &local_err);

    ret = cco->drv->bdrv_co_create_opts(cco->filename, cco->opts, &local_err);

    error_propagate(&cco->err, local_err);

    cco->ret = ret;

}
@@ -437,7 +437,7 @@ int bdrv_create(BlockDriver *drv, const char* filename, 
        .err = NULL,

    };



    if (!drv->bdrv_create) {

    if (!drv->bdrv_co_create_opts) {

        error_setg(errp, "Driver '%s' does not support image creation", drv->format_name);

        ret = -ENOTSUP;

        goto out;
@@ -4711,7 +4711,12 @@ out: 


AioContext *bdrv_get_aio_context(BlockDriverState *bs)

{

    return bs->aio_context;

    return bs ? bs->aio_context : qemu_get_aio_context();

}



AioWait *bdrv_get_aio_wait(BlockDriverState *bs)

{

    return bs ? &bs->wait : NULL;

}



void bdrv_coroutine_enter(BlockDriverState *bs, Coroutine *co)

block/blkdebug.c

+11 −9
Original line number Diff line number Diff line
@@ -627,15 +627,17 @@ static int coroutine_fn blkdebug_co_pdiscard(BlockDriverState *bs, 
    return bdrv_co_pdiscard(bs->file->bs, offset, bytes);

}



static int64_t coroutine_fn blkdebug_co_get_block_status(

    BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum,

static int coroutine_fn blkdebug_co_block_status(BlockDriverState *bs,

                                                 bool want_zero,

                                                 int64_t offset,

                                                 int64_t bytes,

                                                 int64_t *pnum,

                                                 int64_t *map,

                                                 BlockDriverState **file)

{

    assert(QEMU_IS_ALIGNED(sector_num | nb_sectors,

                           DIV_ROUND_UP(bs->bl.request_alignment,

                                        BDRV_SECTOR_SIZE)));

    return bdrv_co_get_block_status_from_file(bs, sector_num, nb_sectors,

                                              pnum, file);

    assert(QEMU_IS_ALIGNED(offset | bytes, bs->bl.request_alignment));

    return bdrv_co_block_status_from_file(bs, want_zero, offset, bytes,

                                          pnum, map, file);

}



static void blkdebug_close(BlockDriverState *bs)
@@ -907,7 +909,7 @@ static BlockDriver bdrv_blkdebug = { 
    .bdrv_co_flush_to_disk  = blkdebug_co_flush,

    .bdrv_co_pwrite_zeroes  = blkdebug_co_pwrite_zeroes,

    .bdrv_co_pdiscard       = blkdebug_co_pdiscard,

    .bdrv_co_get_block_status = blkdebug_co_get_block_status,

    .bdrv_co_block_status   = blkdebug_co_block_status,



    .bdrv_debug_event           = blkdebug_debug_event,

    .bdrv_debug_breakpoint      = blkdebug_debug_breakpoint,

block/block-backend.c

+56 −9
Original line number Diff line number Diff line
@@ -73,6 +73,14 @@ struct BlockBackend { 
    int quiesce_counter;

    VMChangeStateEntry *vmsh;

    bool force_allow_inactivate;



    /* Number of in-flight aio requests.  BlockDriverState also counts

     * in-flight requests but aio requests can exist even when blk->root is

     * NULL, so we cannot rely on its counter for that case.

     * Accessed with atomic ops.

     */

    unsigned int in_flight;

    AioWait wait;

};



typedef struct BlockBackendAIOCB {
@@ -1225,11 +1233,22 @@ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags) 
    return bdrv_make_zero(blk->root, flags);

}



static void blk_inc_in_flight(BlockBackend *blk)

{

    atomic_inc(&blk->in_flight);

}



static void blk_dec_in_flight(BlockBackend *blk)

{

    atomic_dec(&blk->in_flight);

    aio_wait_kick(&blk->wait);

}



static void error_callback_bh(void *opaque)

{

    struct BlockBackendAIOCB *acb = opaque;



    bdrv_dec_in_flight(acb->common.bs);

    blk_dec_in_flight(acb->blk);

    acb->common.cb(acb->common.opaque, acb->ret);

    qemu_aio_unref(acb);

}
@@ -1240,7 +1259,7 @@ BlockAIOCB *blk_abort_aio_request(BlockBackend *blk, 
{

    struct BlockBackendAIOCB *acb;



    bdrv_inc_in_flight(blk_bs(blk));

    blk_inc_in_flight(blk);

    acb = blk_aio_get(&block_backend_aiocb_info, blk, cb, opaque);

    acb->blk = blk;

    acb->ret = ret;
@@ -1263,7 +1282,7 @@ static const AIOCBInfo blk_aio_em_aiocb_info = { 
static void blk_aio_complete(BlkAioEmAIOCB *acb)

{

    if (acb->has_returned) {

        bdrv_dec_in_flight(acb->common.bs);

        blk_dec_in_flight(acb->rwco.blk);

        acb->common.cb(acb->common.opaque, acb->rwco.ret);

        qemu_aio_unref(acb);

    }
@@ -1284,7 +1303,7 @@ static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes, 
    BlkAioEmAIOCB *acb;

    Coroutine *co;



    bdrv_inc_in_flight(blk_bs(blk));

    blk_inc_in_flight(blk);

    acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);

    acb->rwco = (BlkRwCo) {

        .blk    = blk,
@@ -1521,14 +1540,41 @@ int blk_flush(BlockBackend *blk) 


void blk_drain(BlockBackend *blk)

{

    if (blk_bs(blk)) {

        bdrv_drain(blk_bs(blk));

    BlockDriverState *bs = blk_bs(blk);



    if (bs) {

        bdrv_drained_begin(bs);

    }



    /* We may have -ENOMEDIUM completions in flight */

    AIO_WAIT_WHILE(&blk->wait,

            blk_get_aio_context(blk),

            atomic_mb_read(&blk->in_flight) > 0);



    if (bs) {

        bdrv_drained_end(bs);

    }

}



void blk_drain_all(void)

{

    bdrv_drain_all();

    BlockBackend *blk = NULL;



    bdrv_drain_all_begin();



    while ((blk = blk_all_next(blk)) != NULL) {

        AioContext *ctx = blk_get_aio_context(blk);



        aio_context_acquire(ctx);



        /* We may have -ENOMEDIUM completions in flight */

        AIO_WAIT_WHILE(&blk->wait, ctx,

                atomic_mb_read(&blk->in_flight) > 0);



        aio_context_release(ctx);

    }



    bdrv_drain_all_end();

}



void blk_set_on_error(BlockBackend *blk, BlockdevOnError on_read_error,
@@ -1569,10 +1615,11 @@ static void send_qmp_error_event(BlockBackend *blk, 
                                 bool is_read, int error)

{

    IoOperationType optype;

    BlockDriverState *bs = blk_bs(blk);



    optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;

    qapi_event_send_block_io_error(blk_name(blk),

                                   bdrv_get_node_name(blk_bs(blk)), optype,

    qapi_event_send_block_io_error(blk_name(blk), !!bs,

                                   bs ? bdrv_get_node_name(bs) : NULL, optype,

                                   action, blk_iostatus_is_enabled(blk),

                                   error == ENOSPC, strerror(error),

                                   &error_abort);

block/commit.c

+1 −1
Original line number Diff line number Diff line
@@ -265,7 +265,7 @@ static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c, 
static BlockDriver bdrv_commit_top = {

    .format_name                = "commit_top",

    .bdrv_co_preadv             = bdrv_commit_top_preadv,

    .bdrv_co_get_block_status   = bdrv_co_get_block_status_from_backing,

    .bdrv_co_block_status       = bdrv_co_block_status_from_backing,

    .bdrv_refresh_filename      = bdrv_commit_top_refresh_filename,

    .bdrv_close                 = bdrv_commit_top_close,

    .bdrv_child_perm            = bdrv_commit_top_child_perm,

block/crypto.c

+4 −4
Original line number Diff line number Diff line
@@ -556,7 +556,7 @@ static int block_crypto_open_luks(BlockDriverState *bs, 
                                     bs, options, flags, errp);

}



static int block_crypto_create_luks(const char *filename,

static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,

                                                         QemuOpts *opts,

                                                         Error **errp)

{
@@ -617,7 +617,7 @@ BlockDriver bdrv_crypto_luks = { 
    .bdrv_open          = block_crypto_open_luks,

    .bdrv_close         = block_crypto_close,

    .bdrv_child_perm    = bdrv_format_default_perms,

    .bdrv_create        = block_crypto_create_luks,

    .bdrv_co_create_opts = block_crypto_co_create_opts_luks,

    .bdrv_truncate      = block_crypto_truncate,

    .create_opts        = &block_crypto_create_opts_luks,