The following changes since commit ac793156f650ae2d77834932d72224175ee69086:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20201020-1' into staging (2020-10-20 21:11:35 +0100)

for you to fetch changes up to 32a3fd65e7e3551337fd26bfc0e2f899d70c028c:

iotests: add commit top->base cases to 274 (2020-10-22 09:55:39 +0100)

* Fix format string issues on 32-bit hosts [Peter]

* Fix qemu-nbd.c CONFIG_POSIX ifdef issue [Eric]

* Fix missing eventfd.h header on macOS [Peter]

* Drop unreliable vhost-user-blk test (will send a new patch when ready) [Peter]

This pull request contains the vhost-user-blk server by Coiby Xu along with my

additions, block/nvme.c alignment and hardware error statistics by Philippe

Mathieu-Daudé, and bdrv_co_block_status_above() fixes by Vladimir

Sementsov-Ogievskiy.

Coiby Xu (6):

libvhost-user: Allow vu_message_read to be replaced

libvhost-user: remove watch for kick_fd when de-initialize vu-dev

util/vhost-user-server: generic vhost user server

block: move logical block size check function to a common utility

function

block/export: vhost-user block device backend server

MAINTAINERS: Add vhost-user block device backend server maintainer

Philippe Mathieu-Daudé (1):

block/nvme: Add driver statistics for access alignment and hw errors

Stefan Hajnoczi (16):

util/vhost-user-server: s/fileds/fields/ typo fix

util/vhost-user-server: drop unnecessary QOM cast

util/vhost-user-server: drop unnecessary watch deletion

block/export: consolidate request structs into VuBlockReq

util/vhost-user-server: drop unused DevicePanicNotifier

util/vhost-user-server: fix memory leak in vu_message_read()

util/vhost-user-server: check EOF when reading payload

util/vhost-user-server: rework vu_client_trip() coroutine lifecycle

block/export: report flush errors

block/export: convert vhost-user-blk server to block export API

util/vhost-user-server: move header to include/

util/vhost-user-server: use static library in meson.build

qemu-storage-daemon: avoid compiling blockdev_ss twice

block: move block exports to libblockdev

block/export: add iothread and fixed-iothread options

block/export: add vhost-user-blk multi-queue support

Vladimir Sementsov-Ogievskiy (5):

block/io: fix bdrv_co_block_status_above

block/io: bdrv_common_block_status_above: support include_base

block/io: bdrv_common_block_status_above: support bs == base

block/io: fix bdrv_is_allocated_above

iotests: add commit top->base cases to 274

MAINTAINERS | 9 +

qapi/block-core.json | 24 +-

qapi/block-export.json | 36 +-

block/coroutines.h | 2 +

block/export/vhost-user-blk-server.h | 19 +

contrib/libvhost-user/libvhost-user.h | 21 +

include/qemu/vhost-user-server.h | 65 +++

util/block-helpers.h | 19 +

block/export/export.c | 37 +-

block/export/vhost-user-blk-server.c | 431 ++++++++++++++++++++

block/io.c | 132 +++---

block/nvme.c | 27 ++

block/qcow2.c | 16 +-

contrib/libvhost-user/libvhost-user-glib.c | 2 +-

contrib/libvhost-user/libvhost-user.c | 15 +-

hw/core/qdev-properties-system.c | 31 +-

nbd/server.c | 2 -

qemu-nbd.c | 21 +-

softmmu/vl.c | 4 +

stubs/blk-exp-close-all.c | 7 +

tests/vhost-user-bridge.c | 2 +

tools/virtiofsd/fuse_virtio.c | 4 +-

util/block-helpers.c | 46 +++

util/vhost-user-server.c | 446 +++++++++++++++++++++

block/export/meson.build | 3 +-

contrib/libvhost-user/meson.build | 1 +

meson.build | 22 +-

nbd/meson.build | 2 +

storage-daemon/meson.build | 3 +-

stubs/meson.build | 1 +

tests/qemu-iotests/274 | 20 +

tests/qemu-iotests/274.out | 68 ++++

util/meson.build | 4 +

33 files changed, 1420 insertions(+), 122 deletions(-)

create mode 100644 block/export/vhost-user-blk-server.h

create mode 100644 include/qemu/vhost-user-server.h

create mode 100644 util/block-helpers.h

create mode 100644 block/export/vhost-user-blk-server.c

create mode 100644 stubs/blk-exp-close-all.c

create mode 100644 util/block-helpers.c

create mode 100644 util/vhost-user-server.c

2.26.2

Allow the number of queues to be configured using --export

vhost-user-blk,num-queues=N. This setting should match the QEMU --device

vhost-user-blk-pci,num-queues=N setting but QEMU vhost-user-blk.c lowers

its own value if the vhost-user-blk backend offers fewer queues than

QEMU.

The vhost-user-blk-server.c code is already capable of multi-queue. All

virtqueue processing runs in the same AioContext. No new locking is

needed.

Add the num-queues=N option and set the VIRTIO_BLK_F_MQ feature bit.

Note that the feature bit only announces the presence of the num_queues

configuration space field. It does not promise that there is more than 1

virtqueue, so we can set it unconditionally.

I tested multi-queue by running a random read fio test with numjobs=4 on

an -smp 4 guest. After the benchmark finished the guest /proc/interrupts

file showed activity on all 4 virtio-blk MSI-X. The /sys/block/vda/mq/

directory shows that Linux blk-mq has 4 queues configured.

An automated test is included in the next commit.

Acked-by: Markus Armbruster <armbru@redhat.com>

Message-id: 20201001144604.559733-2-stefanha@redhat.com

[Fixed accidental tab characters as suggested by Markus Armbruster

qapi/block-export.json | 10 +++++++---

block/export/vhost-user-blk-server.c | 24 ++++++++++++++++++------

2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/qapi/block-export.json b/qapi/block-export.json

--- a/qapi/block-export.json

+++ b/qapi/block-export.json

@@ -XXX,XX +XXX,XX @@

# SocketAddress types are supported. Passed fds must be UNIX domain

# sockets.

# @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.

+# @num-queues: Number of request virtqueues. Must be greater than 0. Defaults

+# to 1.

#

# Since: 5.2

##

{ 'struct': 'BlockExportOptionsVhostUserBlk',

- 'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }

+ 'data': { 'addr': 'SocketAddress',

+     '*logical-block-size': 'size',

+ '*num-queues': 'uint16'} }

##

# @NbdServerAddOptions:

@@ -XXX,XX +XXX,XX @@

{ 'union': 'BlockExportOptions',

'base': { 'type': 'BlockExportType',

'id': 'str',

-     '*fixed-iothread': 'bool',

-     '*iothread': 'str',

+ '*fixed-iothread': 'bool',

+ '*iothread': 'str',

'node-name': 'str',

'*writable': 'bool',

'*writethrough': 'bool' },

diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c

index XXXXXXX..XXXXXXX 100644

--- a/block/export/vhost-user-blk-server.c

+++ b/block/export/vhost-user-blk-server.c

@@ -XXX,XX +XXX,XX @@

#include "util/block-helpers.h"

enum {

- VHOST_USER_BLK_MAX_QUEUES = 1,

+ VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1,

};

struct virtio_blk_inhdr {

unsigned char status;

@@ -XXX,XX +XXX,XX @@ static uint64_t vu_blk_get_features(VuDev *dev)

1ull << VIRTIO_BLK_F_DISCARD |

1ull << VIRTIO_BLK_F_WRITE_ZEROES |

1ull << VIRTIO_BLK_F_CONFIG_WCE |

+ 1ull << VIRTIO_BLK_F_MQ |

1ull << VIRTIO_F_VERSION_1 |

1ull << VIRTIO_RING_F_INDIRECT_DESC |

1ull << VIRTIO_RING_F_EVENT_IDX |

@@ -XXX,XX +XXX,XX @@ static void blk_aio_detach(void *opaque)

static void

vu_blk_initialize_config(BlockDriverState *bs,

- struct virtio_blk_config *config, uint32_t blk_size)

+ struct virtio_blk_config *config,

+ uint32_t blk_size,

+ uint16_t num_queues)

{

config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;

config->blk_size = blk_size;

@@ -XXX,XX +XXX,XX @@ vu_blk_initialize_config(BlockDriverState *bs,

config->seg_max = 128 - 2;

config->min_io_size = 1;

config->opt_io_size = 1;

- config->num_queues = VHOST_USER_BLK_MAX_QUEUES;

+ config->num_queues = num_queues;

config->max_discard_sectors = 32768;

config->max_discard_seg = 1;

config->discard_sector_alignment = config->blk_size >> 9;

@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,

BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;

Error *local_err = NULL;

uint64_t logical_block_size;

+ uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT;

vexp->writable = opts->writable;

vexp->blkcfg.wce = 0;

@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,

}

vexp->blk_size = logical_block_size;

blk_set_guest_block_size(exp->blk, logical_block_size);

+ if (vu_opts->has_num_queues) {

+ num_queues = vu_opts->num_queues;

+ }

+ if (num_queues == 0) {

+ error_setg(errp, "num-queues must be greater than 0");

+ return -EINVAL;

+ }

vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,

- logical_block_size);

+ logical_block_size, num_queues);

blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,

vexp);

if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,

- VHOST_USER_BLK_MAX_QUEUES, &vu_blk_iface,

- errp)) {

+ num_queues, &vu_blk_iface, errp)) {

blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,

blk_aio_detach, vexp);

return -EADDRNOTAVAIL;

2.26.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

bdrv_co_block_status_above has several design problems with handling

short backing files:

1. With want_zeros=true, it may return ret with BDRV_BLOCK_ZERO but

without BDRV_BLOCK_ALLOCATED flag, when actually short backing file

which produces these after-EOF zeros is inside requested backing

sequence.

2. With want_zero=false, it may return pnum=0 prior to actual EOF,

because of EOF of short backing file.

Fix these things, making logic about short backing files clearer.

With fixed bdrv_block_status_above we also have to improve is_zero in

qcow2 code, otherwise iotest 154 will fail, because with this patch we

stop to merge zeros of different types (produced by fully unallocated

in the whole backing chain regions vs produced by short backing files).

Note also, that this patch leaves for another day the general problem

around block-status: misuse of BDRV_BLOCK_ALLOCATED as is-fs-allocated

vs go-to-backing.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Reviewed-by: Alberto Garcia <berto@igalia.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Message-id: 20200924194003.22080-2-vsementsov@virtuozzo.com

[Fix s/comes/come/ as suggested by Eric Blake

block/io.c | 68 ++++++++++++++++++++++++++++++++++++++++-----------

block/qcow2.c | 16 ++++++++++--

2 files changed, 68 insertions(+), 16 deletions(-)

diff --git a/block/io.c b/block/io.c

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,

int64_t *map,

BlockDriverState **file)

+ int ret;

BlockDriverState *p;

- int ret = 0;

- bool first = true;

+ int64_t eof = 0;

assert(bs != base);

- for (p = bs; p != base; p = bdrv_filter_or_cow_bs(p)) {

+

+ ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);

+ if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {

+ if (ret & BDRV_BLOCK_EOF) {

+ eof = offset + *pnum;

+ }

+

+ assert(*pnum <= bytes);

+ bytes = *pnum;

+

+ for (p = bdrv_filter_or_cow_bs(bs); p != base;

+ p = bdrv_filter_or_cow_bs(p))

+ {

ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,

file);

if (ret < 0) {

- break;

+ return ret;

- if (ret & BDRV_BLOCK_ZERO && ret & BDRV_BLOCK_EOF && !first) {

+ if (*pnum == 0) {

/*

- * Reading beyond the end of the file continues to read

- * zeroes, but we can only widen the result to the

- * unallocated length we learned from an earlier

- * iteration.

+ * The top layer deferred to this layer, and because this layer is

+ * short, any zeroes that we synthesize beyond EOF behave as if they

+ * were allocated at this layer.

+ *

+ * We don't include BDRV_BLOCK_EOF into ret, as upper layer may be

+ * larger. We'll add BDRV_BLOCK_EOF if needed at function end, see

+ * below.

*/

+ assert(ret & BDRV_BLOCK_EOF);

*pnum = bytes;

+ if (file) {

+ *file = p;

+ }

+ ret = BDRV_BLOCK_ZERO | BDRV_BLOCK_ALLOCATED;

+ break;

return ret;

diff --git a/block/qcow2.c b/block/qcow2.c

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@ static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)

if (!bytes) {

return true;

}

- res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);

- return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;

+

+ /*

+ * bdrv_block_status_above doesn't merge different types of zeros, for

+ * example, zeros which come from the region which is unallocated in

+ * the whole backing chain, and zeros which come because of a short

+ * backing file. So, we need a loop.

+ */

+ do {

+ res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);

+ offset += nr;

+ bytes -= nr;

+ } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);

+

+ return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;

}

static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,

2.26.2

Introduce libblkdev.fa to avoid recompiling blockdev_ss twice.

Suggested-by: Paolo Bonzini <pbonzini@redhat.com>

Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>

Message-id: 20200929125516.186715-3-stefanha@redhat.com

meson.build | 12 ++++++++++--

storage-daemon/meson.build | 3 +--

2 files changed, 11 insertions(+), 4 deletions(-)

@@ -XXX,XX +XXX,XX @@ blockdev_ss.add(files(

# os-win32.c does not

blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))

softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])

-softmmu_ss.add_all(blockdev_ss)

common_ss.add(files('cpus-common.c'))

@@ -XXX,XX +XXX,XX @@ block = declare_dependency(link_whole: [libblock],

link_args: '@block.syms',

dependencies: [crypto, io])

+blockdev_ss = blockdev_ss.apply(config_host, strict: false)

+libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,

+ dependencies: blockdev_ss.dependencies(),

+ name_suffix: 'fa',

+ build_by_default: false)

+

+blockdev = declare_dependency(link_whole: [libblockdev],

+ dependencies: [block])

+

qmp_ss = qmp_ss.apply(config_host, strict: false)

libqmp = static_library('qmp', qmp_ss.sources() + genh,

dependencies: qmp_ss.dependencies(),

@@ -XXX,XX +XXX,XX @@ foreach m : block_mods + softmmu_mods

install_dir: config_host['qemu_moddir'])

endforeach

-softmmu_ss.add(authz, block, chardev, crypto, io, qmp)

+softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)

common_ss.add(qom, qemuutil)

common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])

diff --git a/storage-daemon/meson.build b/storage-daemon/meson.build

--- a/storage-daemon/meson.build

+++ b/storage-daemon/meson.build

qsd_ss = ss.source_set()

qsd_ss.add(files('qemu-storage-daemon.c'))

-qsd_ss.add(block, chardev, qmp, qom, qemuutil)

-qsd_ss.add_all(blockdev_ss)

+qsd_ss.add(blockdev, chardev, qmp, qom, qemuutil)

subdir('qapi')