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)

https://gitlab.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 32a3fd65e7e3551337fd26bfc0e2f899d70c028c:

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

Pull request

v2:

* 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

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

bdrv_is_allocated_above wrongly handles short backing files: it reports

after-EOF space as UNALLOCATED which is wrong, as on read the data is

generated on the level of short backing file (if all overlays have

unallocated areas at that place).

Reusing bdrv_common_block_status_above fixes the issue and unifies code

path.

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

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

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

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

[Fix s/has/have/ as suggested by Eric Blake. Fix s/area/areas/.

--Stefan]

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

---

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

1 file changed, 5 insertions(+), 38 deletions(-)

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

In order to reuse bdrv_common_block_status_above in

bdrv_is_allocated_above, let's support include_base parameter.

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-3-vsementsov@virtuozzo.com

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

block/coroutines.h | 2 ++

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

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

diff --git a/block/coroutines.h b/block/coroutines.h

--- a/block/coroutines.h

+++ b/block/coroutines.h

@@ -XXX,XX +XXX,XX @@ bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,

int coroutine_fn

bdrv_co_common_block_status_above(BlockDriverState *bs,

BlockDriverState *base,

+ bool include_base,

bool want_zero,

int64_t offset,

int64_t bytes,

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

int generated_co_wrapper

bdrv_common_block_status_above(BlockDriverState *bs,

BlockDriverState *base,

+ bool include_base,

bool want_zero,

int64_t offset,

int64_t bytes,

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

index XXXXXXX..XXXXXXX 100644

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ early_out:

int coroutine_fn

bdrv_co_common_block_status_above(BlockDriverState *bs,

BlockDriverState *base,

+ bool include_base,

bool want_zero,

int64_t offset,

int64_t bytes,

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

BlockDriverState *p;

int64_t eof = 0;

- assert(bs != base);

+ assert(include_base || bs != base);

+ assert(!include_base || base); /* Can't include NULL base */

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

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

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

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

assert(*pnum <= bytes);

bytes = *pnum;

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

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

p = bdrv_filter_or_cow_bs(p))

{

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

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

break;

}

+ if (p == base) {

+ assert(include_base);

+ break;

+ }

+

/*

* OK, [offset, offset + *pnum) region is unallocated on this layer,

* let's continue the diving.

@@ -XXX,XX +XXX,XX @@ int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,

int64_t offset, int64_t bytes, int64_t *pnum,

int64_t *map, BlockDriverState **file)

{

- return bdrv_common_block_status_above(bs, base, true, offset, bytes,

+ return bdrv_common_block_status_above(bs, base, false, true, offset, bytes,

pnum, map, file);

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,

int ret;

int64_t dummy;

- ret = bdrv_common_block_status_above(bs, bdrv_filter_or_cow_bs(bs), false,

- offset, bytes, pnum ? pnum : &dummy,

- NULL, NULL);

+ ret = bdrv_common_block_status_above(bs, bs, true, false, offset,

+ bytes, pnum ? pnum : &dummy, NULL,

+ NULL);

if (ret < 0) {

return ret;

}

2.26.2

Use the new QAPI block exports API instead of defining our own QOM

objects.

This is a large change because the lifecycle of VuBlockDev needs to

follow BlockExportDriver. QOM properties are replaced by QAPI options

objects.

VuBlockDev is renamed VuBlkExport and contains a BlockExport field.

Several fields can be dropped since BlockExport already has equivalents.

The file names and meson build integration will be adjusted in a future

patch. libvhost-user should probably be built as a static library that

is linked into QEMU instead of as a .c file that results in duplicate

compilation.

The new command-line syntax is:

$ qemu-storage-daemon \

--blockdev file,node-name=drive0,filename=test.img \

--export vhost-user-blk,node-name=drive0,id=export0,unix-socket=/tmp/vhost-user-blk.sock

Note that unix-socket is optional because we may wish to accept chardevs

too in the future.

Markus noted that supported address families are not explicit in the

QAPI schema. It is unlikely that support for more address families will

be added since file descriptor passing is required and few address

families support it. If a new address family needs to be added, then the

QAPI 'features' syntax can be used to advertize them.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

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

Message-id: 20200924151549.913737-12-stefanha@redhat.com

[Skip test on big-endian host architectures because this device doesn't

support them yet (as already mentioned in a code comment).

--Stefan]

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

---

qapi/block-export.json | 21 +-

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

block/export/export.c | 6 +

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

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

block/export/meson.build | 1 +

block/meson.build | 1 -

7 files changed, 156 insertions(+), 358 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 @@

'data': { '*name': 'str', '*description': 'str',

'*bitmap': 'str' } }

+##

+# @BlockExportOptionsVhostUserBlk:

+#

+# A vhost-user-blk block export.

+#

+# @addr: The vhost-user socket on which to listen. Both 'unix' and 'fd'

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

+# sockets.

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

+#

+# Since: 5.2

+##

+{ 'struct': 'BlockExportOptionsVhostUserBlk',

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

+

##

# @NbdServerAddOptions:

#

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

# An enumeration of block export types

#

# @nbd: NBD export

+# @vhost-user-blk: vhost-user-blk export (since 5.2)

#

# Since: 4.2

##

{ 'enum': 'BlockExportType',

- 'data': [ 'nbd' ] }

+ 'data': [ 'nbd', 'vhost-user-blk' ] }

##

# @BlockExportOptions:

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

'*writethrough': 'bool' },

'discriminator': 'type',

'data': {

- 'nbd': 'BlockExportOptionsNbd'

+ 'nbd': 'BlockExportOptionsNbd',

+ 'vhost-user-blk': 'BlockExportOptionsVhostUserBlk'

} }

##

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

index XXXXXXX..XXXXXXX 100644

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

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

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

#ifndef VHOST_USER_BLK_SERVER_H

#define VHOST_USER_BLK_SERVER_H

-#include "util/vhost-user-server.h"

-typedef struct VuBlockDev VuBlockDev;

-#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"

-#define VHOST_USER_BLK_SERVER(obj) \

- OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)

+#include "block/export.h"

-/* vhost user block device */

-struct VuBlockDev {

- Object parent_obj;

- char *node_name;

- SocketAddress *addr;

- AioContext *ctx;

- VuServer vu_server;

- bool running;

- uint32_t blk_size;

- BlockBackend *backend;

- QIOChannelSocket *sioc;

- QTAILQ_ENTRY(VuBlockDev) next;

- struct virtio_blk_config blkcfg;

- bool writable;

-};

+/* For block/export/export.c */

+extern const BlockExportDriver blk_exp_vhost_user_blk;

#endif /* VHOST_USER_BLK_SERVER_H */

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

index XXXXXXX..XXXXXXX 100644

--- a/block/export/export.c

+++ b/block/export/export.c

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

#include "sysemu/block-backend.h"

#include "block/export.h"

#include "block/nbd.h"

+#if CONFIG_LINUX

+#include "block/export/vhost-user-blk-server.h"

+#endif

#include "qapi/error.h"

#include "qapi/qapi-commands-block-export.h"

#include "qapi/qapi-events-block-export.h"

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

static const BlockExportDriver *blk_exp_drivers[] = {

&blk_exp_nbd,

+#if CONFIG_LINUX

+ &blk_exp_vhost_user_blk,

+#endif

};

/* Only accessed from the main thread */

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 "qemu/osdep.h"

#include "block/block.h"

+#include "contrib/libvhost-user/libvhost-user.h"

+#include "standard-headers/linux/virtio_blk.h"

+#include "util/vhost-user-server.h"

#include "vhost-user-blk-server.h"

#include "qapi/error.h"

#include "qom/object_interfaces.h"

@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {

unsigned char status;

};

-typedef struct VuBlockReq {

+typedef struct VuBlkReq {

VuVirtqElement elem;

int64_t sector_num;

size_t size;

@@ -XXX,XX +XXX,XX @@ typedef struct VuBlockReq {

struct virtio_blk_outhdr out;

VuServer *server;

struct VuVirtq *vq;

-} VuBlockReq;

+} VuBlkReq;

-static void vu_block_req_complete(VuBlockReq *req)

+/* vhost user block device */

+typedef struct {

+ BlockExport export;

+ VuServer vu_server;

+ uint32_t blk_size;

+ QIOChannelSocket *sioc;

+ struct virtio_blk_config blkcfg;

+ bool writable;

+} VuBlkExport;

+

+static void vu_blk_req_complete(VuBlkReq *req)

{

VuDev *vu_dev = &req->server->vu_dev;

@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)

free(req);

-static VuBlockDev *get_vu_block_device_by_server(VuServer *server)

- return container_of(server, VuBlockDev, vu_server);

static int coroutine_fn

-vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,

- uint32_t iovcnt, uint32_t type)

+vu_blk_discard_write_zeroes(BlockBackend *blk, struct iovec *iov,

+ uint32_t iovcnt, uint32_t type)

struct virtio_blk_discard_write_zeroes desc;

ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));

@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,

return -EINVAL;

- VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);

uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,

le32_to_cpu(desc.num_sectors) << 9 };

if (type == VIRTIO_BLK_T_DISCARD) {

- if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {

+ if (blk_co_pdiscard(blk, range[0], range[1]) == 0) {

return 0;

}

} else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {

- if (blk_co_pwrite_zeroes(vdev_blk->backend,

- range[0], range[1], 0) == 0) {

+ if (blk_co_pwrite_zeroes(blk, range[0], range[1], 0) == 0) {

return 0;

@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,

return -EINVAL;

}

-static int coroutine_fn vu_block_flush(VuBlockReq *req)

+static void coroutine_fn vu_blk_virtio_process_req(void *opaque)

{

- VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);

- BlockBackend *backend = vdev_blk->backend;

- return blk_co_flush(backend);

-}

-

-static void coroutine_fn vu_block_virtio_process_req(void *opaque)

-{

- VuBlockReq *req = opaque;

+ VuBlkReq *req = opaque;

VuServer *server = req->server;

VuVirtqElement *elem = &req->elem;

uint32_t type;

- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);

- BlockBackend *backend = vdev_blk->backend;

+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);

+ BlockBackend *blk = vexp->export.blk;

struct iovec *in_iov = elem->in_sg;

struct iovec *out_iov = elem->out_sg;

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

bool is_write = type & VIRTIO_BLK_T_OUT;

req->sector_num = le64_to_cpu(req->out.sector);

- int64_t offset = req->sector_num * vdev_blk->blk_size;

+ if (is_write && !vexp->writable) {

+ req->in->status = VIRTIO_BLK_S_IOERR;

+ break;

+ }

+

+ int64_t offset = req->sector_num * vexp->blk_size;

QEMUIOVector qiov;

if (is_write) {

qemu_iovec_init_external(&qiov, out_iov, out_num);

- ret = blk_co_pwritev(backend, offset, qiov.size,

- &qiov, 0);

+ ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0);

} else {

qemu_iovec_init_external(&qiov, in_iov, in_num);

- ret = blk_co_preadv(backend, offset, qiov.size,

- &qiov, 0);

+ ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0);

}

if (ret >= 0) {

req->in->status = VIRTIO_BLK_S_OK;

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

break;

}

case VIRTIO_BLK_T_FLUSH:

- if (vu_block_flush(req) == 0) {

+ if (blk_co_flush(blk) == 0) {

req->in->status = VIRTIO_BLK_S_OK;

} else {

req->in->status = VIRTIO_BLK_S_IOERR;

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

case VIRTIO_BLK_T_DISCARD:

case VIRTIO_BLK_T_WRITE_ZEROES: {

int rc;

- rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],

- out_num, type);

+

+ if (!vexp->writable) {

+ req->in->status = VIRTIO_BLK_S_IOERR;

+ break;

+ }

+

+ rc = vu_blk_discard_write_zeroes(blk, &elem->out_sg[1], out_num, type);

if (rc == 0) {

req->in->status = VIRTIO_BLK_S_OK;

} else {

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

break;

}

- vu_block_req_complete(req);

+ vu_blk_req_complete(req);

return;

err:

- free(elem);

+ free(req);

}

-static void vu_block_process_vq(VuDev *vu_dev, int idx)

+static void vu_blk_process_vq(VuDev *vu_dev, int idx)

{

VuServer *server = container_of(vu_dev, VuServer, vu_dev);

VuVirtq *vq = vu_get_queue(vu_dev, idx);

while (1) {

- VuBlockReq *req;

+ VuBlkReq *req;

- req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));

+ req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq));

if (!req) {

break;

}

@@ -XXX,XX +XXX,XX @@ static void vu_block_process_vq(VuDev *vu_dev, int idx)

req->vq = vq;

Coroutine *co =

- qemu_coroutine_create(vu_block_virtio_process_req, req);

+ qemu_coroutine_create(vu_blk_virtio_process_req, req);

qemu_coroutine_enter(co);

}

}

-static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)

+static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started)

{

VuVirtq *vq;

assert(vu_dev);

vq = vu_get_queue(vu_dev, idx);

- vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);

+ vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL);

}

-static uint64_t vu_block_get_features(VuDev *dev)

+static uint64_t vu_blk_get_features(VuDev *dev)

{

uint64_t features;

VuServer *server = container_of(dev, VuServer, vu_dev);

- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);

+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);

features = 1ull << VIRTIO_BLK_F_SIZE_MAX |

1ull << VIRTIO_BLK_F_SEG_MAX |

1ull << VIRTIO_BLK_F_TOPOLOGY |

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

1ull << VIRTIO_RING_F_EVENT_IDX |

1ull << VHOST_USER_F_PROTOCOL_FEATURES;

- if (!vdev_blk->writable) {

+ if (!vexp->writable) {

features |= 1ull << VIRTIO_BLK_F_RO;

}

return features;

}

-static uint64_t vu_block_get_protocol_features(VuDev *dev)

+static uint64_t vu_blk_get_protocol_features(VuDev *dev)

{

return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |

1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;

}

static int

-vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)

+vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)

{

+ /* TODO blkcfg must be little-endian for VIRTIO 1.0 */

VuServer *server = container_of(vu_dev, VuServer, vu_dev);

- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);

- memcpy(config, &vdev_blk->blkcfg, len);

-

+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);

+ memcpy(config, &vexp->blkcfg, len);

return 0;

}

static int

-vu_block_set_config(VuDev *vu_dev, const uint8_t *data,

+vu_blk_set_config(VuDev *vu_dev, const uint8_t *data,

uint32_t offset, uint32_t size, uint32_t flags)

{

VuServer *server = container_of(vu_dev, VuServer, vu_dev);

- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);

+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);

uint8_t wce;

/* don't support live migration */

@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,

}

wce = *data;

- vdev_blk->blkcfg.wce = wce;

- blk_set_enable_write_cache(vdev_blk->backend, wce);

+ vexp->blkcfg.wce = wce;

+ blk_set_enable_write_cache(vexp->export.blk, wce);

return 0;

}

@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,

* of vu_process_message.

*

*/

-static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)

+static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)

{

if (vmsg->request == VHOST_USER_NONE) {

dev->panic(dev, "disconnect");

@@ -XXX,XX +XXX,XX @@ static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)

return false;

}

-static const VuDevIface vu_block_iface = {

- .get_features = vu_block_get_features,

- .queue_set_started = vu_block_queue_set_started,

- .get_protocol_features = vu_block_get_protocol_features,

- .get_config = vu_block_get_config,

- .set_config = vu_block_set_config,

- .process_msg = vu_block_process_msg,

+static const VuDevIface vu_blk_iface = {

+ .get_features = vu_blk_get_features,

+ .queue_set_started = vu_blk_queue_set_started,

+ .get_protocol_features = vu_blk_get_protocol_features,

+ .get_config = vu_blk_get_config,

+ .set_config = vu_blk_set_config,

+ .process_msg = vu_blk_process_msg,

};

static void blk_aio_attached(AioContext *ctx, void *opaque)

{

- VuBlockDev *vub_dev = opaque;

- vhost_user_server_attach_aio_context(&vub_dev->vu_server, ctx);

+ VuBlkExport *vexp = opaque;

+ vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);

}

static void blk_aio_detach(void *opaque)

{

- VuBlockDev *vub_dev = opaque;

- vhost_user_server_detach_aio_context(&vub_dev->vu_server);

+ VuBlkExport *vexp = opaque;

+ vhost_user_server_detach_aio_context(&vexp->vu_server);

}

static void

-vu_block_initialize_config(BlockDriverState *bs,

+vu_blk_initialize_config(BlockDriverState *bs,

struct virtio_blk_config *config, uint32_t blk_size)

{

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

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

config->max_write_zeroes_seg = 1;

}

-static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)

+static void vu_blk_exp_request_shutdown(BlockExport *exp)

{

+ VuBlkExport *vexp = container_of(exp, VuBlkExport, export);

- BlockBackend *blk;

- Error *local_error = NULL;

- const char *node_name = vu_block_device->node_name;

- bool writable = vu_block_device->writable;

- uint64_t perm = BLK_PERM_CONSISTENT_READ;

- int ret;

-

- AioContext *ctx;

-

- BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);

-

- if (!bs) {

- error_propagate(errp, local_error);

- return NULL;

- }

-

- if (bdrv_is_read_only(bs)) {

- writable = false;

- }

-

- if (writable) {

- perm |= BLK_PERM_WRITE;

- }

-

- ctx = bdrv_get_aio_context(bs);

- aio_context_acquire(ctx);

- bdrv_invalidate_cache(bs, NULL);

- aio_context_release(ctx);

-

- /*

- * Don't allow resize while the vhost user server is running,

- * otherwise we don't care what happens with the node.

- */

- blk = blk_new(bdrv_get_aio_context(bs), perm,

- BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |

- BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);

- ret = blk_insert_bs(blk, bs, errp);

-

- if (ret < 0) {

- goto fail;

- }

-

- blk_set_enable_write_cache(blk, false);

-

- blk_set_allow_aio_context_change(blk, true);

-

- vu_block_device->blkcfg.wce = 0;

- vu_block_device->backend = blk;

- if (!vu_block_device->blk_size) {

- vu_block_device->blk_size = BDRV_SECTOR_SIZE;

- }

- vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;

- blk_set_guest_block_size(blk, vu_block_device->blk_size);

- vu_block_initialize_config(bs, &vu_block_device->blkcfg,

- vu_block_device->blk_size);

- return vu_block_device;

-

-fail:

- blk_unref(blk);

- return NULL;

-}

-

-static void vu_block_deinit(VuBlockDev *vu_block_device)

-{

- if (vu_block_device->backend) {

- blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,

- blk_aio_detach, vu_block_device);

- }

-

- blk_unref(vu_block_device->backend);

-}

-

-static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)

-{

- vhost_user_server_stop(&vu_block_device->vu_server);

- vu_block_deinit(vu_block_device);

-}

-

-static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,

- Error **errp)

-{

- AioContext *ctx;

- SocketAddress *addr = vu_block_device->addr;

-

- if (!vu_block_init(vu_block_device, errp)) {

- return;

- }

-

- ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));

-

- if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,

- VHOST_USER_BLK_MAX_QUEUES, &vu_block_iface,

- errp)) {

- goto error;

- }

-

- blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,

- blk_aio_detach, vu_block_device);

- vu_block_device->running = true;

- return;

-

- error:

- vu_block_deinit(vu_block_device);

-}

-

-static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)

-{

- if (vus->running) {

- error_setg(errp, "The property can't be modified "

- "while the server is running");

- return false;

- }

- return true;

-}

-

-static void vu_set_node_name(Object *obj, const char *value, Error **errp)

-{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

-

- if (!vu_prop_modifiable(vus, errp)) {

- return;

- }

-

- if (vus->node_name) {

- g_free(vus->node_name);

- }

-

- vus->node_name = g_strdup(value);

-}

-

-static char *vu_get_node_name(Object *obj, Error **errp)

-{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

- return g_strdup(vus->node_name);

-}

-

-static void free_socket_addr(SocketAddress *addr)

-{

- g_free(addr->u.q_unix.path);

- g_free(addr);

-}

-

-static void vu_set_unix_socket(Object *obj, const char *value,

- Error **errp)

-{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

-

- if (!vu_prop_modifiable(vus, errp)) {

- return;

- }

-

- if (vus->addr) {

- free_socket_addr(vus->addr);

- }

-

- SocketAddress *addr = g_new0(SocketAddress, 1);

- addr->type = SOCKET_ADDRESS_TYPE_UNIX;

- addr->u.q_unix.path = g_strdup(value);

- vus->addr = addr;

+ vhost_user_server_stop(&vexp->vu_server);

}

-static char *vu_get_unix_socket(Object *obj, Error **errp)

+static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,

+ Error **errp)

{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

- return g_strdup(vus->addr->u.q_unix.path);

-}

-

-static bool vu_get_block_writable(Object *obj, Error **errp)

-{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

- return vus->writable;

-}

-

-static void vu_set_block_writable(Object *obj, bool value, Error **errp)

-{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

-

- if (!vu_prop_modifiable(vus, errp)) {

- return;

- }

-

- vus->writable = value;

-}

-

-static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,

- void *opaque, Error **errp)

-{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

- uint32_t value = vus->blk_size;

-

- visit_type_uint32(v, name, &value, errp);

-}

-

-static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,

- void *opaque, Error **errp)

-{

- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);

-

+ VuBlkExport *vexp = container_of(exp, VuBlkExport, export);

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

Error *local_err = NULL;

- uint32_t value;

+ uint64_t logical_block_size;

- if (!vu_prop_modifiable(vus, errp)) {

- return;

- }

+ vexp->writable = opts->writable;

+ vexp->blkcfg.wce = 0;

- visit_type_uint32(v, name, &value, &local_err);

- if (local_err) {

- goto out;

+ if (vu_opts->has_logical_block_size) {

+ logical_block_size = vu_opts->logical_block_size;

+ } else {

+ logical_block_size = BDRV_SECTOR_SIZE;

}

-

- check_block_size(object_get_typename(obj), name, value, &local_err);

+ check_block_size(exp->id, "logical-block-size", logical_block_size,

+ &local_err);

if (local_err) {

- goto out;

+ error_propagate(errp, local_err);

+ return -EINVAL;

+ }

+ vexp->blk_size = logical_block_size;

+ blk_set_guest_block_size(exp->blk, logical_block_size);

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

+ logical_block_size);

+

+ blk_set_allow_aio_context_change(exp->blk, true);

+ 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)) {

+ blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,

+ blk_aio_detach, vexp);

+ return -EADDRNOTAVAIL;

}

- vus->blk_size = value;

-

-out:

- error_propagate(errp, local_err);