Skip to contentSkip to conversation

nbd: merge block/nbd.c and block/nbd-client.c

PATCH In review Vladimir Sementsov-Ogievskiy 3 participants 9 messages Jun 11, 2019 – Jun 13, 2019 Block layer

lore
Share & tools
lore
#0 lore raw

cover nbd: merge block/nbd.c and block/nbd-client.c

Hi all!

I need some fields of BDRVNBDState to be available in nbd-client.c code for my nbd-reconnect series. This leads to the following idea:
It seems that there is no actual benefits in splitting NBDClientSession out of BDRVNBDState and nbd-client.c out of nbd.c It only increases confusion around nbd client architecture, and make it different from other formats. So, I propose to merge them back.

The only thing I doubt in:
NBD client block driver is called "nbd", so, seems logical to keep BDRVNBDState structure name and block/nbd.c filename. But I can't rename all nbd_client_* handlers to nbd_*, as they start conflicting with definitions in include/block/nbd.h (nbd_init for example). So, for now I've kept old names, so, some handlers are nbd_* and some nbd_client_*, which is definitely inconsistent.. So, maybe they all should become block_nbd_ or bdrv_nbd_ or nbddrv_ or something like this to stress that it is BlockDriver implementation, not nbd/client.c code (separated from generic block layer). Or keep them as is, a bit inconsistent. What do you think?

Vladimir Sementsov-Ogievskiy (3):
block/nbd-client: drop stale logout
block/nbd: merge nbd-client.* to nbd.c
block/nbd: merge NBDClientSession struct back to BDRVNBDState

 block/nbd-client.h  |   72 ---
 block/nbd-client.c  | 1226 -----------------------------------------
 block/nbd.c         | 1282 +++++++++++++++++++++++++++++++++++++++++--
 block/Makefile.objs |    2 +-
 block/trace-events  |    4 +-
 5 files changed, 1251 insertions(+), 1335 deletions(-)
 delete mode 100644 block/nbd-client.h
 delete mode 100644 block/nbd-client.c
Signature · 1 line
2.18.0
#1 lore raw

PATCH 1/3 block/nbd-client: drop stale logout

Drop one on failure path (we have errp) and turn two others into trace points.

---
 block/nbd-client.h | 9 ---------
 block/nbd-client.c | 6 +++---
 block/trace-events | 2 ++
 3 files changed, 5 insertions(+), 12 deletions(-)
block/nbd-client.h +0 -9
index 09e03013d2..231dc13c48 100644
@@ -6,15 +6,6 @@
 #include "block/block_int.h"
 #include "io/channel-socket.h"
 
-/* #define DEBUG_NBD */
-
-#if defined(DEBUG_NBD)
-#define logout(fmt, ...) \
-    fprintf(stderr, "nbd\t%-24s" fmt, __func__, ##__VA_ARGS__)
-#else
-#define logout(fmt, ...) ((void)0)
-#endif
-
 #define MAX_NBD_REQUESTS    16
 
 typedef struct {
block/nbd-client.c +3 -3
index 790ecc1ee1..f89a67c23b 100644
@@ -1136,7 +1136,7 @@ static int nbd_client_connect(BlockDriverState *bs,
     }
 
     /* NBD handshake */
-    logout("session init %s\n", export);
+    trace_nbd_client_connect(export);
     qio_channel_set_blocking(QIO_CHANNEL(sioc), true, NULL);
 
     client->info.request_sizes = true;
@@ -1149,7 +1149,6 @@ static int nbd_client_connect(BlockDriverState *bs,
     g_free(client->info.x_dirty_bitmap);
     g_free(client->info.name);
     if (ret < 0) {
-        logout("Failed to negotiate with the NBD server\n");
         object_unref(OBJECT(sioc));
         return ret;
     }
@@ -1187,7 +1186,8 @@ static int nbd_client_connect(BlockDriverState *bs,
     bdrv_inc_in_flight(bs);
     nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
 
-    logout("Established connection with NBD server\n");
+    trace_nbd_client_connect_success(export);
+
     return 0;
 
  fail:
block/trace-events +2 -0
index eab51497fc..01fa5eb081 100644
@@ -165,6 +165,8 @@ nbd_parse_blockstatus_compliance(const char *err) "ignoring extra data from non-
 nbd_structured_read_compliance(const char *type) "server sent non-compliant unaligned read %s chunk"
 nbd_read_reply_entry_fail(int ret, const char *err) "ret = %d, err: %s"
 nbd_co_request_fail(uint64_t from, uint32_t len, uint64_t handle, uint16_t flags, uint16_t type, const char *name, int ret, const char *err) "Request failed { .from = %" PRIu64", .len = %" PRIu32 ", .handle = %" PRIu64 ", .flags = 0x%" PRIx16 ", .type = %" PRIu16 " (%s) } ret = %d, err: %s"
+nbd_client_connect(const char *export_name) "export '%s'"
+nbd_client_connect_success(const char *export_name) "export '%s'"
 
 # ssh.c
 ssh_restart_coroutine(void *co) "co=%p"
Signature · 1 line
2.18.0
Reviewed-by on v1 1/3
#2 lore raw

Re: [Qemu-devel] [PATCH 1/3] block/nbd-client: drop stale logout

Quoted 10 lines · Vladimir Sementsov-Ogievskiy

Drop one on failure path (we have errp) and turn two others into trace points.

---
 block/nbd-client.h | 9 ---------
 block/nbd-client.c | 6 +++---
 block/trace-events | 2 ++
 3 files changed, 5 insertions(+), 12 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org
#3 lore raw

PATCH 2/3 block/nbd: merge nbd-client.* to nbd.c

In reply to Vladimir Sementsov-Ogievskiy

No reason of keeping driver handlers realization in separate of driver structure. We can get rid of extra header file.

While being here, fix comments style, restore forgotten comments for NBD_FOREACH_REPLY_CHUNK and nbd_reply_chunk_iter_receive, remove extra includes.

---
 block/nbd-client.h  |   63 ---
 block/nbd-client.c  | 1226 -----------------------------------------
 block/nbd.c         | 1285 +++++++++++++++++++++++++++++++++++++++++--
 block/Makefile.objs |    2 +-
 block/trace-events  |    2 +-
 5 files changed, 1255 insertions(+), 1323 deletions(-)
 delete mode 100644 block/nbd-client.h
 delete mode 100644 block/nbd-client.c
block/nbd-client.h deleted +0 -63
deleted file mode 100644
index 231dc13c48..0000000000
@@ -1,63 +0,0 @@
-#ifndef NBD_CLIENT_H
-#define NBD_CLIENT_H
-
-#include "qemu-common.h"
-#include "block/nbd.h"
-#include "block/block_int.h"
-#include "io/channel-socket.h"
-
-#define MAX_NBD_REQUESTS    16
-
-typedef struct {
-    Coroutine *coroutine;
-    uint64_t offset;        /* original offset of the request */
-    bool receiving;         /* waiting for connection_co? */
-} NBDClientRequest;
-
-typedef struct NBDClientSession {
-    QIOChannelSocket *sioc; /* The master data channel */
-    QIOChannel *ioc; /* The current I/O channel which may differ (eg TLS) */
-    NBDExportInfo info;
-
-    CoMutex send_mutex;
-    CoQueue free_sema;
-    Coroutine *connection_co;
-    int in_flight;
-
-    NBDClientRequest requests[MAX_NBD_REQUESTS];
-    NBDReply reply;
-    BlockDriverState *bs;
-    bool quit;
-} NBDClientSession;
-
-NBDClientSession *nbd_get_client_session(BlockDriverState *bs);
-
-int nbd_client_init(BlockDriverState *bs,
-                    SocketAddress *saddr,
-                    const char *export_name,
-                    QCryptoTLSCreds *tlscreds,
-                    const char *hostname,
-                    const char *x_dirty_bitmap,
-                    Error **errp);
-void nbd_client_close(BlockDriverState *bs);
-
-int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes);
-int nbd_client_co_flush(BlockDriverState *bs);
-int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
-                          uint64_t bytes, QEMUIOVector *qiov, int flags);
-int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
-                                int bytes, BdrvRequestFlags flags);
-int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
-                         uint64_t bytes, QEMUIOVector *qiov, int flags);
-
-void nbd_client_detach_aio_context(BlockDriverState *bs);
-void nbd_client_attach_aio_context(BlockDriverState *bs,
-                                   AioContext *new_context);
-
-int coroutine_fn nbd_client_co_block_status(BlockDriverState *bs,
-                                            bool want_zero,
-                                            int64_t offset, int64_t bytes,
-                                            int64_t *pnum, int64_t *map,
-                                            BlockDriverState **file);
-
-#endif /* NBD_CLIENT_H */
block/nbd-client.c deleted +0 -1226

1,226 lines not on this page · raw message

block/nbd.c +1253 -32

1,339 lines not on this page · raw message

block/Makefile.objs +1 -1
index ae11605c9f..dbd1522722 100644
@@ -22,7 +22,7 @@ block-obj-y += null.o mirror.o commit.o io.o create.o
 block-obj-y += throttle-groups.o
 block-obj-$(CONFIG_LINUX) += nvme.o
 
-block-obj-y += nbd.o nbd-client.o
+block-obj-y += nbd.o
 block-obj-$(CONFIG_SHEEPDOG) += sheepdog.o
 block-obj-$(CONFIG_LIBISCSI) += iscsi.o
 block-obj-$(if $(CONFIG_LIBISCSI),y,n) += iscsi-opts.o
block/trace-events +1 -1
index 01fa5eb081..f6e43ee023 100644
@@ -160,7 +160,7 @@ nvme_cmd_map_qiov_iov(void *s, int i, void *page, int pages) "s %p iov[%d] %p pa
 # iscsi.c
 iscsi_xcopy(void *src_lun, uint64_t src_off, void *dst_lun, uint64_t dst_off, uint64_t bytes, int ret) "src_lun %p offset %"PRIu64" dst_lun %p offset %"PRIu64" bytes %"PRIu64" ret %d"
 
-# nbd-client.c
+# nbd.c
 nbd_parse_blockstatus_compliance(const char *err) "ignoring extra data from non-compliant server: %s"
 nbd_structured_read_compliance(const char *type) "server sent non-compliant unaligned read %s chunk"
 nbd_read_reply_entry_fail(int ret, const char *err) "ret = %d, err: %s"
Signature · 1 line
2.18.0
Reviewed-by on v1 2/3
#4 lore raw

Re: [Qemu-devel] [PATCH 2/3] block/nbd: merge nbd-client.* to nbd.c

Quoted 6 lines · Vladimir Sementsov-Ogievskiy

No reason of keeping driver handlers realization in separate of driver structure. We can get rid of extra header file.

While being here, fix comments style, restore forgotten comments for NBD_FOREACH_REPLY_CHUNK and nbd_reply_chunk_iter_receive, remove extra includes.

It's a little bit harder to review for accuracy when the patch does cleanups at the same time; but this shows that the patch is fairly simple to understand:

$ diff -u <(git log -p -1 | sed -n 's/^-//p') <(git log -p -1 | sed -n
's/^\+//p')

the most confusing parts were that HANDLE_TO_INDEX/INDEX_TO_HANDLE moved differently from nbd_get_client_session(), and nbd_client_{attach,detach}_aio_conext moved to a different relative position. Perhaps the patch could have been split to make the code motion even easier to follow, but it's not worth respinning now.

Quoted 11 lines
---
 block/nbd-client.h  |   63 ---
 block/nbd-client.c  | 1226 -----------------------------------------
 block/nbd.c         | 1285 +++++++++++++++++++++++++++++++++++++++++--
 block/Makefile.objs |    2 +-
 block/trace-events  |    2 +-
 5 files changed, 1255 insertions(+), 1323 deletions(-)
 delete mode 100644 block/nbd-client.h
 delete mode 100644 block/nbd-client.c

This will tend to cause merge conflicts to anything else touching either file, so I plan to send a pull request soon.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org
#5 lore raw

PATCH 3/3 block/nbd: merge NBDClientSession struct back to BDRVNBDState

In reply to Vladimir Sementsov-Ogievskiy

No reason to keep it separate, it differs from others block driver behavior and therefor confuses. Instead of generic
'state = (State*)bs->opaque' we have to use special helper.

---
 block/nbd.c | 197 +++++++++++++++++++++++++---------------------------
 1 file changed, 94 insertions(+), 103 deletions(-)
block/nbd.c +94 -103
index 1f00be2d66..81edabbf35 100644
@@ -53,7 +53,7 @@ typedef struct {
     bool receiving;         /* waiting for connection_co? */
 } NBDClientRequest;
 
-typedef struct NBDClientSession {
+typedef struct BDRVNBDState {
     QIOChannelSocket *sioc; /* The master data channel */
     QIOChannel *ioc; /* The current I/O channel which may differ (eg TLS) */
     NBDExportInfo info;
@@ -67,24 +67,13 @@ typedef struct NBDClientSession {
     NBDReply reply;
     BlockDriverState *bs;
     bool quit;
-} NBDClientSession;
-
-typedef struct BDRVNBDState {
-    NBDClientSession client;
 
     /* For nbd_refresh_filename() */
     SocketAddress *saddr;
     char *export, *tlscredsid;
 } BDRVNBDState;
 
-static NBDClientSession *nbd_get_client_session(BlockDriverState *bs)
-{
-    BDRVNBDState *s = bs->opaque;
-    return &s->client;
-}
-
-
-static void nbd_recv_coroutines_wake_all(NBDClientSession *s)
+static void nbd_recv_coroutines_wake_all(BDRVNBDState *s)
 {
     int i;
 
@@ -99,14 +88,15 @@ static void nbd_recv_coroutines_wake_all(NBDClientSession *s)
 
 static void nbd_client_detach_aio_context(BlockDriverState *bs)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
-    qio_channel_detach_aio_context(QIO_CHANNEL(client->ioc));
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
+
+    qio_channel_detach_aio_context(QIO_CHANNEL(s->ioc));
 }
 
 static void nbd_client_attach_aio_context_bh(void *opaque)
 {
     BlockDriverState *bs = opaque;
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
 
     /*
      * The node is still drained, so we know the coroutine has yielded in
@@ -114,15 +104,16 @@ static void nbd_client_attach_aio_context_bh(void *opaque)
      * entered for the first time. Both places are safe for entering the
      * coroutine.
      */
-    qemu_aio_coroutine_enter(bs->aio_context, client->connection_co);
+    qemu_aio_coroutine_enter(bs->aio_context, s->connection_co);
     bdrv_dec_in_flight(bs);
 }
 
 static void nbd_client_attach_aio_context(BlockDriverState *bs,
                                           AioContext *new_context)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
-    qio_channel_attach_aio_context(QIO_CHANNEL(client->ioc), new_context);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
+
+    qio_channel_attach_aio_context(QIO_CHANNEL(s->ioc), new_context);
 
     bdrv_inc_in_flight(bs);
 
@@ -136,26 +127,26 @@ static void nbd_client_attach_aio_context(BlockDriverState *bs,
 
 static void nbd_teardown_connection(BlockDriverState *bs)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
 
-    assert(client->ioc);
+    assert(s->ioc);
 
     /* finish any pending coroutines */
-    qio_channel_shutdown(client->ioc,
+    qio_channel_shutdown(s->ioc,
                          QIO_CHANNEL_SHUTDOWN_BOTH,
                          NULL);
-    BDRV_POLL_WHILE(bs, client->connection_co);
+    BDRV_POLL_WHILE(bs, s->connection_co);
 
     nbd_client_detach_aio_context(bs);
-    object_unref(OBJECT(client->sioc));
-    client->sioc = NULL;
-    object_unref(OBJECT(client->ioc));
-    client->ioc = NULL;
+    object_unref(OBJECT(s->sioc));
+    s->sioc = NULL;
+    object_unref(OBJECT(s->ioc));
+    s->ioc = NULL;
 }
 
 static coroutine_fn void nbd_connection_entry(void *opaque)
 {
-    NBDClientSession *s = opaque;
+    BDRVNBDState *s = opaque;
     uint64_t i;
     int ret = 0;
     Error *local_err = NULL;
@@ -223,7 +214,7 @@ static int nbd_co_send_request(BlockDriverState *bs,
                                NBDRequest *request,
                                QEMUIOVector *qiov)
 {
-    NBDClientSession *s = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     int rc, i;
 
     qemu_co_mutex_lock(&s->send_mutex);
@@ -298,7 +289,7 @@ static inline uint64_t payload_advance64(uint8_t **payload)
     return ldq_be_p(*payload - 8);
 }
 
-static int nbd_parse_offset_hole_payload(NBDClientSession *client,
+static int nbd_parse_offset_hole_payload(BDRVNBDState *s,
                                          NBDStructuredReplyChunk *chunk,
                                          uint8_t *payload, uint64_t orig_offset,
                                          QEMUIOVector *qiov, Error **errp)
@@ -321,8 +312,8 @@ static int nbd_parse_offset_hole_payload(NBDClientSession *client,
                          " region");
         return -EINVAL;
     }
-    if (client->info.min_block &&
-        !QEMU_IS_ALIGNED(hole_size, client->info.min_block)) {
+    if (s->info.min_block &&
+        !QEMU_IS_ALIGNED(hole_size, s->info.min_block)) {
         trace_nbd_structured_read_compliance("hole");
     }
 
@@ -336,7 +327,7 @@ static int nbd_parse_offset_hole_payload(NBDClientSession *client,
  * Based on our request, we expect only one extent in reply, for the
  * base:allocation context.
  */
-static int nbd_parse_blockstatus_payload(NBDClientSession *client,
+static int nbd_parse_blockstatus_payload(BDRVNBDState *s,
                                          NBDStructuredReplyChunk *chunk,
                                          uint8_t *payload, uint64_t orig_length,
                                          NBDExtent *extent, Error **errp)
@@ -351,11 +342,11 @@ static int nbd_parse_blockstatus_payload(NBDClientSession *client,
     }
 
     context_id = payload_advance32(&payload);
-    if (client->info.context_id != context_id) {
+    if (s->info.context_id != context_id) {
         error_setg(errp, "Protocol error: unexpected context id %d for "
                          "NBD_REPLY_TYPE_BLOCK_STATUS, when negotiated context "
                          "id is %d", context_id,
-                         client->info.context_id);
+                         s->info.context_id);
         return -EINVAL;
     }
 
@@ -380,14 +371,14 @@ static int nbd_parse_blockstatus_payload(NBDClientSession *client,
      * up to the full block and change the status to fully-allocated
      * (always a safe status, even if it loses information).
      */
-    if (client->info.min_block && !QEMU_IS_ALIGNED(extent->length,
-                                                   client->info.min_block)) {
+    if (s->info.min_block && !QEMU_IS_ALIGNED(extent->length,
+                                                   s->info.min_block)) {
         trace_nbd_parse_blockstatus_compliance("extent length is unaligned");
-        if (extent->length > client->info.min_block) {
+        if (extent->length > s->info.min_block) {
             extent->length = QEMU_ALIGN_DOWN(extent->length,
-                                             client->info.min_block);
+                                             s->info.min_block);
         } else {
-            extent->length = client->info.min_block;
+            extent->length = s->info.min_block;
             extent->flags = 0;
         }
     }
@@ -453,7 +444,7 @@ static int nbd_parse_error_payload(NBDStructuredReplyChunk *chunk,
     return 0;
 }
 
-static int nbd_co_receive_offset_data_payload(NBDClientSession *s,
+static int nbd_co_receive_offset_data_payload(BDRVNBDState *s,
                                               uint64_t orig_offset,
                                               QEMUIOVector *qiov, Error **errp)
 {
@@ -498,7 +489,7 @@ static int nbd_co_receive_offset_data_payload(NBDClientSession *s,
 
 #define NBD_MAX_MALLOC_PAYLOAD 1000
 static coroutine_fn int nbd_co_receive_structured_payload(
-        NBDClientSession *s, void **payload, Error **errp)
+        BDRVNBDState *s, void **payload, Error **errp)
 {
     int ret;
     uint32_t len;
@@ -548,7 +539,7 @@ static coroutine_fn int nbd_co_receive_structured_payload(
  * corresponding to the server's error reply), and errp is unchanged.
  */
 static coroutine_fn int nbd_co_do_receive_one_chunk(
-        NBDClientSession *s, uint64_t handle, bool only_structured,
+        BDRVNBDState *s, uint64_t handle, bool only_structured,
         int *request_ret, QEMUIOVector *qiov, void **payload, Error **errp)
 {
     int ret;
@@ -641,7 +632,7 @@ static coroutine_fn int nbd_co_do_receive_one_chunk(
  * Return value is a fatal error code or normal nbd reply error code
  */
 static coroutine_fn int nbd_co_receive_one_chunk(
-        NBDClientSession *s, uint64_t handle, bool only_structured,
+        BDRVNBDState *s, uint64_t handle, bool only_structured,
         int *request_ret, QEMUIOVector *qiov, NBDReply *reply, void **payload,
         Error **errp)
 {
@@ -709,7 +700,7 @@ static void nbd_iter_request_error(NBDReplyChunkIter *iter, int ret)
  * nbd_reply_chunk_iter_receive
  * The pointer stored in @payload requires g_free() to free it.
  */
-static bool nbd_reply_chunk_iter_receive(NBDClientSession *s,
+static bool nbd_reply_chunk_iter_receive(BDRVNBDState *s,
                                          NBDReplyChunkIter *iter,
                                          uint64_t handle,
                                          QEMUIOVector *qiov, NBDReply *reply,
@@ -776,7 +767,7 @@ break_loop:
     return false;
 }
 
-static int nbd_co_receive_return_code(NBDClientSession *s, uint64_t handle,
+static int nbd_co_receive_return_code(BDRVNBDState *s, uint64_t handle,
                                       int *request_ret, Error **errp)
 {
     NBDReplyChunkIter iter;
@@ -790,7 +781,7 @@ static int nbd_co_receive_return_code(NBDClientSession *s, uint64_t handle,
     return iter.ret;
 }
 
-static int nbd_co_receive_cmdread_reply(NBDClientSession *s, uint64_t handle,
+static int nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t handle,
                                         uint64_t offset, QEMUIOVector *qiov,
                                         int *request_ret, Error **errp)
 {
@@ -842,7 +833,7 @@ static int nbd_co_receive_cmdread_reply(NBDClientSession *s, uint64_t handle,
     return iter.ret;
 }
 
-static int nbd_co_receive_blockstatus_reply(NBDClientSession *s,
+static int nbd_co_receive_blockstatus_reply(BDRVNBDState *s,
                                             uint64_t handle, uint64_t length,
                                             NBDExtent *extent,
                                             int *request_ret, Error **errp)
@@ -907,7 +898,7 @@ static int nbd_co_request(BlockDriverState *bs, NBDRequest *request,
 {
     int ret, request_ret;
     Error *local_err = NULL;
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
 
     assert(request->type != NBD_CMD_READ);
     if (write_qiov) {
@@ -921,7 +912,7 @@ static int nbd_co_request(BlockDriverState *bs, NBDRequest *request,
         return ret;
     }
 
-    ret = nbd_co_receive_return_code(client, request->handle,
+    ret = nbd_co_receive_return_code(s, request->handle,
                                      &request_ret, &local_err);
     if (local_err) {
         trace_nbd_co_request_fail(request->from, request->len, request->handle,
@@ -938,7 +929,7 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
 {
     int ret, request_ret;
     Error *local_err = NULL;
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     NBDRequest request = {
         .type = NBD_CMD_READ,
         .from = offset,
@@ -957,13 +948,13 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
      * advertised size because the block layer rounded size up, then
      * truncate the request to the server and tail-pad with zero.
      */
-    if (offset >= client->info.size) {
+    if (offset >= s->info.size) {
         assert(bytes < BDRV_SECTOR_SIZE);
         qemu_iovec_memset(qiov, 0, 0, bytes);
         return 0;
     }
-    if (offset + bytes > client->info.size) {
-        uint64_t slop = offset + bytes - client->info.size;
+    if (offset + bytes > s->info.size) {
+        uint64_t slop = offset + bytes - s->info.size;
 
         assert(slop < BDRV_SECTOR_SIZE);
         qemu_iovec_memset(qiov, bytes - slop, 0, slop);
@@ -975,7 +966,7 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
         return ret;
     }
 
-    ret = nbd_co_receive_cmdread_reply(client, request.handle, offset, qiov,
+    ret = nbd_co_receive_cmdread_reply(s, request.handle, offset, qiov,
                                        &request_ret, &local_err);
     if (local_err) {
         trace_nbd_co_request_fail(request.from, request.len, request.handle,
@@ -990,16 +981,16 @@ static int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
 static int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
                                  uint64_t bytes, QEMUIOVector *qiov, int flags)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     NBDRequest request = {
         .type = NBD_CMD_WRITE,
         .from = offset,
         .len = bytes,
     };
 
-    assert(!(client->info.flags & NBD_FLAG_READ_ONLY));
+    assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
     if (flags & BDRV_REQ_FUA) {
-        assert(client->info.flags & NBD_FLAG_SEND_FUA);
+        assert(s->info.flags & NBD_FLAG_SEND_FUA);
         request.flags |= NBD_CMD_FLAG_FUA;
     }
 
@@ -1014,20 +1005,20 @@ static int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
 static int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
                                        int bytes, BdrvRequestFlags flags)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     NBDRequest request = {
         .type = NBD_CMD_WRITE_ZEROES,
         .from = offset,
         .len = bytes,
     };
 
-    assert(!(client->info.flags & NBD_FLAG_READ_ONLY));
-    if (!(client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES)) {
+    assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
+    if (!(s->info.flags & NBD_FLAG_SEND_WRITE_ZEROES)) {
         return -ENOTSUP;
     }
 
     if (flags & BDRV_REQ_FUA) {
-        assert(client->info.flags & NBD_FLAG_SEND_FUA);
+        assert(s->info.flags & NBD_FLAG_SEND_FUA);
         request.flags |= NBD_CMD_FLAG_FUA;
     }
     if (!(flags & BDRV_REQ_MAY_UNMAP)) {
@@ -1042,10 +1033,10 @@ static int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
 
 static int nbd_client_co_flush(BlockDriverState *bs)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     NBDRequest request = { .type = NBD_CMD_FLUSH };
 
-    if (!(client->info.flags & NBD_FLAG_SEND_FLUSH)) {
+    if (!(s->info.flags & NBD_FLAG_SEND_FLUSH)) {
         return 0;
     }
 
@@ -1058,15 +1049,15 @@ static int nbd_client_co_flush(BlockDriverState *bs)
 static int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset,
                                   int bytes)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     NBDRequest request = {
         .type = NBD_CMD_TRIM,
         .from = offset,
         .len = bytes,
     };
 
-    assert(!(client->info.flags & NBD_FLAG_READ_ONLY));
-    if (!(client->info.flags & NBD_FLAG_SEND_TRIM) || !bytes) {
+    assert(!(s->info.flags & NBD_FLAG_READ_ONLY));
+    if (!(s->info.flags & NBD_FLAG_SEND_TRIM) || !bytes) {
         return 0;
     }
 
@@ -1079,7 +1070,7 @@ static int coroutine_fn nbd_client_co_block_status(
 {
     int ret, request_ret;
     NBDExtent extent = { 0 };
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     Error *local_err = NULL;
 
     NBDRequest request = {
@@ -1087,12 +1078,12 @@ static int coroutine_fn nbd_client_co_block_status(
         .from = offset,
         .len = MIN(MIN_NON_ZERO(QEMU_ALIGN_DOWN(INT_MAX,
                                                 bs->bl.request_alignment),
-                                client->info.max_block),
-                   MIN(bytes, client->info.size - offset)),
+                                s->info.max_block),
+                   MIN(bytes, s->info.size - offset)),
         .flags = NBD_CMD_FLAG_REQ_ONE,
     };
 
-    if (!client->info.base_allocation) {
+    if (!s->info.base_allocation) {
         *pnum = bytes;
         *map = offset;
         *file = bs;
@@ -1106,22 +1097,22 @@ static int coroutine_fn nbd_client_co_block_status(
      * up, we truncated the request to the server (above), or are
      * called on just the hole.
      */
-    if (offset >= client->info.size) {
+    if (offset >= s->info.size) {
         *pnum = bytes;
         assert(bytes < BDRV_SECTOR_SIZE);
         /* Intentionally don't report offset_valid for the hole */
         return BDRV_BLOCK_ZERO;
     }
 
-    if (client->info.min_block) {
-        assert(QEMU_IS_ALIGNED(request.len, client->info.min_block));
+    if (s->info.min_block) {
+        assert(QEMU_IS_ALIGNED(request.len, s->info.min_block));
     }
     ret = nbd_co_send_request(bs, &request, NULL);
     if (ret < 0) {
         return ret;
     }
 
-    ret = nbd_co_receive_blockstatus_reply(client, request.handle, bytes,
+    ret = nbd_co_receive_blockstatus_reply(s, request.handle, bytes,
                                            &extent, &request_ret, &local_err);
     if (local_err) {
         trace_nbd_co_request_fail(request.from, request.len, request.handle,
@@ -1145,12 +1136,12 @@ static int coroutine_fn nbd_client_co_block_status(
 
 static void nbd_client_close(BlockDriverState *bs)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     NBDRequest request = { .type = NBD_CMD_DISC };
 
-    assert(client->ioc);
+    assert(s->ioc);
 
-    nbd_send_request(client->ioc, &request);
+    nbd_send_request(s->ioc, &request);
 
     nbd_teardown_connection(bs);
 }
@@ -1184,7 +1175,7 @@ static int nbd_client_connect(BlockDriverState *bs,
                               const char *x_dirty_bitmap,
                               Error **errp)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     int ret;
 
     /*
@@ -1201,44 +1192,44 @@ static int nbd_client_connect(BlockDriverState *bs,
     trace_nbd_client_connect(export);
     qio_channel_set_blocking(QIO_CHANNEL(sioc), true, NULL);
 
-    client->info.request_sizes = true;
-    client->info.structured_reply = true;
-    client->info.base_allocation = true;
-    client->info.x_dirty_bitmap = g_strdup(x_dirty_bitmap);
-    client->info.name = g_strdup(export ?: "");
+    s->info.request_sizes = true;
+    s->info.structured_reply = true;
+    s->info.base_allocation = true;
+    s->info.x_dirty_bitmap = g_strdup(x_dirty_bitmap);
+    s->info.name = g_strdup(export ?: "");
     ret = nbd_receive_negotiate(QIO_CHANNEL(sioc), tlscreds, hostname,
-                                &client->ioc, &client->info, errp);
-    g_free(client->info.x_dirty_bitmap);
-    g_free(client->info.name);
+                                &s->ioc, &s->info, errp);
+    g_free(s->info.x_dirty_bitmap);
+    g_free(s->info.name);
     if (ret < 0) {
         object_unref(OBJECT(sioc));
         return ret;
     }
-    if (x_dirty_bitmap && !client->info.base_allocation) {
+    if (x_dirty_bitmap && !s->info.base_allocation) {
         error_setg(errp, "requested x-dirty-bitmap %s not found",
                    x_dirty_bitmap);
         ret = -EINVAL;
         goto fail;
     }
-    if (client->info.flags & NBD_FLAG_READ_ONLY) {
+    if (s->info.flags & NBD_FLAG_READ_ONLY) {
         ret = bdrv_apply_auto_read_only(bs, "NBD export is read-only", errp);
         if (ret < 0) {
             goto fail;
         }
     }
-    if (client->info.flags & NBD_FLAG_SEND_FUA) {
+    if (s->info.flags & NBD_FLAG_SEND_FUA) {
         bs->supported_write_flags = BDRV_REQ_FUA;
         bs->supported_zero_flags |= BDRV_REQ_FUA;
     }
-    if (client->info.flags & NBD_FLAG_SEND_WRITE_ZEROES) {
+    if (s->info.flags & NBD_FLAG_SEND_WRITE_ZEROES) {
         bs->supported_zero_flags |= BDRV_REQ_MAY_UNMAP;
     }
 
-    client->sioc = sioc;
+    s->sioc = sioc;
 
-    if (!client->ioc) {
-        client->ioc = QIO_CHANNEL(sioc);
-        object_ref(OBJECT(client->ioc));
+    if (!s->ioc) {
+        s->ioc = QIO_CHANNEL(sioc);
+        object_ref(OBJECT(s->ioc));
     }
 
     /*
@@ -1246,7 +1237,7 @@ static int nbd_client_connect(BlockDriverState *bs,
      * kick the reply mechanism.
      */
     qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
-    client->connection_co = qemu_coroutine_create(nbd_connection_entry, client);
+    s->connection_co = qemu_coroutine_create(nbd_connection_entry, s);
     bdrv_inc_in_flight(bs);
     nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
 
@@ -1263,7 +1254,7 @@ static int nbd_client_connect(BlockDriverState *bs,
     {
         NBDRequest request = { .type = NBD_CMD_DISC };
 
-        nbd_send_request(client->ioc ?: QIO_CHANNEL(sioc), &request);
+        nbd_send_request(s->ioc ?: QIO_CHANNEL(sioc), &request);
 
         object_unref(OBJECT(sioc));
 
@@ -1279,11 +1270,11 @@ static int nbd_client_init(BlockDriverState *bs,
                            const char *x_dirty_bitmap,
                            Error **errp)
 {
-    NBDClientSession *client = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
 
-    client->bs = bs;
-    qemu_co_mutex_init(&client->send_mutex);
-    qemu_co_queue_init(&client->free_sema);
+    s->bs = bs;
+    qemu_co_mutex_init(&s->send_mutex);
+    qemu_co_queue_init(&s->free_sema);
 
     return nbd_client_connect(bs, saddr, export, tlscreds, hostname,
                               x_dirty_bitmap, errp);
@@ -1665,7 +1656,7 @@ static int nbd_co_flush(BlockDriverState *bs)
 
 static void nbd_refresh_limits(BlockDriverState *bs, Error **errp)
 {
-    NBDClientSession *s = nbd_get_client_session(bs);
+    BDRVNBDState *s = (BDRVNBDState *)bs->opaque;
     uint32_t min = s->info.min_block;
     uint32_t max = MIN_NON_ZERO(NBD_MAX_BUFFER_SIZE, s->info.max_block);
 
@@ -1712,7 +1703,7 @@ static int64_t nbd_getlength(BlockDriverState *bs)
 {
     BDRVNBDState *s = bs->opaque;
 
-    return s->client.info.size;
+    return s->info.size;
 }
 
 static void nbd_refresh_filename(BlockDriverState *bs)
Signature · 1 line
2.18.0
Reviewed-by on v1 3/3
#6 lore raw

Re: [Qemu-devel] [PATCH 3/3] block/nbd: merge NBDClientSession struct back to BDRVNBDState

Quoted 2 lines · Vladimir Sementsov-Ogievskiy

No reason to keep it separate, it differs from others block driver behavior and therefor confuses. Instead of generic

s/therefor/therefore/ (both spellings are valid, but the former looks archaic)

Quoted 7 lines

'state = (State*)bs->opaque' we have to use special helper.

---
 block/nbd.c | 197 +++++++++++++++++++++++++---------------------------
 1 file changed, 94 insertions(+), 103 deletions(-)

I'm queuing this series through my NBD tree.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org
#7 lore raw

Re: [Qemu-devel] [PATCH 3/3] block/nbd: merge NBDClientSession struct back to BDRVNBDState

Quoted 6 lines · Eric Blake
Quoted 2 lines · Vladimir Sementsov-Ogievskiy

No reason to keep it separate, it differs from others block driver behavior and therefor confuses. Instead of generic

s/therefor/therefore/ (both spellings are valid, but the former looks archaic)

Interesting, for me it was just a mistake.

Quoted 9 lines
Quoted 8 lines

'state = (State*)bs->opaque' we have to use special helper.

---
  block/nbd.c | 197 +++++++++++++++++++++++++---------------------------
  1 file changed, 94 insertions(+), 103 deletions(-)
Quoted 4 lines

I'm queuing this series through my NBD tree.

Thanks!! I'll rebase reconnect series on this.

Signature · 2 lines
Best regards,
Vladimir
#8 lore raw

Re: [Qemu-devel] [PATCH 3/3] block/nbd: merge NBDClientSession struct back to BDRVNBDState

In reply to Eric Blake
Quoted 6 lines · Eric Blake
Quoted 2 lines · Vladimir Sementsov-Ogievskiy

No reason to keep it separate, it differs from others block driver behavior and therefor confuses. Instead of generic

s/therefor/therefore/ (both spellings are valid, but the former looks archaic)

The things you teach me.

I will happily use “therefor” from now on whenever not too inappropriate.

(I like how Wiktionary notes that “therefor” is an anagram of “therfore”. That one looks nice, too. I suppose I will just switch between both at random.)

Max