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

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging 



Pull request

# gpg: Signature made Fri 05 Jun 2020 10:47:27 BST
# gpg:                using RSA key 8695A8BFD3F97CDAAC35775A9CA4ABB381AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>" [full]
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>" [full]
# Primary key fingerprint: 8695 A8BF D3F9 7CDA AC35  775A 9CA4 ABB3 81AB 73C8

* remotes/stefanha/tags/block-pull-request:
  block: Factor out bdrv_run_co()
  exec: Rename qemu_ram_writeback() as qemu_ram_msync()
  hw/block: Let the NVMe emulated device be target-agnostic
  memory: Extract memory_region_msync() from memory_region_writeback()
  memory: Rename memory_region_do_writeback -> memory_region_writeback
  fuzz: run the main-loop in fork-server process
  fuzz: add mangled object name to linker script
  fuzz: fix typo in i440fx-qtest-reboot arguments
  fuzz: add datadir for oss-fuzz compatability
  io_uring: use io_uring_cq_ready() to check for ready cqes
  io_uring: retry io_uring_submit() if it fails with errno=EINTR

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 66234fee 7d2410ce

block/io.c

+72 −121
Original line number Diff line number Diff line
@@ -35,8 +35,6 @@ 
#include "qemu/main-loop.h"

#include "sysemu/replay.h"



#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */



/* Maximum bounce buffer for copy-on-read and write zeroes, in bytes */

#define MAX_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)
@@ -891,29 +889,63 @@ static int bdrv_check_byte_request(BlockDriverState *bs, int64_t offset, 
    return 0;

}



typedef int coroutine_fn BdrvRequestEntry(void *opaque);

typedef struct BdrvRunCo {

    BdrvRequestEntry *entry;

    void *opaque;

    int ret;

    bool done;

    Coroutine *co; /* Coroutine, running bdrv_run_co_entry, for debugging */

} BdrvRunCo;



static void coroutine_fn bdrv_run_co_entry(void *opaque)

{

    BdrvRunCo *arg = opaque;



    arg->ret = arg->entry(arg->opaque);

    arg->done = true;

    aio_wait_kick();

}



static int bdrv_run_co(BlockDriverState *bs, BdrvRequestEntry *entry,

                       void *opaque)

{

    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

        return entry(opaque);

    } else {

        BdrvRunCo s = { .entry = entry, .opaque = opaque };



        s.co = qemu_coroutine_create(bdrv_run_co_entry, &s);

        bdrv_coroutine_enter(bs, s.co);



        BDRV_POLL_WHILE(bs, !s.done);



        return s.ret;

    }

}



typedef struct RwCo {

    BdrvChild *child;

    int64_t offset;

    QEMUIOVector *qiov;

    bool is_write;

    int ret;

    BdrvRequestFlags flags;

} RwCo;



static void coroutine_fn bdrv_rw_co_entry(void *opaque)

static int coroutine_fn bdrv_rw_co_entry(void *opaque)

{

    RwCo *rwco = opaque;



    if (!rwco->is_write) {

        rwco->ret = bdrv_co_preadv(rwco->child, rwco->offset,

        return bdrv_co_preadv(rwco->child, rwco->offset,

                              rwco->qiov->size, rwco->qiov,

                              rwco->flags);

    } else {

        rwco->ret = bdrv_co_pwritev(rwco->child, rwco->offset,

        return bdrv_co_pwritev(rwco->child, rwco->offset,

                               rwco->qiov->size, rwco->qiov,

                               rwco->flags);

    }

    aio_wait_kick();

}



/*
@@ -923,25 +955,15 @@ static int bdrv_prwv_co(BdrvChild *child, int64_t offset, 
                        QEMUIOVector *qiov, bool is_write,

                        BdrvRequestFlags flags)

{

    Coroutine *co;

    RwCo rwco = {

        .child = child,

        .offset = offset,

        .qiov = qiov,

        .is_write = is_write,

        .ret = NOT_DONE,

        .flags = flags,

    };



    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

        bdrv_rw_co_entry(&rwco);

    } else {

        co = qemu_coroutine_create(bdrv_rw_co_entry, &rwco);

        bdrv_coroutine_enter(child->bs, co);

        BDRV_POLL_WHILE(child->bs, rwco.ret == NOT_DONE);

    }

    return rwco.ret;

    return bdrv_run_co(child->bs, bdrv_rw_co_entry, &rwco);

}



int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
@@ -2229,8 +2251,6 @@ typedef struct BdrvCoBlockStatusData { 
    int64_t *pnum;

    int64_t *map;

    BlockDriverState **file;

    int ret;

    bool done;

} BdrvCoBlockStatusData;



int coroutine_fn bdrv_co_block_status_from_file(BlockDriverState *bs,
@@ -2484,16 +2504,14 @@ static int coroutine_fn bdrv_co_block_status_above(BlockDriverState *bs, 
}



/* Coroutine wrapper for bdrv_block_status_above() */

static void coroutine_fn bdrv_block_status_above_co_entry(void *opaque)

static int coroutine_fn bdrv_block_status_above_co_entry(void *opaque)

{

    BdrvCoBlockStatusData *data = opaque;



    data->ret = bdrv_co_block_status_above(data->bs, data->base,

    return bdrv_co_block_status_above(data->bs, data->base,

                                      data->want_zero,

                                      data->offset, data->bytes,

                                      data->pnum, data->map, data->file);

    data->done = true;

    aio_wait_kick();

}



/*
@@ -2508,7 +2526,6 @@ static int bdrv_common_block_status_above(BlockDriverState *bs, 
                                          int64_t *map,

                                          BlockDriverState **file)

{

    Coroutine *co;

    BdrvCoBlockStatusData data = {

        .bs = bs,

        .base = base,
@@ -2518,18 +2535,9 @@ static int bdrv_common_block_status_above(BlockDriverState *bs, 
        .pnum = pnum,

        .map = map,

        .file = file,

        .done = false,

    };



    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

        bdrv_block_status_above_co_entry(&data);

    } else {

        co = qemu_coroutine_create(bdrv_block_status_above_co_entry, &data);

        bdrv_coroutine_enter(bs, co);

        BDRV_POLL_WHILE(bs, !data.done);

    }

    return data.ret;

    return bdrv_run_co(bs, bdrv_block_status_above_co_entry, &data);

}



int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
@@ -2630,7 +2638,6 @@ typedef struct BdrvVmstateCo { 
    QEMUIOVector        *qiov;

    int64_t             pos;

    bool                is_read;

    int                 ret;

} BdrvVmstateCo;



static int coroutine_fn
@@ -2658,33 +2665,25 @@ bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos, 
    return ret;

}



static void coroutine_fn bdrv_co_rw_vmstate_entry(void *opaque)

static int coroutine_fn bdrv_co_rw_vmstate_entry(void *opaque)

{

    BdrvVmstateCo *co = opaque;

    co->ret = bdrv_co_rw_vmstate(co->bs, co->qiov, co->pos, co->is_read);

    aio_wait_kick();



    return bdrv_co_rw_vmstate(co->bs, co->qiov, co->pos, co->is_read);

}



static inline int

bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,

                bool is_read)

{

    if (qemu_in_coroutine()) {

        return bdrv_co_rw_vmstate(bs, qiov, pos, is_read);

    } else {

    BdrvVmstateCo data = {

        .bs         = bs,

        .qiov       = qiov,

        .pos        = pos,

        .is_read    = is_read,

            .ret        = -EINPROGRESS,

    };

        Coroutine *co = qemu_coroutine_create(bdrv_co_rw_vmstate_entry, &data);



        bdrv_coroutine_enter(bs, co);

        BDRV_POLL_WHILE(bs, data.ret == -EINPROGRESS);

        return data.ret;

    }

    return bdrv_run_co(bs, bdrv_co_rw_vmstate_entry, &data);

}



int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
@@ -2762,18 +2761,9 @@ void bdrv_aio_cancel_async(BlockAIOCB *acb) 
/**************************************************************/

/* Coroutine block device emulation */



typedef struct FlushCo {

    BlockDriverState *bs;

    int ret;

} FlushCo;





static void coroutine_fn bdrv_flush_co_entry(void *opaque)

static int coroutine_fn bdrv_flush_co_entry(void *opaque)

{

    FlushCo *rwco = opaque;



    rwco->ret = bdrv_co_flush(rwco->bs);

    aio_wait_kick();

    return bdrv_co_flush(opaque);

}



int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
@@ -2890,36 +2880,20 @@ early_exit: 


int bdrv_flush(BlockDriverState *bs)

{

    Coroutine *co;

    FlushCo flush_co = {

        .bs = bs,

        .ret = NOT_DONE,

    };



    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

        bdrv_flush_co_entry(&flush_co);

    } else {

        co = qemu_coroutine_create(bdrv_flush_co_entry, &flush_co);

        bdrv_coroutine_enter(bs, co);

        BDRV_POLL_WHILE(bs, flush_co.ret == NOT_DONE);

    }



    return flush_co.ret;

    return bdrv_run_co(bs, bdrv_flush_co_entry, bs);

}



typedef struct DiscardCo {

    BdrvChild *child;

    int64_t offset;

    int64_t bytes;

    int ret;

} DiscardCo;

static void coroutine_fn bdrv_pdiscard_co_entry(void *opaque)



static int coroutine_fn bdrv_pdiscard_co_entry(void *opaque)

{

    DiscardCo *rwco = opaque;



    rwco->ret = bdrv_co_pdiscard(rwco->child, rwco->offset, rwco->bytes);

    aio_wait_kick();

    return bdrv_co_pdiscard(rwco->child, rwco->offset, rwco->bytes);

}



int coroutine_fn bdrv_co_pdiscard(BdrvChild *child, int64_t offset,
@@ -3038,24 +3012,13 @@ out: 


int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes)

{

    Coroutine *co;

    DiscardCo rwco = {

        .child = child,

        .offset = offset,

        .bytes = bytes,

        .ret = NOT_DONE,

    };



    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

        bdrv_pdiscard_co_entry(&rwco);

    } else {

        co = qemu_coroutine_create(bdrv_pdiscard_co_entry, &rwco);

        bdrv_coroutine_enter(child->bs, co);

        BDRV_POLL_WHILE(child->bs, rwco.ret == NOT_DONE);

    }



    return rwco.ret;

    return bdrv_run_co(child->bs, bdrv_pdiscard_co_entry, &rwco);

}



int bdrv_co_ioctl(BlockDriverState *bs, int req, void *buf)
@@ -3463,21 +3426,19 @@ typedef struct TruncateCo { 
    PreallocMode prealloc;

    BdrvRequestFlags flags;

    Error **errp;

    int ret;

} TruncateCo;



static void coroutine_fn bdrv_truncate_co_entry(void *opaque)

static int coroutine_fn bdrv_truncate_co_entry(void *opaque)

{

    TruncateCo *tco = opaque;

    tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact,



    return bdrv_co_truncate(tco->child, tco->offset, tco->exact,

                            tco->prealloc, tco->flags, tco->errp);

    aio_wait_kick();

}



int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,

                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)

{

    Coroutine *co;

    TruncateCo tco = {

        .child      = child,

        .offset     = offset,
@@ -3485,17 +3446,7 @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact, 
        .prealloc   = prealloc,

        .flags      = flags,

        .errp       = errp,

        .ret        = NOT_DONE,

    };



    if (qemu_in_coroutine()) {

        /* Fast-path if already in coroutine context */

        bdrv_truncate_co_entry(&tco);

    } else {

        co = qemu_coroutine_create(bdrv_truncate_co_entry, &tco);

        bdrv_coroutine_enter(child->bs, co);

        BDRV_POLL_WHILE(child->bs, tco.ret == NOT_DONE);

    }



    return tco.ret;

    return bdrv_run_co(child->bs, bdrv_truncate_co_entry, &tco);

}

block/io_uring.c

+4 −7
Original line number Diff line number Diff line
@@ -231,7 +231,7 @@ static int ioq_submit(LuringState *s) 
        trace_luring_io_uring_submit(s, ret);

        /* Prevent infinite loop if submission is refused */

        if (ret <= 0) {

            if (ret == -EAGAIN) {

            if (ret == -EAGAIN || ret == -EINTR) {

                continue;

            }

            break;
@@ -277,14 +277,11 @@ static void qemu_luring_completion_cb(void *opaque) 
static bool qemu_luring_poll_cb(void *opaque)

{

    LuringState *s = opaque;

    struct io_uring_cqe *cqes;



    if (io_uring_peek_cqe(&s->ring, &cqes) == 0) {

        if (cqes) {

    if (io_uring_cq_ready(&s->ring)) {

        luring_process_completions_and_submit(s);

        return true;

    }

    }



    return false;

}

exec.c

+1 −1
Original line number Diff line number Diff line
@@ -2127,7 +2127,7 @@ int qemu_ram_resize(RAMBlock *block, ram_addr_t newsize, Error **errp) 
 * Otherwise no-op.

 * @Note: this is supposed to be a synchronous op.

 */

void qemu_ram_writeback(RAMBlock *block, ram_addr_t start, ram_addr_t length)

void qemu_ram_msync(RAMBlock *block, ram_addr_t start, ram_addr_t length)

{

    /* The requested range should fit in within the block range */

    g_assert((start + length) <= block->used_length);

hw/block/Makefile.objs

+1 −1
Original line number Diff line number Diff line
@@ -13,6 +13,6 @@ common-obj-$(CONFIG_SH4) += tc58128.o 


obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o

obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o

obj-$(CONFIG_NVME_PCI) += nvme.o

common-obj-$(CONFIG_NVME_PCI) += nvme.o



obj-y += dataplane/

hw/block/nvme.c

+2 −4
Original line number Diff line number Diff line
@@ -46,8 +46,7 @@ 
#include "qapi/visitor.h"

#include "sysemu/hostmem.h"

#include "sysemu/block-backend.h"

#include "exec/ram_addr.h"



#include "exec/memory.h"

#include "qemu/log.h"

#include "qemu/module.h"

#include "qemu/cutils.h"
@@ -1207,8 +1206,7 @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size) 
         */

        if (addr == 0xE08 &&

            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {

            qemu_ram_writeback(n->pmrdev->mr.ram_block,

                               0, n->pmrdev->size);

            memory_region_msync(&n->pmrdev->mr, 0, n->pmrdev->size);

        }

        memcpy(&val, ptr + addr, size);

    } else {