block/nbd: rework client connection
Subsystems (2)
v4 cover block/nbd: rework client connection
v4:
Now based on new Paolo's patch:
Based-on: <[email protected]>
Also, I've dropped patch 33 for now, it's too much for this series. I'll resend it later on top of this.
The series is also available at tag up-nbd-client-connection-v4 in git https://src.openvz.org/scm/~vsementsov/qemu.git
01: new
02: add Eric's r-b
03: add Roman's and Eric's r-bs
04: rebased to start of the series
05-06: new
07: tweak comment, add Eric's r-b
08: add Roman's r-b
09: add Eric's r-b
10: tweak comment, use aio_co_wake (after Paolo's fix), keep calling aio_co_wake after mutex in nbd_co_establish_connection_cancel 11: improve comments, change logic a bit
12: add Eric's r-b, fix grammar
13: add Eric's r-b, improve wording
14: add Roman's and Eric's r-bs
15: add Eric's r-b, fix commit message
16: rebased
17: add Eric's r-b, rebased on some changes, but still a clear movement.
18: rebased, changed
19: rebased, tweak comment
20: tweak wording, add comment
21: rebased, tweak wording
22: add Roman's and Eric's r-bs, tweak comment
23: add Eric's r-b, tweak commit message
24: add Eric's r-b, tweak commit message and subject
25-26: add Eric's r-b
27: add Eric's r-b, tweak commit message
28: tweak commit message, keep coroutine_fn
29: add Eric's r-b, tweak commit message
30: add Eric's r-b, add whitespace in comment
31: add Eric's r-b, fix s/clinen?t/client/
32: add Eric's r-b, rebased
Roman Kagan (2):
block/nbd: fix channel object leak block/nbd: ensure ->connection_thread is always valid
Vladimir Sementsov-Ogievskiy (30):
co-queue: drop extra coroutine_fn marks
block/nbd: fix how state is cleared on nbd_open() failure paths block/nbd: connect_thread_func(): do qio_channel_set_delay(false)
qemu-sockets: introduce socket_address_parse_named_fd() block/nbd: call socket_address_parse_named_fd() in advance block/nbd: nbd_client_handshake(): fix leak of s->ioc block/nbd: BDRVNBDState: drop unused connect_err and connect_status block/nbd: simplify waking of nbd_co_establish_connection() block/nbd: drop thr->state
block/nbd: bs-independent interface for nbd_co_establish_connection() block/nbd: make nbd_co_establish_connection_cancel() bs-independent block/nbd: rename NBDConnectThread to NBDClientConnection block/nbd: introduce nbd_client_connection_new() block/nbd: introduce nbd_client_connection_release()
nbd: move connection code from block/nbd to nbd/client-connection nbd/client-connection: use QEMU_LOCK_GUARD nbd/client-connection: add possibility of negotiation nbd/client-connection: implement connection retry nbd/client-connection: shutdown connection on release block/nbd: split nbd_handle_updated_info out of nbd_client_handshake() block/nbd: use negotiation of NBDClientConnection block/nbd: don't touch s->sioc in nbd_teardown_connection() block/nbd: drop BDRVNBDState::sioc
nbd/client-connection: return only one io channel
block-coroutine-wrapper: allow non bdrv_ prefix
block/nbd: split nbd_co_do_establish_connection out of
nbd_reconnect_attempt
nbd/client-connection: add option for non-blocking connection attempt block/nbd: reuse nbd_co_do_establish_connection() in nbd_open() block/nbd: add nbd_client_connected() helper
block/nbd: safer transition to receiving request
block/coroutines.h | 6 + include/block/nbd.h | 18 + include/qemu/coroutine.h | 6 +- include/qemu/sockets.h | 14 + block/nbd.c | 553 ++++++----------------------- nbd/client-connection.c | 384 ++++++++++++++++++++ util/qemu-sockets.c | 19 + nbd/meson.build | 1 + scripts/block-coroutine-wrapper.py | 7 +- 9 files changed, 560 insertions(+), 448 deletions(-) create mode 100644 nbd/client-connection.c
Signature · 1 line
2.29.2
PATCH v4 6/32 block/nbd: call socket_address_parse_named_fd() in advance
Detecting monitor by current coroutine works bad when we are not in coroutine context. And that's exactly so in nbd reconnect code, where qio_channel_socket_connect_sync() is called from thread.
Monitor is needed only to parse named file descriptor. So, let's just parse it during nbd_open(), so that all further users of s->saddr don't need to access monitor.
--- block/nbd.c | 6 ++++++ 1 file changed, 6 insertions(+)
block/nbd.c +6 -0
@@ -2140,6 +2140,12 @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options, goto done; } +if (socket_address_parse_named_fd (saddr, errp) <0 ) { +qapi_free_SocketAddress (saddr); + saddr =NULL ; + goto done; + } + done:qobject_unref (addr);visit_free (iv);
Signature · 1 line
2.29.2
PATCH v4 7/32 block/nbd: ensure ->connection_thread is always valid
In reply to Vladimir Sementsov-OgievskiyFrom: Roman Kagan <[email protected]>
Simplify lifetime management of BDRVNBDState->connect_thread by delaying the possible cleanup of it until the BDRVNBDState itself goes away.
This also reverts
0267101af6 "block/nbd: fix possible use after free of s->connect_thread"
as now s->connect_thread can't be cleared until the very end.
--- block/nbd.c | 56 ++++++++++++++++++++--------------------------------- 1 file changed, 21 insertions(+), 35 deletions(-)
block/nbd.c +21 -35
@@ -144,17 +144,31 @@ typedef struct BDRVNBDState {NBDConnectThread *connect_thread; } BDRVNBDState; +static void nbd_free_connect_thread (NBDConnectThread *thr);static int nbd_establish_connection (BlockDriverState *bs,SocketAddress *saddr,Error **errp);static int nbd_co_establish_connection (BlockDriverState *bs,Error **errp); -static void nbd_co_establish_connection_cancel (BlockDriverState *bs, -bool detach); +static void nbd_co_establish_connection_cancel (BlockDriverState *bs);static int nbd_client_handshake (BlockDriverState *bs,Error **errp);static void nbd_yank (void *opaque);static void nbd_clear_bdrvstate (BlockDriverState *bs) {BDRVNBDState *s = (BDRVNBDState *)bs->opaque; +NBDConnectThread *thr = s->connect_thread; +bool thr_running; + +qemu_mutex_lock (&thr->mutex); + thr_running = thr->state ==CONNECT_THREAD_RUNNING ; +if (thr_running) { + thr->state =CONNECT_THREAD_RUNNING_DETACHED ; + } +qemu_mutex_unlock (&thr->mutex); + +/* the runaway thread will clean up itself */ +if (!thr_running) { +nbd_free_connect_thread (thr); + }yank_unregister_instance (BLOCKDEV_YANK_INSTANCE (bs->node_name));
@@ -295,7 +309,7 @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs) s->drained = true;qemu_co_sleep_wake (&s->reconnect_sleep); -nbd_co_establish_connection_cancel (bs, false); +nbd_co_establish_connection_cancel (bs);reconnect_delay_timer_del (s);
@@ -333,7 +347,7 @@ static void nbd_teardown_connection(BlockDriverState *bs) s->state =NBD_CLIENT_QUIT ;if (s->connection_co) {qemu_co_sleep_wake (&s->reconnect_sleep); -nbd_co_establish_connection_cancel (bs, true); +nbd_co_establish_connection_cancel (bs); }if (qemu_in_coroutine ()) { s->teardown_co =qemu_coroutine_self ();
@@ -446,11 +460,6 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp)BDRVNBDState *s = bs->opaque;NBDConnectThread *thr = s->connect_thread; -if (!thr) { -/* detached */ -return -1 ; - } -qemu_mutex_lock (&thr->mutex);switch (thr->state) {
@@ -494,12 +503,6 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp) s->wait_connect = true;qemu_coroutine_yield (); -if (!s->connect_thread) { -/* detached */ -return -1 ; - } -assert (thr == s->connect_thread); -qemu_mutex_lock (&thr->mutex);switch (thr->state) {
@@ -547,18 +550,12 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp)* nbd_co_establish_connection_cancel * Cancel nbd_co_establish_connection asynchronously: it will finish soon, to * allow drained section to begin. -* -* If detach is true, also cleanup the state (or if thread is running, move it -* to CONNECT_THREAD_RUNNING_DETACHED state). s->connect_thread becomes NULL if -* detach is true. */ -static void nbd_co_establish_connection_cancel (BlockDriverState *bs, -bool detach) +static void nbd_co_establish_connection_cancel (BlockDriverState *bs) {BDRVNBDState *s = bs->opaque;NBDConnectThread *thr = s->connect_thread;bool wake = false; -bool do_free = false;qemu_mutex_lock (&thr->mutex);
@@ -569,21 +566,10 @@ static void nbd_co_establish_connection_cancel(BlockDriverState *bs, s->wait_connect = false; wake = true; } -if (detach) { - thr->state =CONNECT_THREAD_RUNNING_DETACHED ; - s->connect_thread =NULL ; - } - }else if (detach) { - do_free = true; }qemu_mutex_unlock (&thr->mutex); -if (do_free) { -nbd_free_connect_thread (thr); - s->connect_thread =NULL ; - } -if (wake) {aio_co_wake (s->connection_co); }
@@ -2310,6 +2296,8 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } +nbd_init_connect_thread (s); +/* * establish TCP connection, return error if it fails * TODO: Configurable retry-until-timeout behaviour.
@@ -2326,8 +2314,6 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,/* successfully connected */ s->state =NBD_CLIENT_CONNECTED ; -nbd_init_connect_thread (s); - s->connection_co =qemu_coroutine_create (nbd_connection_entry, s);bdrv_inc_in_flight (bs);aio_co_schedule (bdrv_get_aio_context (bs), s->connection_co);
Signature · 1 line
2.29.2
PATCH v4 21/32 nbd/client-connection: shutdown connection on release
In reply to Vladimir Sementsov-OgievskiyNow, when a thread can do negotiation and retry, it may run relatively long. We need a mechanism to stop it, when the user is not interested in a result any more. So, on nbd_client_connection_release() let's shutdown the socket, and do not retry connection if thread is detached.
--- nbd/client-connection.c | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-)
nbd/client-connection.c +17 -3
@@ -167,9 +167,13 @@ static void *connect_thread_func(void *opaque)uint64_t timeout =1 ;uint64_t max_timeout =16 ; -while (true) { +qemu_mutex_lock (&conn->mutex); +while (!conn->detached) { +assert (!conn->sioc); conn->sioc =qio_channel_socket_new (); +qemu_mutex_unlock (&conn->mutex); +error_free (conn->err); conn->err =NULL ; conn->updated_info = conn->initial_info;
@@ -187,14 +191,20 @@ static void *connect_thread_func(void *opaque) conn->updated_info.x_dirty_bitmap =NULL ; conn->updated_info.name =NULL ; +qemu_mutex_lock (&conn->mutex); +if (ret <0 ) {object_unref (OBJECT (conn->sioc)); conn->sioc =NULL ; -if (conn->do_retry) { +if (conn->do_retry && !conn->detached) { +qemu_mutex_unlock (&conn->mutex); +sleep (timeout);if (timeout < max_timeout) { timeout *=2 ; } + +qemu_mutex_lock (&conn->mutex);continue ; } }
@@ -202,7 +212,7 @@ static void *connect_thread_func(void *opaque)break ; } -qemu_mutex_lock (&conn->mutex); +/* mutex is locked */ assert (conn->running); conn->running = false;
@@ -236,6 +246,10 @@ void nbd_client_connection_release(NBDClientConnection *conn) }else { do_free = true; } +if (conn->sioc) { +qio_channel_shutdown (QIO_CHANNEL (conn->sioc), +QIO_CHANNEL_SHUTDOWN_BOTH ,NULL ); + } }if (do_free) {
Signature · 1 line
2.29.2
PATCH v4 1/32 co-queue: drop extra coroutine_fn marks
In reply to Vladimir Sementsov-Ogievskiyqemu_co_queue_next() and qemu_co_queue_restart_all() just call aio_co_wake() which works well in non-coroutine context. So these functions can be called from non-coroutine context as well. And actually qemu_co_queue_restart_all() is called from nbd_cancel_in_flight(), which is called from non-coroutine context.
--- include/qemu/coroutine.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
include/qemu/coroutine.h +4 -2
@@ -210,13 +210,15 @@ void coroutine_fn qemu_co_queue_wait_impl(CoQueue *queue, QemuLockable *lock);/** * Removes the next coroutine from the CoQueue, and wake it up. * Returns true if a coroutine was removed, false if the queue is empty. +* OK to run from coroutine and non-coroutine context. */ -bool coroutine_fn qemu_co_queue_next(CoQueue *queue); +bool qemu_co_queue_next (CoQueue *queue);/** * Empties the CoQueue; all coroutines are woken up. +* OK to run from coroutine and non-coroutine context. */ -void coroutine_fn qemu_co_queue_restart_all(CoQueue *queue); +void qemu_co_queue_restart_all (CoQueue *queue);/** * Removes the next coroutine from the CoQueue, and wake it up. Unlike
Signature · 1 line
2.29.2
PATCH v4 8/32 block/nbd: nbd_client_handshake(): fix leak of s->ioc
In reply to Vladimir Sementsov-Ogievskiy--- block/nbd.c | 2 ++ 1 file changed, 2 insertions(+)
block/nbd.c +2 -0
@@ -1889,6 +1889,8 @@ static int nbd_client_handshake(BlockDriverState *bs, Error **errp) nbd_yank, bs);object_unref (OBJECT (s->sioc)); s->sioc =NULL ; +object_unref (OBJECT (s->ioc)); + s->ioc =NULL ;return ret; }
Signature · 1 line
2.29.2
PATCH v4 10/32 block/nbd: simplify waking of nbd_co_establish_connection()
In reply to Vladimir Sementsov-OgievskiyInstead of managing connect_bh, bh_ctx, and wait_connect fields, we can use a single link to the waiting coroutine with proper mutex protection.
So new logic is:
nbd_co_establish_connection() sets wait_co under the mutex, releases the mutex, then yield()s. Note that wait_co may be scheduled by the thread immediately after unlocking the mutex. Still, the main thread (or iothread) will not reach the code for entering the coroutine until the yield(), so we are safe.
connect_thread_func() and nbd_co_establish_connection_cancel() do the following to handle wait_co:
Under the mutex, if thr->wait_co is not NULL, make it NULL and schedule it. This way, we avoid scheduling the coroutine twice.
Still scheduling is a bit different:
In connect_thread_func() we can just call aio_co_wake under mutex, after commit
[async: the main AioContext is only "current" if under the BQL]
we are sure that aio_co_wake() will not try to acquire the aio context and do qemu_aio_coroutine_enter() but simply schedule the coroutine by aio_co_schedule().
nbd_co_establish_connection_cancel() will be called from non-coroutine context in further patch and will be able to go through qemu_aio_coroutine_enter() path of aio_co_wake(). So keep current behavior of waking the coroutine after the critical section.
Also, this commit reduces the dependence of nbd_co_establish_connection() on the internals of bs (we now use a generic pointer to the coroutine, instead of direct use of s->connection_co). This is a step towards splitting the connection API out of nbd.c.
--- block/nbd.c | 55 +++++++++++++++-------------------------------------- 1 file changed, 15 insertions(+), 40 deletions(-)
block/nbd.c +15 -40
@@ -87,12 +87,6 @@ typedef enum NBDConnectThreadState { typedef struct NBDConnectThread { /* Initialization constants */ SocketAddress *saddr; /* address to connect to */ - /* - * Bottom half to schedule on completion. Scheduled only if bh_ctx is not - * NULL - */ - QEMUBHFunc *bh_func; - void *bh_opaque; /* * Result of last attempt. Valid in FAIL and SUCCESS states.
@@ -101,10 +95,15 @@ typedef struct NBDConnectThread {QIOChannelSocket *sioc;Error *err; -/* state and bh_ctx are protected by mutex */ QemuMutex mutex; +/* All further fields are protected by mutex */ NBDConnectThreadState state;/* current state of the thread */ -AioContext *bh_ctx;/* where to schedule bh (NULL means don't schedule) */ + +/* +* wait_co: if non-NULL, which coroutine to wake in +* nbd_co_establish_connection() after yield() +*/ +Coroutine *wait_co; } NBDConnectThread; typedef struct BDRVNBDState {
@@ -138,7 +137,6 @@ typedef struct BDRVNBDState {char *x_dirty_bitmap;bool alloc_depth; -bool wait_connect;NBDConnectThread *connect_thread; } BDRVNBDState;
@@ -370,15 +368,6 @@ static bool nbd_client_connecting_wait(BDRVNBDState *s)return qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTING_WAIT ; } -static void connect_bh (void *opaque) -{ -BDRVNBDState *state = opaque; - -assert (state->wait_connect); - state->wait_connect = false; -aio_co_wake (state->connection_co); -} -static void nbd_init_connect_thread (BDRVNBDState *s) { s->connect_thread =g_new (NBDConnectThread,1 );
@@ -386,8 +375,6 @@ static void nbd_init_connect_thread(BDRVNBDState *s) *s->connect_thread = (NBDConnectThread ) { .saddr =QAPI_CLONE (SocketAddress, s->saddr), .state =CONNECT_THREAD_NONE , - .bh_func = connect_bh, - .bh_opaque = s, };qemu_mutex_init (&s->connect_thread->mutex);
@@ -427,11 +414,9 @@ static void *connect_thread_func(void *opaque)switch (thr->state) {case CONNECT_THREAD_RUNNING : thr->state = ret <0 ?CONNECT_THREAD_FAIL :CONNECT_THREAD_SUCCESS ; -if (thr->bh_ctx) { -aio_bh_schedule_oneshot (thr->bh_ctx, thr->bh_func, thr->bh_opaque); - -/* play safe, don't reuse bh_ctx on further connection attempts */ - thr->bh_ctx =NULL ; +if (thr->wait_co) { +aio_co_wake (thr->wait_co); + thr->wait_co =NULL ; }break ;case CONNECT_THREAD_RUNNING_DETACHED :
@@ -485,20 +470,14 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp)abort (); } - thr->bh_ctx =qemu_get_current_aio_context (); + thr->wait_co =qemu_coroutine_self ();qemu_mutex_unlock (&thr->mutex); -/* * We are going to wait for connect-thread finish, but * nbd_client_co_drain_begin() can interrupt. -* -* Note that wait_connect variable is not visible for connect-thread. It -* doesn't need mutex protection, it used only inside home aio context of -* bs. */ - s->wait_connect = true;qemu_coroutine_yield ();qemu_mutex_lock (&thr->mutex);
@@ -553,23 +532,19 @@ static void nbd_co_establish_connection_cancel(BlockDriverState *bs) {BDRVNBDState *s = bs->opaque;NBDConnectThread *thr = s->connect_thread; -bool wake = false; +Coroutine *wait_co =NULL ;qemu_mutex_lock (&thr->mutex);if (thr->state ==CONNECT_THREAD_RUNNING ) {/* We can cancel only in running state, when bh is not yet scheduled */ - thr->bh_ctx =NULL ; -if (s->wait_connect) { - s->wait_connect = false; - wake = true; - } + wait_co =g_steal_pointer (&thr->wait_co); }qemu_mutex_unlock (&thr->mutex); -if (wake) { -aio_co_wake (s->connection_co); +if (wait_co) { +aio_co_wake (wait_co); } }
Signature · 1 line
2.29.2
PATCH v4 2/32 block/nbd: fix channel object leak
In reply to Vladimir Sementsov-OgievskiyFrom: Roman Kagan <[email protected]>
nbd_free_connect_thread leaks the channel object if it hasn't been stolen.
Unref it and fix the leak.
--- block/nbd.c | 1 + 1 file changed, 1 insertion(+)
block/nbd.c +1 -0
@@ -381,6 +381,7 @@ static void nbd_free_connect_thread(NBDConnectThread *thr) {if (thr->sioc) {qio_channel_close (QIO_CHANNEL (thr->sioc),NULL ); +object_unref (OBJECT (thr->sioc)); }error_free (thr->err);qapi_free_SocketAddress (thr->saddr);
Signature · 1 line
2.29.2
PATCH v4 3/32 block/nbd: fix how state is cleared on nbd_open() failure paths
In reply to Vladimir Sementsov-OgievskiyWe have two "return error" paths in nbd_open() after nbd_process_options(). Actually we should call nbd_clear_bdrvstate() on these paths. Interesting that nbd_process_options() calls nbd_clear_bdrvstate() by itself.
Let's fix leaks and refactor things to be more obvious:
- intialize yank at top of nbd_open()
- move yank cleanup to nbd_clear_bdrvstate()
- refactor nbd_open() so that all failure paths except for yank-register goes through nbd_clear_bdrvstate()
--- block/nbd.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-)
block/nbd.c +18 -18
@@ -152,8 +152,12 @@ static void nbd_co_establish_connection_cancel(BlockDriverState *bs,static int nbd_client_handshake (BlockDriverState *bs,Error **errp);static void nbd_yank (void *opaque); -static void nbd_clear_bdrvstate (BDRVNBDState *s) +static void nbd_clear_bdrvstate (BlockDriverState *bs) { +BDRVNBDState *s = (BDRVNBDState *)bs->opaque; + +yank_unregister_instance (BLOCKDEV_YANK_INSTANCE (bs->node_name)); +object_unref (OBJECT (s->tlscreds));qapi_free_SocketAddress (s->saddr); s->saddr =NULL ;
@@ -2275,9 +2279,6 @@ static int nbd_process_options(BlockDriverState *bs, QDict *options, ret =0 ; error: -if (ret <0 ) { -nbd_clear_bdrvstate (s); - }qemu_opts_del (opts);return ret; }
@@ -2288,11 +2289,6 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,int ret;BDRVNBDState *s = (BDRVNBDState *)bs->opaque; - ret =nbd_process_options (bs, options, errp); -if (ret <0 ) { -return ret; - } - s->bs = bs;qemu_co_mutex_init (&s->send_mutex);qemu_co_queue_init (&s->free_sema);
@@ -2301,20 +2297,23 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,return -EEXIST ; } + ret =nbd_process_options (bs, options, errp); +if (ret <0 ) { + goto fail; + } +/* * establish TCP connection, return error if it fails * TODO: Configurable retry-until-timeout behaviour. */ if (nbd_establish_connection (bs, s->saddr, errp) <0 ) { -yank_unregister_instance (BLOCKDEV_YANK_INSTANCE (bs->node_name)); -return -ECONNREFUSED ; + ret = -ECONNREFUSED ; + goto fail; } ret =nbd_client_handshake (bs, errp);if (ret <0 ) { -yank_unregister_instance (BLOCKDEV_YANK_INSTANCE (bs->node_name)); -nbd_clear_bdrvstate (s); -return ret; + goto fail; }/* successfully connected */ s->state =NBD_CLIENT_CONNECTED ;
@@ -2326,6 +2325,10 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,aio_co_schedule (bdrv_get_aio_context (bs), s->connection_co);return 0 ; + +fail: +nbd_clear_bdrvstate (bs); +return ret; }static int nbd_co_flush (BlockDriverState *bs)
@@ -2369,11 +2372,8 @@ static void nbd_refresh_limits(BlockDriverState *bs, Error **errp)static void nbd_close (BlockDriverState *bs) { -BDRVNBDState *s = bs->opaque; -nbd_client_close (bs); -yank_unregister_instance (BLOCKDEV_YANK_INSTANCE (bs->node_name)); -nbd_clear_bdrvstate (s); +nbd_clear_bdrvstate (bs); }/*
Signature · 1 line
2.29.2
PATCH v4 26/32 nbd/client-connection: return only one io channel
In reply to Vladimir Sementsov-Ogievskiyblock/nbd doesn't need underlying sioc channel anymore. So, we can update nbd/client-connection interface to return only one top-most io channel, which is more straight forward.
--- include/block/nbd.h | 4 ++-- block/nbd.c | 13 ++----------- nbd/client-connection.c | 33 +++++++++++++++++++++++++-------- 3 files changed, 29 insertions(+), 21 deletions(-)
include/block/nbd.h +2 -2
@@ -418,9 +418,9 @@ NBDClientConnection *nbd_client_connection_new(const SocketAddress *saddr, QCryptoTLSCreds *tlscreds);void nbd_client_connection_release (NBDClientConnection *conn); -QIOChannelSocket *coroutine_fn +QIOChannel *coroutine_fnnbd_co_establish_connection (NBDClientConnection *conn, NBDExportInfo *info, - QIOChannel **ioc, Error **errp); + Error **errp); void coroutine_fn nbd_co_establish_connection_cancel(NBDClientConnection *conn);
block/nbd.c +2 -11
@@ -360,7 +360,6 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) {int ret;AioContext *aio_context =bdrv_get_aio_context (s->bs); -QIOChannelSocket *sioc;if (!nbd_client_connecting (s)) {return ;
@@ -399,20 +398,12 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) s->ioc =NULL ; } - sioc =nbd_co_establish_connection (s->conn, &s->info, &s->ioc,NULL ); -if (!sioc) { + s->ioc =nbd_co_establish_connection (s->conn, &s->info,NULL ); +if (!s->ioc) { ret = -ECONNREFUSED ; goto out; } -if (s->ioc) { -/* sioc is referenced by s->ioc */ -object_unref (OBJECT (sioc)); - }else { - s->ioc =QIO_CHANNEL (sioc); - } - sioc =NULL ; -qio_channel_set_blocking (QIO_CHANNEL (s->ioc), false,NULL );qio_channel_attach_aio_context (QIO_CHANNEL (s->ioc), aio_context);
nbd/client-connection.c +25 -8
@@ -271,15 +271,15 @@ void nbd_client_connection_release(NBDClientConnection *conn)* nbd_receive_export_list() would be zero (see description of NBDExportInfo in * include/block/nbd.h). */ -QIOChannelSocket *coroutine_fn +QIOChannel *coroutine_fnnbd_co_establish_connection (NBDClientConnection *conn, NBDExportInfo *info, - QIOChannel **ioc, Error **errp) + Error **errp) { +QIOChannel *ioc;QemuThread thread;if (conn->do_negotiation) {assert (info); -assert (ioc); } WITH_QEMU_LOCK_GUARD(&conn->mutex) {
@@ -293,10 +293,17 @@ nbd_co_establish_connection(NBDClientConnection *conn, NBDExportInfo *info,if (conn->sioc) {/* Previous attempt finally succeeded in background */ if (conn->do_negotiation) { - *ioc =g_steal_pointer (&conn->ioc); + ioc =g_steal_pointer (&conn->ioc);memcpy (info, &conn->updated_info,sizeof (*info)); } -return g_steal_pointer (&conn->sioc); +if (ioc) { +/* TLS channel now has own reference to parent */ +object_unref (OBJECT (conn->sioc)); + }else { + ioc =QIO_CHANNEL (conn->sioc); + } + conn->sioc =NULL ; +return ioc; } conn->running = true;
@@ -328,11 +335,21 @@ nbd_co_establish_connection(NBDClientConnection *conn, NBDExportInfo *info, }else {error_propagate (errp, conn->err); conn->err =NULL ; -if (conn->sioc && conn->do_negotiation) { - *ioc =g_steal_pointer (&conn->ioc); +if (!conn->sioc) { +return NULL ; + } +if (conn->do_negotiation) { + ioc =g_steal_pointer (&conn->ioc);memcpy (info, &conn->updated_info,sizeof (*info)); } -return g_steal_pointer (&conn->sioc); +if (ioc) { +/* TLS channel now has own reference to parent */ +object_unref (OBJECT (conn->sioc)); + }else { + ioc =QIO_CHANNEL (conn->sioc); + } + conn->sioc =NULL ; +return ioc; } }
Signature · 1 line
2.29.2
PATCH v4 12/32 block/nbd: bs-independent interface for nbd_co_establish_connection()
In reply to Vladimir Sementsov-OgievskiyWe are going to split connection code to a separate file. Now we are ready to give nbd_co_establish_connection() clean and bs-independent interface.
--- block/nbd.c | 50 ++++++++++++++++++++++++++++++++------------------ 1 file changed, 32 insertions(+), 18 deletions(-)
block/nbd.c +32 -18
@@ -129,7 +129,8 @@ typedef struct BDRVNBDState {static void nbd_free_connect_thread (NBDConnectThread *thr);static int nbd_establish_connection (BlockDriverState *bs,SocketAddress *saddr,Error **errp); -static int nbd_co_establish_connection (BlockDriverState *bs,Error **errp); +static coroutine_fn QIOChannelSocket * +nbd_co_establish_connection (NBDConnectThread *thr, Error **errp);static void nbd_co_establish_connection_cancel (BlockDriverState *bs);static int nbd_client_handshake (BlockDriverState *bs,Error **errp);static void nbd_yank (void *opaque);
@@ -415,22 +416,37 @@ static void *connect_thread_func(void *opaque)return NULL ; } -static int coroutine_fn -nbd_co_establish_connection (BlockDriverState *bs,Error **errp) +/* +* Get a new connection in context of @thr: +* if the thread is running, wait for completion +* if the thread already succeeded in the background, and user didn't get the +* result, just return it now +* otherwise the thread is not running, so start a thread and wait for +* completion +*/ +static coroutine_fn QIOChannelSocket * +nbd_co_establish_connection (NBDConnectThread *thr,Error **errp) { +QIOChannelSocket *sioc =NULL ;QemuThread thread; -BDRVNBDState *s = bs->opaque; -NBDConnectThread *thr = s->connect_thread; - -assert (!s->sioc);qemu_mutex_lock (&thr->mutex); +/* +* Don't call nbd_co_establish_connection() in several coroutines in +* parallel. Only one call at once is supported. +*/ +assert (!thr->wait_co); +if (!thr->running) {if (thr->sioc) {/* Previous attempt finally succeeded in background */ - goto out; + sioc =g_steal_pointer (&thr->sioc); +qemu_mutex_unlock (&thr->mutex); + +return sioc; } + thr->running = true;error_free (thr->err); thr->err =NULL ;
@@ -444,13 +460,12 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp)/* * We are going to wait for connect-thread finish, but -* nbd_client_co_drain_begin() can interrupt. +* nbd_co_establish_connection_cancel() can interrupt. */ qemu_coroutine_yield ();qemu_mutex_lock (&thr->mutex); -out:if (thr->running) {/* * The connection attempt was canceled and the coroutine resumed
@@ -462,17 +477,12 @@ out: }else {error_propagate (errp, thr->err); thr->err =NULL ; - s->sioc = thr->sioc; - thr->sioc =NULL ; -if (s->sioc) { -yank_register_function (BLOCKDEV_YANK_INSTANCE (bs->node_name), - nbd_yank, bs); - } + sioc =g_steal_pointer (&thr->sioc); }qemu_mutex_unlock (&thr->mutex); -return s->sioc ?0 :-1 ; +return sioc; }/*
@@ -540,11 +550,15 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) s->ioc =NULL ; } -if (nbd_co_establish_connection (s->bs,NULL ) <0 ) { + s->sioc =nbd_co_establish_connection (s->connect_thread,NULL ); +if (!s->sioc) { ret = -ECONNREFUSED ; goto out; } +yank_register_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, + s->bs); +bdrv_dec_in_flight (s->bs); ret =nbd_client_handshake (s->bs,NULL );
Signature · 1 line
2.29.2
PATCH v4 9/32 block/nbd: BDRVNBDState: drop unused connect_err and connect_status
In reply to Vladimir Sementsov-OgievskiyThese fields are write-only. Drop them.
--- block/nbd.c | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-)
block/nbd.c +2 -10
@@ -121,8 +121,6 @@ typedef struct BDRVNBDState {bool wait_drained_end;int in_flight;NBDClientState state; -int connect_status; -Error *connect_err;bool wait_in_flight;QEMUTimer *reconnect_delay_timer;
@@ -578,7 +576,6 @@ static void nbd_co_establish_connection_cancel(BlockDriverState *bs) static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) {int ret; -Error *local_err =NULL ;if (!nbd_client_connecting (s)) {return ;
@@ -619,14 +616,14 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) s->ioc =NULL ; } -if (nbd_co_establish_connection (s->bs, &local_err) <0 ) { +if (nbd_co_establish_connection (s->bs,NULL ) <0 ) { ret = -ECONNREFUSED ; goto out; }bdrv_dec_in_flight (s->bs); - ret =nbd_client_handshake (s->bs, &local_err); + ret =nbd_client_handshake (s->bs,NULL );if (s->drained) { s->wait_drained_end = true;
@@ -641,11 +638,6 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s)bdrv_inc_in_flight (s->bs); out: - s->connect_status = ret; -error_free (s->connect_err); - s->connect_err =NULL ; -error_propagate (&s->connect_err, local_err); -if (ret >=0 ) {/* successfully connected */ s->state =NBD_CLIENT_CONNECTED ;
Signature · 1 line
2.29.2
PATCH v4 4/32 block/nbd: connect_thread_func(): do qio_channel_set_delay(false)
In reply to Vladimir Sementsov-Ogievskiynbd_open() does it (through nbd_establish_connection()). Actually we lost that call on reconnect path in 1dc4718d849e1a1fe "block/nbd: use non-blocking connect: fix vm hang on connect()" when we have introduced reconnect thread.
--- block/nbd.c | 2 ++ 1 file changed, 2 insertions(+)
block/nbd.c +2 -0
@@ -408,6 +408,8 @@ static void *connect_thread_func(void *opaque) thr->sioc =NULL ; } +qio_channel_set_delay (QIO_CHANNEL (thr->sioc), false); +qemu_mutex_lock (&thr->mutex);switch (thr->state) {
Signature · 1 line
2.29.2
PATCH v4 24/32 block/nbd: don't touch s->sioc in nbd_teardown_connection()
In reply to Vladimir Sementsov-OgievskiyNegotiation during reconnect is now done in a thread, and s->sioc is not available during negotiation. Negotiation in thread will be cancelled by nbd_client_connection_release() called from nbd_clear_bdrvstate(). So, we don't need this code chunk anymore.
--- block/nbd.c | 4 ---- 1 file changed, 4 deletions(-)
block/nbd.c +0 -4
@@ -280,10 +280,6 @@ static void nbd_teardown_connection(BlockDriverState *bs)if (s->ioc) {/* finish any pending coroutines */ qio_channel_shutdown (s->ioc,QIO_CHANNEL_SHUTDOWN_BOTH ,NULL ); - }else if (s->sioc) { -/* abort negotiation */ -qio_channel_shutdown (QIO_CHANNEL (s->sioc),QIO_CHANNEL_SHUTDOWN_BOTH , -NULL ); } s->state =NBD_CLIENT_QUIT ;
Signature · 1 line
2.29.2
PATCH v4 20/32 nbd/client-connection: implement connection retry
In reply to Vladimir Sementsov-OgievskiyAdd an option for a thread to retry connection until succeeds. We'll use nbd/client-connection both for reconnect and for initial connection in nbd_open(), so we need a possibility to use same NBDClientConnection instance to connect once in nbd_open() and then use retry semantics for reconnect.
--- include/block/nbd.h | 2 ++ nbd/client-connection.c | 56 +++++++++++++++++++++++++++++++---------- 2 files changed, 45 insertions(+), 13 deletions(-)
include/block/nbd.h +2 -0
@@ -409,6 +409,8 @@ const char *nbd_err_lookup(int err);/* nbd/client-connection.c */ typedef struct NBDClientConnection NBDClientConnection ; +void nbd_client_connection_enable_retry (NBDClientConnection *conn); + NBDClientConnection *nbd_client_connection_new(const SocketAddress *saddr, bool do_negotiation, const char *export_name,
nbd/client-connection.c +43 -13
78 lines not on this page · raw message
Signature · 1 line
2.29.2
PATCH v4 11/32 block/nbd: drop thr->state
In reply to Vladimir Sementsov-OgievskiyWe don't need all these states. The code refactored to use two boolean variables looks simpler.
While moving the comment in nbd_co_establish_connection() rework it to give better information. Also, we are going to move the connection code to separate file and mentioning drained section would be confusing.
Improve also the comment in NBDConnectThread, while dropping removed state names from it.
--- block/nbd.c | 139 +++++++++++++++++----------------------------------- 1 file changed, 44 insertions(+), 95 deletions(-)
block/nbd.c +44 -95
@@ -66,38 +66,24 @@ typedef enum NBDClientState {NBD_CLIENT_QUIT } NBDClientState; -typedef enum NBDConnectThreadState { -/* No thread, no pending results */ -CONNECT_THREAD_NONE , - -/* Thread is running, no results for now */ -CONNECT_THREAD_RUNNING , - -/* -* Thread is running, but requestor exited. Thread should close -* the new socket and free the connect state on exit. -*/ -CONNECT_THREAD_RUNNING_DETACHED , - -/* Thread finished, results are stored in a state */ -CONNECT_THREAD_FAIL , -CONNECT_THREAD_SUCCESS -}NBDConnectThreadState ; - typedef struct NBDConnectThread { /* Initialization constants */ SocketAddress *saddr; /* address to connect to */ + QemuMutex mutex; + /* - * Result of last attempt. Valid in FAIL and SUCCESS states. - * If you want to steal error, don't forget to set pointer to NULL. + * @sioc and @err present a result of connection attempt. + * While running is true, they are used only by thread, mutex locking is not + * needed. When thread is finished nbd_co_establish_connection steal these + * pointers under mutex. */ QIOChannelSocket *sioc; Error *err; - QemuMutex mutex; - /* All further fields are protected by mutex */ - NBDConnectThreadState state; /* current state of the thread */ + /* All further fields are accessed only under mutex */ + bool running; /* thread is running now */ + bool detached; /* thread is detached and should cleanup the state */ /* * wait_co: if non-NULL, which coroutine to wake in
@@ -152,17 +138,19 @@ static void nbd_clear_bdrvstate(BlockDriverState *bs) {BDRVNBDState *s = (BDRVNBDState *)bs->opaque;NBDConnectThread *thr = s->connect_thread; -bool thr_running; +bool do_free = false;qemu_mutex_lock (&thr->mutex); - thr_running = thr->state ==CONNECT_THREAD_RUNNING ; -if (thr_running) { - thr->state =CONNECT_THREAD_RUNNING_DETACHED ; +assert (!thr->detached); +if (thr->running) { + thr->detached = true; + }else { + do_free = true; }qemu_mutex_unlock (&thr->mutex);/* the runaway thread will clean up itself */ -if (!thr_running) { +if (do_free) {nbd_free_connect_thread (thr); }
@@ -374,7 +362,6 @@ static void nbd_init_connect_thread(BDRVNBDState *s) *s->connect_thread = (NBDConnectThread ) { .saddr =QAPI_CLONE (SocketAddress, s->saddr), - .state =CONNECT_THREAD_NONE , };qemu_mutex_init (&s->connect_thread->mutex);
@@ -395,7 +382,7 @@ static void *connect_thread_func(void *opaque) {NBDConnectThread *thr = opaque;int ret; -bool do_free = false; +bool do_free; thr->sioc =qio_channel_socket_new ();
@@ -411,20 +398,13 @@ static void *connect_thread_func(void *opaque)qemu_mutex_lock (&thr->mutex); -switch (thr->state) { -case CONNECT_THREAD_RUNNING : - thr->state = ret <0 ?CONNECT_THREAD_FAIL :CONNECT_THREAD_SUCCESS ; -if (thr->wait_co) { -aio_co_wake (thr->wait_co); - thr->wait_co =NULL ; - } -break ; -case CONNECT_THREAD_RUNNING_DETACHED : - do_free = true; -break ; -default : -abort (); +assert (thr->running); + thr->running = false; +if (thr->wait_co) { +aio_co_wake (thr->wait_co); + thr->wait_co =NULL ; } + do_free = thr->detached;qemu_mutex_unlock (&thr->mutex);
@@ -438,36 +418,24 @@ static void *connect_thread_func(void *opaque) static int coroutine_fnnbd_co_establish_connection (BlockDriverState *bs,Error **errp) { -int ret;QemuThread thread;BDRVNBDState *s = bs->opaque;NBDConnectThread *thr = s->connect_thread; +assert (!s->sioc); +qemu_mutex_lock (&thr->mutex); -switch (thr->state) { -case CONNECT_THREAD_FAIL : -case CONNECT_THREAD_NONE : +if (!thr->running) { +if (thr->sioc) { +/* Previous attempt finally succeeded in background */ + goto out; + } + thr->running = true;error_free (thr->err); thr->err =NULL ; - thr->state =CONNECT_THREAD_RUNNING ;qemu_thread_create (&thread,"nbd-connect" , connect_thread_func, thr,QEMU_THREAD_DETACHED ); -break ; -case CONNECT_THREAD_SUCCESS : -/* Previous attempt finally succeeded in background */ - thr->state =CONNECT_THREAD_NONE ; - s->sioc = thr->sioc; - thr->sioc =NULL ; -yank_register_function (BLOCKDEV_YANK_INSTANCE (bs->node_name), - nbd_yank, bs); -qemu_mutex_unlock (&thr->mutex); -return 0 ; -case CONNECT_THREAD_RUNNING : -/* Already running, will wait */ -break ; -default : -abort (); } thr->wait_co =qemu_coroutine_self ();
@@ -482,10 +450,16 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp)qemu_mutex_lock (&thr->mutex); -switch (thr->state) { -case CONNECT_THREAD_SUCCESS : -case CONNECT_THREAD_FAIL : - thr->state =CONNECT_THREAD_NONE ; +out: +if (thr->running) { +/* +* The connection attempt was canceled and the coroutine resumed +* before the connection thread finished its job. Report the +* attempt as failed, but leave the connection thread running, +* to reuse it for the next connection attempt. +*/ +error_setg (errp,"Connection attempt cancelled by other operation" ); + }else {error_propagate (errp, thr->err); thr->err =NULL ; s->sioc = thr->sioc;
@@ -494,33 +468,11 @@ nbd_co_establish_connection(BlockDriverState *bs, Error **errp)yank_register_function (BLOCKDEV_YANK_INSTANCE (bs->node_name), nbd_yank, bs); } - ret = (s->sioc ?0 :-1 ); -break ; -case CONNECT_THREAD_RUNNING : -case CONNECT_THREAD_RUNNING_DETACHED : -/* -* Obviously, drained section wants to start. Report the attempt as -* failed. Still connect thread is executing in background, and its -* result may be used for next connection attempt. -*/ - ret =-1 ; -error_setg (errp,"Connection attempt cancelled by other operation" ); -break ; - -case CONNECT_THREAD_NONE : -/* -* Impossible. We've seen this thread running. So it should be -* running or at least give some results. -*/ -abort (); - -default : -abort (); }qemu_mutex_unlock (&thr->mutex); -return ret; +return s->sioc ?0 :-1 ; }/*
@@ -532,14 +484,11 @@ static void nbd_co_establish_connection_cancel(BlockDriverState *bs) {BDRVNBDState *s = bs->opaque;NBDConnectThread *thr = s->connect_thread; -Coroutine *wait_co =NULL ; +Coroutine *wait_co;qemu_mutex_lock (&thr->mutex); -if (thr->state ==CONNECT_THREAD_RUNNING ) { -/* We can cancel only in running state, when bh is not yet scheduled */ - wait_co =g_steal_pointer (&thr->wait_co); - } + wait_co =g_steal_pointer (&thr->wait_co);qemu_mutex_unlock (&thr->mutex);
Signature · 1 line
2.29.2
PATCH v4 5/32 qemu-sockets: introduce socket_address_parse_named_fd()
In reply to Vladimir Sementsov-OgievskiyAdd function that transforms named fd inside SocketAddress structure into number representation. This way it may be then used in a context where current monitor is not available.
--- include/qemu/sockets.h | 14 ++++++++++++++ util/qemu-sockets.c | 19 +++++++++++++++++++ 2 files changed, 33 insertions(+)
include/qemu/sockets.h +14 -0
@@ -111,4 +111,18 @@ SocketAddress *socket_remote_address(int fd, Error **errp);*/ SocketAddress *socket_address_flatten (SocketAddressLegacy *addr); +/** +* socket_address_parse_named_fd: +* +* Modify @addr, replacing named fd by corresponding number. +* +* Parsing named fd (by sockget_get_fd) is not possible in context where +* current monitor is not available. So, SocketAddress user may first call +* socket_parse_named_fd() to parse named fd in advance, and then pass @addr to +* the context where monitor is not available. +* +* Return 0 on success. +*/ +int socket_address_parse_named_fd (SocketAddress *addr,Error **errp); +#endif /* QEMU_SOCKETS_H */
util/qemu-sockets.c +19 -0
@@ -1141,6 +1141,25 @@ static int socket_get_fd(const char *fdstr, Error **errp)return fd; } +int socket_address_parse_named_fd (SocketAddress *addr,Error **errp) +{ +int fd; + +if (addr->type !=SOCKET_ADDRESS_TYPE_FD ) { +return 0 ; + } + + fd =socket_get_fd (addr->u.fd.str, errp); +if (fd <0 ) { +return fd; + } + +g_free (addr->u.fd.str); + addr->u.fd.str =g_strdup_printf ("%d" , fd); + +return 0 ; +} +int socket_connect (SocketAddress *addr,Error **errp) {int fd;
Signature · 1 line
2.29.2
PATCH v4 25/32 block/nbd: drop BDRVNBDState::sioc
In reply to Vladimir Sementsov-OgievskiyCurrently sioc pointer is used just to pass from socket-connection to nbd negotiation. Drop the field, and use local variables instead. With next commit we'll update nbd/client-connection.c to behave appropriately (return only top-most ioc, not two channels).
--- block/nbd.c | 98 ++++++++++++++++++++++++++--------------------------- 1 file changed, 48 insertions(+), 50 deletions(-)
block/nbd.c +48 -50
@@ -67,8 +67,7 @@ typedef enum NBDClientState { } NBDClientState; typedef struct BDRVNBDState { - QIOChannelSocket *sioc; /* The master data channel */ - QIOChannel *ioc; /* The current I/O channel which may differ (eg TLS) */ + QIOChannel *ioc; /* The current I/O channel */ NBDExportInfo info; CoMutex send_mutex;
@@ -100,9 +99,11 @@ typedef struct BDRVNBDState {NBDClientConnection *conn; } BDRVNBDState; -static int nbd_establish_connection (BlockDriverState *bs,SocketAddress *saddr, -Error **errp); -static int nbd_client_handshake (BlockDriverState *bs,Error **errp); +static QIOChannelSocket *nbd_establish_connection (BlockDriverState *bs, +SocketAddress *saddr, +Error **errp); +static int nbd_client_handshake (BlockDriverState *bs,QIOChannelSocket *sioc, +Error **errp);static void nbd_yank (void *opaque);static void nbd_clear_bdrvstate (BlockDriverState *bs)
@@ -359,6 +360,7 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) {int ret;AioContext *aio_context =bdrv_get_aio_context (s->bs); +QIOChannelSocket *sioc;if (!nbd_client_connecting (s)) {return ;
@@ -393,27 +395,26 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s)qio_channel_detach_aio_context (QIO_CHANNEL (s->ioc));yank_unregister_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, s->bs); -object_unref (OBJECT (s->sioc)); - s->sioc =NULL ;object_unref (OBJECT (s->ioc)); s->ioc =NULL ; } - s->sioc =nbd_co_establish_connection (s->conn, &s->info, &s->ioc,NULL ); -if (!s->sioc) { + sioc =nbd_co_establish_connection (s->conn, &s->info, &s->ioc,NULL ); +if (!sioc) { ret = -ECONNREFUSED ; goto out; } -qio_channel_set_blocking (QIO_CHANNEL (s->sioc), false,NULL ); -qio_channel_attach_aio_context (QIO_CHANNEL (s->sioc), aio_context);if (s->ioc) { -qio_channel_set_blocking (QIO_CHANNEL (s->ioc), false,NULL ); -qio_channel_attach_aio_context (QIO_CHANNEL (s->ioc), aio_context); +/* sioc is referenced by s->ioc */ +object_unref (OBJECT (sioc)); }else { - s->ioc =QIO_CHANNEL (s->sioc); -object_ref (OBJECT (s->ioc)); + s->ioc =QIO_CHANNEL (sioc); } + sioc =NULL ; + +qio_channel_set_blocking (QIO_CHANNEL (s->ioc), false,NULL ); +qio_channel_attach_aio_context (QIO_CHANNEL (s->ioc), aio_context);yank_register_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, s->bs);
@@ -430,8 +431,6 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s)yank_unregister_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, s->bs); -object_unref (OBJECT (s->sioc)); - s->sioc =NULL ;object_unref (OBJECT (s->ioc)); s->ioc =NULL ;
@@ -566,8 +565,6 @@ static coroutine_fn void nbd_connection_entry(void *opaque)qio_channel_detach_aio_context (QIO_CHANNEL (s->ioc));yank_unregister_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, s->bs); -object_unref (OBJECT (s->sioc)); - s->sioc =NULL ;object_unref (OBJECT (s->ioc)); s->ioc =NULL ; }
@@ -1566,7 +1563,7 @@ static void nbd_yank(void *opaque)BDRVNBDState *s = (BDRVNBDState *)bs->opaque;qatomic_store_release (&s->state,NBD_CLIENT_QUIT ); -qio_channel_shutdown (QIO_CHANNEL (s->sioc),QIO_CHANNEL_SHUTDOWN_BOTH ,NULL ); +qio_channel_shutdown (QIO_CHANNEL (s->ioc),QIO_CHANNEL_SHUTDOWN_BOTH ,NULL ); }static void nbd_client_close (BlockDriverState *bs)
@@ -1581,57 +1578,64 @@ static void nbd_client_close(BlockDriverState *bs)nbd_teardown_connection (bs); } -static int nbd_establish_connection (BlockDriverState *bs, -SocketAddress *saddr, -Error **errp) +static QIOChannelSocket *nbd_establish_connection (BlockDriverState *bs, +SocketAddress *saddr, +Error **errp) {ERRP_GUARD (); -BDRVNBDState *s = (BDRVNBDState *)bs->opaque; +QIOChannelSocket *sioc; - s->sioc =qio_channel_socket_new (); -qio_channel_set_name (QIO_CHANNEL (s->sioc),"nbd-client" ); + sioc =qio_channel_socket_new (); +qio_channel_set_name (QIO_CHANNEL (sioc),"nbd-client" ); -qio_channel_socket_connect_sync (s->sioc, saddr, errp); +qio_channel_socket_connect_sync (sioc, saddr, errp);if (*errp) { -object_unref (OBJECT (s->sioc)); - s->sioc =NULL ; -return -1 ; +object_unref (OBJECT (sioc)); +return NULL ; }yank_register_function (BLOCKDEV_YANK_INSTANCE (bs->node_name), nbd_yank, bs); -qio_channel_set_delay (QIO_CHANNEL (s->sioc), false); +qio_channel_set_delay (QIO_CHANNEL (sioc), false); -return 0 ; +return sioc; } -/* nbd_client_handshake takes ownership on s->sioc. On failure it's unref'ed. */ -static int nbd_client_handshake (BlockDriverState *bs,Error **errp) +/* nbd_client_handshake takes ownership on sioc. */ +static int nbd_client_handshake (BlockDriverState *bs,QIOChannelSocket *sioc, +Error **errp) {BDRVNBDState *s = (BDRVNBDState *)bs->opaque;AioContext *aio_context =bdrv_get_aio_context (bs);int ret;trace_nbd_client_handshake (s->export); -qio_channel_set_blocking (QIO_CHANNEL (s->sioc), false,NULL ); -qio_channel_attach_aio_context (QIO_CHANNEL (s->sioc), aio_context); +qio_channel_set_blocking (QIO_CHANNEL (sioc), false,NULL ); +qio_channel_attach_aio_context (QIO_CHANNEL (sioc), aio_context); s->info.request_sizes = true; s->info.structured_reply = true; s->info.base_allocation = true; s->info.x_dirty_bitmap =g_strdup (s->x_dirty_bitmap); s->info.name =g_strdup (s->export ?:"" ); - ret =nbd_receive_negotiate (aio_context,QIO_CHANNEL (s->sioc), s->tlscreds, + ret =nbd_receive_negotiate (aio_context,QIO_CHANNEL (sioc), s->tlscreds, s->hostname, &s->ioc, &s->info, errp);g_free (s->info.x_dirty_bitmap);g_free (s->info.name);if (ret <0 ) {yank_unregister_function (BLOCKDEV_YANK_INSTANCE (bs->node_name), nbd_yank, bs); -object_unref (OBJECT (s->sioc)); - s->sioc =NULL ; +object_unref (OBJECT (sioc));return ret; } +if (s->ioc) { +/* sioc is referenced by s->ioc */ +object_unref (OBJECT (sioc)); + }else { + s->ioc =QIO_CHANNEL (sioc); + } + sioc =NULL ; + ret =nbd_handle_updated_info (bs, errp);if (ret <0 ) {/*
@@ -1640,23 +1644,15 @@ static int nbd_client_handshake(BlockDriverState *bs, Error **errp)*/ NBDRequest request = { .type =NBD_CMD_DISC }; -nbd_send_request (s->ioc ?:QIO_CHANNEL (s->sioc), &request); +nbd_send_request (s->ioc, &request);yank_unregister_function (BLOCKDEV_YANK_INSTANCE (bs->node_name), nbd_yank, bs); -object_unref (OBJECT (s->sioc)); - s->sioc =NULL ;object_unref (OBJECT (s->ioc)); s->ioc =NULL ; -return ret; } -if (!s->ioc) { - s->ioc =QIO_CHANNEL (s->sioc); -object_ref (OBJECT (s->ioc)); - } -return 0 ; }
@@ -2048,6 +2044,7 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags, {int ret;BDRVNBDState *s = (BDRVNBDState *)bs->opaque; +QIOChannelSocket *sioc; s->bs = bs;qemu_co_mutex_init (&s->send_mutex);
@@ -2069,12 +2066,13 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,* establish TCP connection, return error if it fails * TODO: Configurable retry-until-timeout behaviour. */ -if (nbd_establish_connection (bs, s->saddr, errp) <0 ) { + sioc =nbd_establish_connection (bs, s->saddr, errp); +if (!sioc) { ret = -ECONNREFUSED ; goto fail; } - ret =nbd_client_handshake (bs, errp); + ret =nbd_client_handshake (bs, sioc, errp);if (ret <0 ) { goto fail; }
Signature · 1 line
2.29.2
PATCH v4 13/32 block/nbd: make nbd_co_establish_connection_cancel() bs-independent
In reply to Vladimir Sementsov-Ogievskiynbd_co_establish_connection_cancel() actually needs only pointer to NBDConnectThread. So, make it clean.
--- block/nbd.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)
block/nbd.c +9 -8
@@ -131,7 +131,7 @@ static int nbd_establish_connection(BlockDriverState *bs, SocketAddress *saddr, Error **errp); static coroutine_fn QIOChannelSocket *nbd_co_establish_connection (NBDConnectThread *thr, Error **errp); -static void nbd_co_establish_connection_cancel (BlockDriverState *bs); +static void nbd_co_establish_connection_cancel (NBDConnectThread *thr);static int nbd_client_handshake (BlockDriverState *bs,Error **errp);static void nbd_yank (void *opaque);
@@ -294,7 +294,7 @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs) s->drained = true;qemu_co_sleep_wake (&s->reconnect_sleep); -nbd_co_establish_connection_cancel (bs); +nbd_co_establish_connection_cancel (s->connect_thread);reconnect_delay_timer_del (s);
@@ -332,7 +332,7 @@ static void nbd_teardown_connection(BlockDriverState *bs) s->state =NBD_CLIENT_QUIT ;if (s->connection_co) {qemu_co_sleep_wake (&s->reconnect_sleep); -nbd_co_establish_connection_cancel (bs); +nbd_co_establish_connection_cancel (s->connect_thread); }if (qemu_in_coroutine ()) { s->teardown_co =qemu_coroutine_self ();
@@ -487,13 +487,14 @@ nbd_co_establish_connection(NBDConnectThread *thr, Error **errp)/* * nbd_co_establish_connection_cancel -* Cancel nbd_co_establish_connection asynchronously: it will finish soon, to -* allow drained section to begin. +* Cancel nbd_co_establish_connection() asynchronously. +* +* Note that this function neither directly stops the thread nor closes the +* socket, but rather safely wakes nbd_co_establish_connection() which is +* sleeping in yield() */ -static void nbd_co_establish_connection_cancel (BlockDriverState *bs) +static void nbd_co_establish_connection_cancel (NBDConnectThread *thr) { -BDRVNBDState *s = bs->opaque; -NBDConnectThread *thr = s->connect_thread;Coroutine *wait_co;qemu_mutex_lock (&thr->mutex);
Signature · 1 line
2.29.2
PATCH v4 17/32 nbd: move connection code from block/nbd to nbd/client-connection
In reply to Vladimir Sementsov-OgievskiyWe now have bs-independent connection API, which consists of four functions:
nbd_client_connection_new()
nbd_client_connection_release()
nbd_co_establish_connection()
nbd_co_establish_connection_cancel()
Move them to a separate file together with NBDClientConnection structure which becomes private to the new API.
--- include/block/nbd.h | 11 ++ block/nbd.c | 206 ----------------------------------- nbd/client-connection.c | 231 ++++++++++++++++++++++++++++++++++++++++ nbd/meson.build | 1 + 4 files changed, 243 insertions(+), 206 deletions(-) create mode 100644 nbd/client-connection.c
include/block/nbd.h +11 -0
@@ -406,4 +406,15 @@ const char *nbd_info_lookup(uint16_t info);const char *nbd_cmd_lookup (uint16_t info);const char *nbd_err_lookup (int err); +/* nbd/client-connection.c */ +typedef struct NBDClientConnection NBDClientConnection ; + +NBDClientConnection *nbd_client_connection_new (const SocketAddress *saddr); +void nbd_client_connection_release (NBDClientConnection *conn); + +QIOChannelSocket *coroutine_fn +nbd_co_establish_connection (NBDClientConnection *conn, Error **errp); + +void coroutine_fn nbd_co_establish_connection_cancel(NBDClientConnection *conn); +#endif
block/nbd.c +0 -206
226 lines not on this page · raw message
nbd/client-connection.c new file +231 -0
231 lines not on this page · raw message
nbd/meson.build +1 -0
@@ -1,5 +1,6 @@ block_ss.add(files( 'client.c', + 'client-connection.c', 'common.c', )) blockdev_ss.add(files(
Signature · 1 line
2.29.2
PATCH v4 27/32 block-coroutine-wrapper: allow non bdrv_ prefix
In reply to Vladimir Sementsov-OgievskiyWe are going to reuse the script to generate a nbd_ function in further commit. Prepare the script now.
--- scripts/block-coroutine-wrapper.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
scripts/block-coroutine-wrapper.py +4 -3
@@ -98,12 +98,13 @@ def snake_to_camel(func_name: str) -> str: def gen_wrapper(func: FuncDecl) -> str: - assert func.name.startswith('bdrv_') - assert not func.name.startswith('bdrv_co_') + assert not '_co_' in func.name assert func.return_type == 'int' assert func.args[0].type in ['BlockDriverState *', 'BdrvChild *'] - name = 'bdrv_co_' + func.name[5:] + subsystem, subname = func.name.split('_', 1) + + name = f'{subsystem}_co_{subname}' bs = 'bs' if func.args[0].type == 'BlockDriverState *' else 'child->bs' struct_name = snake_to_camel(name)
Signature · 1 line
2.29.2
PATCH v4 18/32 nbd/client-connection: use QEMU_LOCK_GUARD
In reply to Vladimir Sementsov-OgievskiyWe don't update connect_thread_func() to use QEMU_LOCK_GUARD, as it will get more complex critical sections logic in further commit, where QEMU_LOCK_GUARD doesn't help.
--- nbd/client-connection.c | 99 +++++++++++++++++++---------------------- 1 file changed, 45 insertions(+), 54 deletions(-)
nbd/client-connection.c +45 -54
@@ -124,14 +124,14 @@ void nbd_client_connection_release(NBDClientConnection *conn)return ; } -qemu_mutex_lock (&conn->mutex); -assert (!conn->detached); -if (conn->running) { - conn->detached = true; - }else { - do_free = true; + WITH_QEMU_LOCK_GUARD(&conn->mutex) { +assert (!conn->detached); +if (conn->running) { + conn->detached = true; + }else { + do_free = true; + } } -qemu_mutex_unlock (&conn->mutex);if (do_free) {nbd_client_connection_do_free (conn);
@@ -149,62 +149,55 @@ void nbd_client_connection_release(NBDClientConnection *conn) QIOChannelSocket *coroutine_fn nbd_co_establish_connection(NBDClientConnection *conn, Error **errp) { -QIOChannelSocket *sioc =NULL ;QemuThread thread; -qemu_mutex_lock (&conn->mutex); - -/* -* Don't call nbd_co_establish_connection() in several coroutines in -* parallel. Only one call at once is supported. -*/ -assert (!conn->wait_co); - -if (!conn->running) { -if (conn->sioc) { -/* Previous attempt finally succeeded in background */ - sioc =g_steal_pointer (&conn->sioc); -qemu_mutex_unlock (&conn->mutex); - -return sioc; + WITH_QEMU_LOCK_GUARD(&conn->mutex) { +/* +* Don't call nbd_co_establish_connection() in several coroutines in +* parallel. Only one call at once is supported. +*/ +assert (!conn->wait_co); + +if (!conn->running) { +if (conn->sioc) { +/* Previous attempt finally succeeded in background */ +return g_steal_pointer (&conn->sioc); + } + + conn->running = true; +error_free (conn->err); + conn->err =NULL ; +qemu_thread_create (&thread,"nbd-connect" , + connect_thread_func, conn,QEMU_THREAD_DETACHED ); } - conn->running = true; -error_free (conn->err); - conn->err =NULL ; -qemu_thread_create (&thread,"nbd-connect" , - connect_thread_func, conn,QEMU_THREAD_DETACHED ); + conn->wait_co =qemu_coroutine_self (); } - conn->wait_co =qemu_coroutine_self (); - -qemu_mutex_unlock (&conn->mutex); -/* * We are going to wait for connect-thread finish, but * nbd_co_establish_connection_cancel() can interrupt. */ qemu_coroutine_yield (); -qemu_mutex_lock (&conn->mutex); - -if (conn->running) { -/* -* The connection attempt was canceled and the coroutine resumed -* before the connection thread finished its job. Report the -* attempt as failed, but leave the connection thread running, -* to reuse it for the next connection attempt. -*/ -error_setg (errp,"Connection attempt cancelled by other operation" ); - }else { -error_propagate (errp, conn->err); - conn->err =NULL ; - sioc =g_steal_pointer (&conn->sioc); + WITH_QEMU_LOCK_GUARD(&conn->mutex) { +if (conn->running) { +/* +* The connection attempt was canceled and the coroutine resumed +* before the connection thread finished its job. Report the +* attempt as failed, but leave the connection thread running, +* to reuse it for the next connection attempt. +*/ +error_setg (errp,"Connection attempt cancelled by other operation" ); +return NULL ; + }else { +error_propagate (errp, conn->err); + conn->err =NULL ; +return g_steal_pointer (&conn->sioc); + } } -qemu_mutex_unlock (&conn->mutex); - -return sioc; +abort ();/* unreachable */ }/*
@@ -219,11 +212,9 @@ void nbd_co_establish_connection_cancel(NBDClientConnection *conn) {Coroutine *wait_co; -qemu_mutex_lock (&conn->mutex); - - wait_co =g_steal_pointer (&conn->wait_co); - -qemu_mutex_unlock (&conn->mutex); + WITH_QEMU_LOCK_GUARD(&conn->mutex) { + wait_co =g_steal_pointer (&conn->wait_co); + }if (wait_co) {aio_co_wake (wait_co);
Signature · 1 line
2.29.2
PATCH v4 15/32 block/nbd: introduce nbd_client_connection_new()
In reply to Vladimir Sementsov-OgievskiyThis is a step of creating bs-independent nbd connection interface.
--- block/nbd.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)
block/nbd.c +9 -6
@@ -357,15 +357,18 @@ static bool nbd_client_connecting_wait(BDRVNBDState *s)return qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTING_WAIT ; } -static void nbd_init_connect_thread (BDRVNBDState *s) +static NBDClientConnection * +nbd_client_connection_new (const SocketAddress *saddr) { - s->conn =g_new (NBDClientConnection,1 ); +NBDClientConnection *conn =g_new (NBDClientConnection,1 ); - *s->conn = (NBDClientConnection ) { - .saddr =QAPI_CLONE (SocketAddress, s->saddr), + *conn = (NBDClientConnection ) { + .saddr =QAPI_CLONE (SocketAddress, saddr), }; -qemu_mutex_init (&s->conn->mutex); +qemu_mutex_init (&conn->mutex); + +return conn; }static void nbd_free_connect_thread (NBDClientConnection *conn)
@@ -2229,7 +2232,7 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } -nbd_init_connect_thread (s); + s->conn =nbd_client_connection_new (s->saddr);/* * establish TCP connection, return error if it fails
Signature · 1 line
2.29.2
PATCH v4 30/32 block/nbd: reuse nbd_co_do_establish_connection() in nbd_open()
In reply to Vladimir Sementsov-OgievskiyThe only last step we need to reuse the function is coroutine-wrapper. nbd_open() may be called from non-coroutine context. So, generate the wrapper and use it.
--- block/coroutines.h | 6 +++ block/nbd.c | 103 +++------------------------------------------ 2 files changed, 11 insertions(+), 98 deletions(-)
block/coroutines.h +6 -0
@@ -66,4 +66,10 @@ int coroutine_fn bdrv_co_readv_vmstate(BlockDriverState *bs, int coroutine_fn bdrv_co_writev_vmstate(BlockDriverState *bs,QEMUIOVector *qiov,int64_t pos); +int generated_co_wrapper +nbd_do_establish_connection (BlockDriverState *bs, Error **errp); +int coroutine_fn +nbd_co_do_establish_connection (BlockDriverState *bs, Error **errp); + +#endif /* BLOCK_COROUTINES_INT_H */
block/nbd.c +5 -98
142 lines not on this page · raw message
Signature · 1 line
2.29.2
PATCH v4 19/32 nbd/client-connection: add possibility of negotiation
In reply to Vladimir Sementsov-OgievskiyAdd arguments and logic to support nbd negotiation in the same thread after successful connection.
--- include/block/nbd.h | 9 +++- block/nbd.c | 4 +- nbd/client-connection.c | 105 ++++++++++++++++++++++++++++++++++++++-- 3 files changed, 109 insertions(+), 9 deletions(-)
include/block/nbd.h +7 -2
@@ -409,11 +409,16 @@ const char *nbd_err_lookup(int err);/* nbd/client-connection.c */ typedef struct NBDClientConnection NBDClientConnection ; -NBDClientConnection *nbd_client_connection_new (const SocketAddress *saddr); +NBDClientConnection *nbd_client_connection_new (const SocketAddress *saddr, +bool do_negotiation, +const char *export_name, +const char *x_dirty_bitmap, +QCryptoTLSCreds *tlscreds);void nbd_client_connection_release (NBDClientConnection *conn); QIOChannelSocket *coroutine_fn -nbd_co_establish_connection (NBDClientConnection *conn, Error **errp); +nbd_co_establish_connection (NBDClientConnection *conn, NBDExportInfo *info, + QIOChannel **ioc, Error **errp); void coroutine_fn nbd_co_establish_connection_cancel(NBDClientConnection *conn);
block/nbd.c +2 -2
@@ -357,7 +357,7 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) s->ioc =NULL ; } - s->sioc =nbd_co_establish_connection (s->conn,NULL ); + s->sioc =nbd_co_establish_connection (s->conn,NULL ,NULL ,NULL );if (!s->sioc) { ret = -ECONNREFUSED ; goto out;
@@ -2035,7 +2035,7 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } - s->conn =nbd_client_connection_new (s->saddr); + s->conn =nbd_client_connection_new (s->saddr, false,NULL ,NULL ,NULL );/* * establish TCP connection, return error if it fails
nbd/client-connection.c +100 -5
173 lines not on this page · raw message
Signature · 1 line
2.29.2
PATCH v4 23/32 block/nbd: use negotiation of NBDClientConnection
In reply to Vladimir Sementsov-OgievskiyNow that we can opt in to negotiation as part of the client connection thread, use that to simplify connection_co. This is another step on the way to moving all reconnect code into NBDClientConnection.
--- block/nbd.c | 44 ++++++++++++++++++++++++++++++-------------- 1 file changed, 30 insertions(+), 14 deletions(-)
block/nbd.c +30 -14
@@ -362,6 +362,7 @@ static int nbd_handle_updated_info(BlockDriverState *bs, Error **errp) static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) {int ret; +AioContext *aio_context =bdrv_get_aio_context (s->bs);if (!nbd_client_connecting (s)) {return ;
@@ -402,30 +403,44 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) s->ioc =NULL ; } - s->sioc =nbd_co_establish_connection (s->conn,NULL ,NULL ,NULL ); + s->sioc =nbd_co_establish_connection (s->conn, &s->info, &s->ioc,NULL );if (!s->sioc) { ret = -ECONNREFUSED ; goto out; } +qio_channel_set_blocking (QIO_CHANNEL (s->sioc), false,NULL ); +qio_channel_attach_aio_context (QIO_CHANNEL (s->sioc), aio_context); +if (s->ioc) { +qio_channel_set_blocking (QIO_CHANNEL (s->ioc), false,NULL ); +qio_channel_attach_aio_context (QIO_CHANNEL (s->ioc), aio_context); + }else { + s->ioc =QIO_CHANNEL (s->sioc); +object_ref (OBJECT (s->ioc)); + } +yank_register_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, s->bs); -bdrv_dec_in_flight (s->bs); + ret =nbd_handle_updated_info (s->bs,NULL ); +if (ret <0 ) { +/* +* We have connected, but must fail for other reasons. +* Send NBD_CMD_DISC as a courtesy to the server. +*/ +NBDRequest request = { .type =NBD_CMD_DISC }; - ret =nbd_client_handshake (s->bs,NULL ); +nbd_send_request (s->ioc, &request); -if (s->drained) { - s->wait_drained_end = true; -while (s->drained) { -/* -* We may be entered once from nbd_client_attach_aio_context_bh -* and then from nbd_client_co_drain_end. So here is a loop. -*/ -qemu_coroutine_yield (); - } +yank_unregister_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), + nbd_yank, s->bs); +object_unref (OBJECT (s->sioc)); + s->sioc =NULL ; +object_unref (OBJECT (s->ioc)); + s->ioc =NULL ; + +return ; } -bdrv_inc_in_flight (s->bs); out:if (ret >=0 ) {
@@ -2051,7 +2066,8 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } - s->conn =nbd_client_connection_new (s->saddr, false,NULL ,NULL ,NULL ); + s->conn =nbd_client_connection_new (s->saddr, true, s->export, + s->x_dirty_bitmap, s->tlscreds);/* * establish TCP connection, return error if it fails
Signature · 1 line
2.29.2
PATCH v4 16/32 block/nbd: introduce nbd_client_connection_release()
In reply to Vladimir Sementsov-OgievskiyThis is a last step of creating bs-independent nbd connection interface. With next commit we can finally move it to separate file.
--- block/nbd.c | 45 +++++++++++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 18 deletions(-)
block/nbd.c +27 -18
@@ -126,7 +126,7 @@ typedef struct BDRVNBDState {NBDClientConnection *conn; } BDRVNBDState; -static void nbd_free_connect_thread (NBDClientConnection *conn); +static void nbd_client_connection_release (NBDClientConnection *conn);static int nbd_establish_connection (BlockDriverState *bs,SocketAddress *saddr,Error **errp); static coroutine_fn QIOChannelSocket *
@@ -138,22 +138,9 @@ static void nbd_yank(void *opaque);static void nbd_clear_bdrvstate (BlockDriverState *bs) {BDRVNBDState *s = (BDRVNBDState *)bs->opaque; -NBDClientConnection *conn = s->conn; -bool do_free = false; - -qemu_mutex_lock (&conn->mutex); -assert (!conn->detached); -if (conn->running) { - conn->detached = true; - }else { - do_free = true; - } -qemu_mutex_unlock (&conn->mutex); -/* the runaway thread will clean up itself */ -if (do_free) { -nbd_free_connect_thread (conn); - } +nbd_client_connection_release (s->conn); + s->conn =NULL ;yank_unregister_instance (BLOCKDEV_YANK_INSTANCE (bs->node_name));
@@ -371,7 +358,7 @@ nbd_client_connection_new(const SocketAddress *saddr)return conn; } -static void nbd_free_connect_thread (NBDClientConnection *conn) +static void nbd_client_connection_do_free (NBDClientConnection *conn) {if (conn->sioc) {qio_channel_close (QIO_CHANNEL (conn->sioc),NULL );
@@ -413,12 +400,34 @@ static void *connect_thread_func(void *opaque)qemu_mutex_unlock (&conn->mutex);if (do_free) { -nbd_free_connect_thread (conn); +nbd_client_connection_do_free (conn); }return NULL ; } +static void nbd_client_connection_release (NBDClientConnection *conn) +{ +bool do_free = false; + +if (!conn) { +return ; + } + +qemu_mutex_lock (&conn->mutex); +assert (!conn->detached); +if (conn->running) { + conn->detached = true; + }else { + do_free = true; + } +qemu_mutex_unlock (&conn->mutex); + +if (do_free) { +nbd_client_connection_do_free (conn); + } +} +/* * Get a new connection in context of @conn: * if the thread is running, wait for completion
Signature · 1 line
2.29.2
PATCH v4 14/32 block/nbd: rename NBDConnectThread to NBDClientConnection
In reply to Vladimir Sementsov-OgievskiyWe are going to move the connection code to its own file, and want clear names and APIs first.
The structure is shared between user and (possibly) several runs of connect-thread. So it's wrong to call it "thread". Let's rename to something more generic.
Appropriately rename connect_thread and thr variables to conn.
--- block/nbd.c | 134 ++++++++++++++++++++++++++-------------------------- 1 file changed, 67 insertions(+), 67 deletions(-)
block/nbd.c +67 -67
@@ -66,7 +66,7 @@ typedef enum NBDClientState {NBD_CLIENT_QUIT } NBDClientState; -typedef struct NBDConnectThread { +typedef struct NBDClientConnection { /* Initialization constants */ SocketAddress *saddr; /* address to connect to */
@@ -90,7 +90,7 @@ typedef struct NBDConnectThread {* nbd_co_establish_connection() after yield() */ Coroutine *wait_co; -} NBDConnectThread; +} NBDClientConnection; typedef struct BDRVNBDState { QIOChannelSocket *sioc; /* The master data channel */
@@ -123,36 +123,36 @@ typedef struct BDRVNBDState {char *x_dirty_bitmap;bool alloc_depth; -NBDConnectThread *connect_thread; +NBDClientConnection *conn; } BDRVNBDState; -static void nbd_free_connect_thread (NBDConnectThread *thr); +static void nbd_free_connect_thread (NBDClientConnection *conn);static int nbd_establish_connection (BlockDriverState *bs,SocketAddress *saddr,Error **errp); static coroutine_fn QIOChannelSocket * -nbd_co_establish_connection (NBDConnectThread *thr, Error **errp); -static void nbd_co_establish_connection_cancel (NBDConnectThread *thr); +nbd_co_establish_connection (NBDClientConnection *conn, Error **errp); +static void nbd_co_establish_connection_cancel (NBDClientConnection *conn);static int nbd_client_handshake (BlockDriverState *bs,Error **errp);static void nbd_yank (void *opaque);static void nbd_clear_bdrvstate (BlockDriverState *bs) {BDRVNBDState *s = (BDRVNBDState *)bs->opaque; -NBDConnectThread *thr = s->connect_thread; +NBDClientConnection *conn = s->conn;bool do_free = false; -qemu_mutex_lock (&thr->mutex); -assert (!thr->detached); -if (thr->running) { - thr->detached = true; +qemu_mutex_lock (&conn->mutex); +assert (!conn->detached); +if (conn->running) { + conn->detached = true; }else { do_free = true; } -qemu_mutex_unlock (&thr->mutex); +qemu_mutex_unlock (&conn->mutex);/* the runaway thread will clean up itself */ if (do_free) { -nbd_free_connect_thread (thr); +nbd_free_connect_thread (conn); }yank_unregister_instance (BLOCKDEV_YANK_INSTANCE (bs->node_name));
@@ -294,7 +294,7 @@ static void coroutine_fn nbd_client_co_drain_begin(BlockDriverState *bs) s->drained = true;qemu_co_sleep_wake (&s->reconnect_sleep); -nbd_co_establish_connection_cancel (s->connect_thread); +nbd_co_establish_connection_cancel (s->conn);reconnect_delay_timer_del (s);
@@ -332,7 +332,7 @@ static void nbd_teardown_connection(BlockDriverState *bs) s->state =NBD_CLIENT_QUIT ;if (s->connection_co) {qemu_co_sleep_wake (&s->reconnect_sleep); -nbd_co_establish_connection_cancel (s->connect_thread); +nbd_co_establish_connection_cancel (s->conn); }if (qemu_in_coroutine ()) { s->teardown_co =qemu_coroutine_self ();
@@ -359,65 +359,65 @@ static bool nbd_client_connecting_wait(BDRVNBDState *s)static void nbd_init_connect_thread (BDRVNBDState *s) { - s->connect_thread =g_new (NBDConnectThread,1 ); + s->conn =g_new (NBDClientConnection,1 ); - *s->connect_thread = (NBDConnectThread ) { + *s->conn = (NBDClientConnection ) { .saddr =QAPI_CLONE (SocketAddress, s->saddr), }; -qemu_mutex_init (&s->connect_thread->mutex); +qemu_mutex_init (&s->conn->mutex); } -static void nbd_free_connect_thread (NBDConnectThread *thr) +static void nbd_free_connect_thread (NBDClientConnection *conn) { -if (thr->sioc) { -qio_channel_close (QIO_CHANNEL (thr->sioc),NULL ); -object_unref (OBJECT (thr->sioc)); +if (conn->sioc) { +qio_channel_close (QIO_CHANNEL (conn->sioc),NULL ); +object_unref (OBJECT (conn->sioc)); } -error_free (thr->err); -qapi_free_SocketAddress (thr->saddr); -g_free (thr); +error_free (conn->err); +qapi_free_SocketAddress (conn->saddr); +g_free (conn); }static void *connect_thread_func (void *opaque) { -NBDConnectThread *thr = opaque; +NBDClientConnection *conn = opaque;int ret;bool do_free; - thr->sioc =qio_channel_socket_new (); + conn->sioc =qio_channel_socket_new (); -error_free (thr->err); - thr->err =NULL ; - ret =qio_channel_socket_connect_sync (thr->sioc, thr->saddr, &thr->err); +error_free (conn->err); + conn->err =NULL ; + ret =qio_channel_socket_connect_sync (conn->sioc, conn->saddr, &conn->err);if (ret <0 ) { -object_unref (OBJECT (thr->sioc)); - thr->sioc =NULL ; +object_unref (OBJECT (conn->sioc)); + conn->sioc =NULL ; } -qio_channel_set_delay (QIO_CHANNEL (thr->sioc), false); +qio_channel_set_delay (QIO_CHANNEL (conn->sioc), false); -qemu_mutex_lock (&thr->mutex); +qemu_mutex_lock (&conn->mutex); -assert (thr->running); - thr->running = false; -if (thr->wait_co) { -aio_co_wake (thr->wait_co); - thr->wait_co =NULL ; +assert (conn->running); + conn->running = false; +if (conn->wait_co) { +aio_co_wake (conn->wait_co); + conn->wait_co =NULL ; } - do_free = thr->detached; + do_free = conn->detached; -qemu_mutex_unlock (&thr->mutex); +qemu_mutex_unlock (&conn->mutex);if (do_free) { -nbd_free_connect_thread (thr); +nbd_free_connect_thread (conn); }return NULL ; }/* -* Get a new connection in context of @thr: +* Get a new connection in context of @conn: * if the thread is running, wait for completion * if the thread already succeeded in the background, and user didn't get the * result, just return it now
@@ -425,38 +425,38 @@ static void *connect_thread_func(void *opaque)* completion */ static coroutine_fn QIOChannelSocket * -nbd_co_establish_connection (NBDConnectThread *thr,Error **errp) +nbd_co_establish_connection (NBDClientConnection *conn,Error **errp) {QIOChannelSocket *sioc =NULL ;QemuThread thread; -qemu_mutex_lock (&thr->mutex); +qemu_mutex_lock (&conn->mutex);/* * Don't call nbd_co_establish_connection() in several coroutines in * parallel. Only one call at once is supported. */ -assert (!thr->wait_co); +assert (!conn->wait_co); -if (!thr->running) { -if (thr->sioc) { +if (!conn->running) { +if (conn->sioc) {/* Previous attempt finally succeeded in background */ - sioc =g_steal_pointer (&thr->sioc); -qemu_mutex_unlock (&thr->mutex); + sioc =g_steal_pointer (&conn->sioc); +qemu_mutex_unlock (&conn->mutex);return sioc; } - thr->running = true; -error_free (thr->err); - thr->err =NULL ; + conn->running = true; +error_free (conn->err); + conn->err =NULL ;qemu_thread_create (&thread,"nbd-connect" , - connect_thread_func, thr,QEMU_THREAD_DETACHED ); + connect_thread_func, conn,QEMU_THREAD_DETACHED ); } - thr->wait_co =qemu_coroutine_self (); + conn->wait_co =qemu_coroutine_self (); -qemu_mutex_unlock (&thr->mutex); +qemu_mutex_unlock (&conn->mutex);/* * We are going to wait for connect-thread finish, but
@@ -464,9 +464,9 @@ nbd_co_establish_connection(NBDConnectThread *thr, Error **errp)*/ qemu_coroutine_yield (); -qemu_mutex_lock (&thr->mutex); +qemu_mutex_lock (&conn->mutex); -if (thr->running) { +if (conn->running) {/* * The connection attempt was canceled and the coroutine resumed * before the connection thread finished its job. Report the
@@ -475,12 +475,12 @@ nbd_co_establish_connection(NBDConnectThread *thr, Error **errp)*/ error_setg (errp,"Connection attempt cancelled by other operation" ); }else { -error_propagate (errp, thr->err); - thr->err =NULL ; - sioc =g_steal_pointer (&thr->sioc); +error_propagate (errp, conn->err); + conn->err =NULL ; + sioc =g_steal_pointer (&conn->sioc); } -qemu_mutex_unlock (&thr->mutex); +qemu_mutex_unlock (&conn->mutex);return sioc; }
@@ -493,15 +493,15 @@ nbd_co_establish_connection(NBDConnectThread *thr, Error **errp)* socket, but rather safely wakes nbd_co_establish_connection() which is * sleeping in yield() */ -static void nbd_co_establish_connection_cancel (NBDConnectThread *thr) +static void nbd_co_establish_connection_cancel (NBDClientConnection *conn) {Coroutine *wait_co; -qemu_mutex_lock (&thr->mutex); +qemu_mutex_lock (&conn->mutex); - wait_co =g_steal_pointer (&thr->wait_co); + wait_co =g_steal_pointer (&conn->wait_co); -qemu_mutex_unlock (&thr->mutex); +qemu_mutex_unlock (&conn->mutex);if (wait_co) {aio_co_wake (wait_co);
@@ -551,7 +551,7 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) s->ioc =NULL ; } - s->sioc =nbd_co_establish_connection (s->connect_thread,NULL ); + s->sioc =nbd_co_establish_connection (s->conn,NULL );if (!s->sioc) { ret = -ECONNREFUSED ; goto out;
Signature · 1 line
2.29.2
PATCH v4 22/32 block/nbd: split nbd_handle_updated_info out of nbd_client_handshake()
In reply to Vladimir Sementsov-OgievskiyTo be reused in the following patch.
--- block/nbd.c | 100 ++++++++++++++++++++++++++++++---------------------- 1 file changed, 58 insertions(+), 42 deletions(-)
block/nbd.c +58 -42
@@ -314,6 +314,51 @@ static bool nbd_client_connecting_wait(BDRVNBDState *s)return qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTING_WAIT ; } +/* +* Update @bs with information learned during a completed negotiation process. +* Return failure if the server's advertised options are incompatible with the +* client's needs. +*/ +static int nbd_handle_updated_info (BlockDriverState *bs,Error **errp) +{ +BDRVNBDState *s = (BDRVNBDState *)bs->opaque; +int ret; + +if (s->x_dirty_bitmap) { +if (!s->info.base_allocation) { +error_setg (errp,"requested x-dirty-bitmap %s not found" , + s->x_dirty_bitmap); +return -EINVAL ; + } +if (strcmp (s->x_dirty_bitmap,"qemu:allocation-depth" ) ==0 ) { + s->alloc_depth = true; + } + } + +if (s->info.flags &NBD_FLAG_READ_ONLY ) { + ret =bdrv_apply_auto_read_only (bs,"NBD export is read-only" , errp); +if (ret <0 ) { +return ret; + } + } + +if (s->info.flags &NBD_FLAG_SEND_FUA ) { + bs->supported_write_flags =BDRV_REQ_FUA ; + bs->supported_zero_flags |=BDRV_REQ_FUA ; + } + +if (s->info.flags &NBD_FLAG_SEND_WRITE_ZEROES ) { + bs->supported_zero_flags |=BDRV_REQ_MAY_UNMAP ; +if (s->info.flags &NBD_FLAG_SEND_FAST_ZERO ) { + bs->supported_zero_flags |=BDRV_REQ_NO_FALLBACK ; + } + } + +trace_nbd_client_handshake_success (s->export); + +return 0 ; +} + static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) {int ret;
@@ -1575,49 +1620,13 @@ static int nbd_client_handshake(BlockDriverState *bs, Error **errp) s->sioc =NULL ;return ret; } -if (s->x_dirty_bitmap) { -if (!s->info.base_allocation) { -error_setg (errp,"requested x-dirty-bitmap %s not found" , - s->x_dirty_bitmap); - ret = -EINVAL ; - goto fail; - } -if (strcmp (s->x_dirty_bitmap,"qemu:allocation-depth" ) ==0 ) { - s->alloc_depth = true; - } - } -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 (s->info.flags &NBD_FLAG_SEND_FUA ) { - bs->supported_write_flags =BDRV_REQ_FUA ; - bs->supported_zero_flags |=BDRV_REQ_FUA ; - } -if (s->info.flags &NBD_FLAG_SEND_WRITE_ZEROES ) { - bs->supported_zero_flags |=BDRV_REQ_MAY_UNMAP ; -if (s->info.flags &NBD_FLAG_SEND_FAST_ZERO ) { - bs->supported_zero_flags |=BDRV_REQ_NO_FALLBACK ; - } - } -if (!s->ioc) { - s->ioc =QIO_CHANNEL (s->sioc); -object_ref (OBJECT (s->ioc)); - } - -trace_nbd_client_handshake_success (s->export); - -return 0 ; - - fail: -/* -* We have connected, but must fail for other reasons. -* Send NBD_CMD_DISC as a courtesy to the server. -*/ - { + ret =nbd_handle_updated_info (bs, errp); +if (ret <0 ) { +/* +* We have connected, but must fail for other reasons. +* Send NBD_CMD_DISC as a courtesy to the server. +*/ NBDRequest request = { .type =NBD_CMD_DISC };nbd_send_request (s->ioc ?:QIO_CHANNEL (s->sioc), &request);
@@ -1631,6 +1640,13 @@ static int nbd_client_handshake(BlockDriverState *bs, Error **errp)return ret; } + +if (!s->ioc) { + s->ioc =QIO_CHANNEL (s->sioc); +object_ref (OBJECT (s->ioc)); + } + +return 0 ; }/*
Signature · 1 line
2.29.2
PATCH v4 31/32 block/nbd: add nbd_client_connected() helper
In reply to Vladimir Sementsov-OgievskiyWe already have two similar helpers for other state. Let's add another one for convenience.
--- block/nbd.c | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-)
block/nbd.c +14 -11
@@ -122,15 +122,20 @@ static void nbd_clear_bdrvstate(BlockDriverState *bs) s->x_dirty_bitmap =NULL ; } +static bool nbd_client_connected (BDRVNBDState *s) +{ +return qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTED ; +} +static void nbd_channel_error (BDRVNBDState *s,int ret) {if (ret == -EIO ) { -if (qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTED ) { +if (nbd_client_connected (s)) { s->state = s->reconnect_delay ?NBD_CLIENT_CONNECTING_WAIT :NBD_CLIENT_CONNECTING_NOWAIT ; } }else { -if (qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTED ) { +if (nbd_client_connected (s)) {qio_channel_shutdown (s->ioc,QIO_CHANNEL_SHUTDOWN_BOTH ,NULL ); } s->state =NBD_CLIENT_QUIT ;
@@ -228,7 +233,7 @@ static void nbd_client_attach_aio_context(BlockDriverState *bs,* s->connection_co is either yielded from nbd_receive_reply or from * nbd_co_reconnect_loop() */ -if (qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTED ) { +if (nbd_client_connected (s)) {qio_channel_attach_aio_context (QIO_CHANNEL (s->ioc), new_context); }
@@ -499,7 +504,7 @@ static coroutine_fn void nbd_connection_entry(void *opaque)nbd_co_reconnect_loop (s); } -if (qatomic_load_acquire (&s->state) !=NBD_CLIENT_CONNECTED ) { +if (!nbd_client_connected (s)) {continue ; }
@@ -578,7 +583,7 @@ static int nbd_co_send_request(BlockDriverState *bs,qemu_co_queue_wait (&s->free_sema, &s->send_mutex); } -if (qatomic_load_acquire (&s->state) !=NBD_CLIENT_CONNECTED ) { +if (!nbd_client_connected (s)) { rc = -EIO ; goto err; }
@@ -605,8 +610,7 @@ static int nbd_co_send_request(BlockDriverState *bs,if (qiov) {qio_channel_set_cork (s->ioc, true); rc =nbd_send_request (s->ioc, request); -if (qatomic_load_acquire (&s->state) ==NBD_CLIENT_CONNECTED && - rc >=0 ) { +if (nbd_client_connected (s) && rc >=0 ) {if (qio_channel_writev_all (s->ioc, qiov->iov, qiov->niov,NULL ) <0 ) { rc = -EIO ;
@@ -931,7 +935,7 @@ static coroutine_fn int nbd_co_do_receive_one_chunk( s->requests[i].receiving = true;qemu_coroutine_yield (); s->requests[i].receiving = false; -if (qatomic_load_acquire (&s->state) !=NBD_CLIENT_CONNECTED ) { +if (!nbd_client_connected (s)) {error_setg (errp,"Connection closed" );return -EIO ; }
@@ -1090,7 +1094,7 @@ static bool nbd_reply_chunk_iter_receive(BDRVNBDState *s,NBDReply local_reply;NBDStructuredReplyChunk *chunk;Error *local_err =NULL ; -if (qatomic_load_acquire (&s->state) !=NBD_CLIENT_CONNECTED ) { +if (!nbd_client_connected (s)) {error_setg (&local_err,"Connection closed" );nbd_iter_channel_error (iter, -EIO , &local_err); goto break_loop;
@@ -1115,8 +1119,7 @@ static bool nbd_reply_chunk_iter_receive(BDRVNBDState *s, }/* Do not execute the body of NBD_FOREACH_REPLY_CHUNK for simple reply. */ -if (nbd_reply_is_simple (reply) || -qatomic_load_acquire (&s->state) !=NBD_CLIENT_CONNECTED ) { +if (nbd_reply_is_simple (reply) || !nbd_client_connected (s)) { goto break_loop; }
Signature · 1 line
2.29.2
PATCH v4 29/32 nbd/client-connection: add option for non-blocking connection attempt
In reply to Vladimir Sementsov-OgievskiyWe'll need a possibility of non-blocking nbd_co_establish_connection(), so that it returns immediately, and it returns success only if a connections was previously established in background.
--- include/block/nbd.h | 2 +- block/nbd.c | 2 +- nbd/client-connection.c | 8 +++++++- 3 files changed, 9 insertions(+), 3 deletions(-)
include/block/nbd.h +1 -1
@@ -420,7 +420,7 @@ void nbd_client_connection_release(NBDClientConnection *conn); QIOChannel *coroutine_fnnbd_co_establish_connection (NBDClientConnection *conn, NBDExportInfo *info, - Error **errp); + bool blocking, Error **errp); void coroutine_fn nbd_co_establish_connection_cancel(NBDClientConnection *conn);
block/nbd.c +1 -1
@@ -364,7 +364,7 @@ static int coroutine_fn nbd_co_do_establish_connection(BlockDriverState *bs,assert (!s->ioc); - s->ioc =nbd_co_establish_connection (s->conn, &s->info, errp); + s->ioc =nbd_co_establish_connection (s->conn, &s->info, true, errp);if (!s->ioc) {return -ECONNREFUSED ; }
nbd/client-connection.c +7 -1
@@ -265,6 +265,8 @@ void nbd_client_connection_release(NBDClientConnection *conn)* otherwise the thread is not running, so start a thread and wait for * completion * +* If @blocking is false, don't wait for the thread, return immediately. +* * If @info is not NULL, also do nbd-negotiation after successful connection. * In this case info is used only as out parameter, and is fully initialized by * nbd_co_establish_connection(). "IN" fields of info as well as related only to
@@ -273,7 +275,7 @@ void nbd_client_connection_release(NBDClientConnection *conn)*/ QIOChannel *coroutine_fnnbd_co_establish_connection (NBDClientConnection *conn, NBDExportInfo *info, - Error **errp) + bool blocking, Error **errp) {QIOChannel *ioc;QemuThread thread;
@@ -313,6 +315,10 @@ nbd_co_establish_connection(NBDClientConnection *conn, NBDExportInfo *info, connect_thread_func, conn, QEMU_THREAD_DETACHED); } +if (!blocking) { +return NULL ; + } + conn->wait_co =qemu_coroutine_self (); }
Signature · 1 line
2.29.2
PATCH v4 32/32 block/nbd: safer transition to receiving request
In reply to Vladimir Sementsov-Ogievskiyreq->receiving is a flag of request being in one concrete yield point in nbd_co_do_receive_one_chunk().
Such kind of boolean flag is always better to unset before scheduling the coroutine, to avoid double scheduling. So, let's be more careful.
--- block/nbd.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
block/nbd.c +3 -1
@@ -150,6 +150,7 @@ static void nbd_recv_coroutines_wake_all(BDRVNBDState *s)NBDClientRequest *req = &s->requests[i];if (req->coroutine && req->receiving) { + req->receiving = false;aio_co_wake (req->coroutine); } }
@@ -548,6 +549,7 @@ static coroutine_fn void nbd_connection_entry(void *opaque)* connection_co happens through a bottom half, which can only * run after we yield. */ + s->requests[i].receiving = false;aio_co_wake (s->requests[i].coroutine);qemu_coroutine_yield (); }
@@ -934,7 +936,7 @@ static coroutine_fn int nbd_co_do_receive_one_chunk(/* Wait until we're woken up by nbd_connection_entry. */ s->requests[i].receiving = true;qemu_coroutine_yield (); - s->requests[i].receiving = false; +assert (!s->requests[i].receiving);if (!nbd_client_connected (s)) {error_setg (errp,"Connection closed" );return -EIO ;
Signature · 1 line
2.29.2
PATCH v4 28/32 block/nbd: split nbd_co_do_establish_connection out of nbd_reconnect_attempt
In reply to Vladimir Sementsov-OgievskiySplit out the part that we want to reuse for nbd_open().
--- block/nbd.c | 80 ++++++++++++++++++++++++++++------------------------- 1 file changed, 42 insertions(+), 38 deletions(-)
block/nbd.c +42 -38
@@ -356,11 +356,50 @@ static int nbd_handle_updated_info(BlockDriverState *bs, Error **errp)return 0 ; } -static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) +static int coroutine_fn nbd_co_do_establish_connection(BlockDriverState *bs, +Error **errp) { +BDRVNBDState *s = (BDRVNBDState *)bs->opaque;int ret; -AioContext *aio_context =bdrv_get_aio_context (s->bs); +assert (!s->ioc); + + s->ioc =nbd_co_establish_connection (s->conn, &s->info, errp); +if (!s->ioc) { +return -ECONNREFUSED ; + } + + ret =nbd_handle_updated_info (s->bs,NULL ); +if (ret <0 ) { +/* +* We have connected, but must fail for other reasons. +* Send NBD_CMD_DISC as a courtesy to the server. +*/ +NBDRequest request = { .type =NBD_CMD_DISC }; + +nbd_send_request (s->ioc, &request); + +object_unref (OBJECT (s->ioc)); + s->ioc =NULL ; + +return ret; + } + +qio_channel_set_blocking (s->ioc, false,NULL ); +qio_channel_attach_aio_context (s->ioc,bdrv_get_aio_context (bs)); + +yank_register_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, + bs); + +/* successfully connected */ + s->state =NBD_CLIENT_CONNECTED ; +qemu_co_queue_restart_all (&s->free_sema); + +return 0 ; +} + +static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) +{if (!nbd_client_connecting (s)) {return ; }
@@ -398,42 +437,7 @@ static coroutine_fn void nbd_reconnect_attempt(BDRVNBDState *s) s->ioc =NULL ; } - s->ioc =nbd_co_establish_connection (s->conn, &s->info,NULL ); -if (!s->ioc) { - ret = -ECONNREFUSED ; - goto out; - } - -qio_channel_set_blocking (QIO_CHANNEL (s->ioc), false,NULL ); -qio_channel_attach_aio_context (QIO_CHANNEL (s->ioc), aio_context); - -yank_register_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), nbd_yank, - s->bs); - - ret =nbd_handle_updated_info (s->bs,NULL ); -if (ret <0 ) { -/* -* We have connected, but must fail for other reasons. -* Send NBD_CMD_DISC as a courtesy to the server. -*/ -NBDRequest request = { .type =NBD_CMD_DISC }; - -nbd_send_request (s->ioc, &request); - -yank_unregister_function (BLOCKDEV_YANK_INSTANCE (s->bs->node_name), - nbd_yank, s->bs); -object_unref (OBJECT (s->ioc)); - s->ioc =NULL ; - -return ; - } - -out: -if (ret >=0 ) { -/* successfully connected */ - s->state =NBD_CLIENT_CONNECTED ; -qemu_co_queue_restart_all (&s->free_sema); - } +nbd_co_do_establish_connection (s->bs,NULL ); } static coroutine_fn void nbd_co_reconnect_loop(BDRVNBDState *s)
Signature · 1 line
2.29.2
Re: [PATCH v4 01/32] co-queue: drop extra coroutine_fn marks
In reply to Vladimir Sementsov-OgievskiyQuoted 10 lines · Vladimir Sementsov-Ogievskiy
qemu_co_queue_next()andqemu_co_queue_restart_all()just callaio_co_wake()which works well in non-coroutine context. So these functions can be called from non-coroutine context as well. And actuallyqemu_co_queue_restart_all()is called fromnbd_cancel_in_flight(), which is called from non-coroutine context.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/qemu/coroutine.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
In the back of my mind, I have to repeatedly question my faulty memory on whether:
absence of coroutine_fn means this function is unsafe to call from a coroutine context (that is, coroutines can only call functions tagged with coroutine_fn)
vs.
presence of coroutine_fn means this function must only use coroutine-safe actions, but not all coroutine-safe functions have this tag (in particular, functions which are designed to work both in or out of coroutine context do not have the tag, but coroutines can call functions without the tag)
But thankfully, rereading include/qemu/coroutine.h clears it up and both of my initial thoughts are wrong although the second is closer; it is yet another definition:
presence of coroutine_fn means this function must NOT be called except from a coroutine context. coroutines can call functions with or without the tag, but if they lack the tag, the coroutine must ensure the function won't block.
Thus, adding the tag is something we do when writing a function that obeys coroutine rules and requires a coroutine context to already be present, and once a function is then relaxed enough to work from both regular and coroutine functions, we drop the marker. But we keep the _co_ in the function name to remind ourselves that it is coroutine-safe, in addition to normal-safe.
And your patch is doing just that - we have functions that work from both normal and coroutine context, so we can drop the marker but keep _co_ in the name.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 01/32] co-queue: drop extra coroutine_fn marks
Quoted 43 lines · Eric Blake
Quoted 10 lines · Vladimir Sementsov-Ogievskiy
qemu_co_queue_next()andqemu_co_queue_restart_all()just callaio_co_wake()which works well in non-coroutine context. So these functions can be called from non-coroutine context as well. And actuallyqemu_co_queue_restart_all()is called fromnbd_cancel_in_flight(), which is called from non-coroutine context.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/qemu/coroutine.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)In the back of my mind, I have to repeatedly question my faulty memory on whether:
absence of
coroutine_fnmeans this function is unsafe to call from a coroutine context (that is, coroutines can only call functions tagged withcoroutine_fn)vs.
presence of
coroutine_fnmeans this function must only use coroutine-safe actions, but not all coroutine-safe functions have this tag (in particular, functions which are designed to work both in or out of coroutine context do not have the tag, but coroutines can call functions without the tag)But thankfully, rereading
include/qemu/coroutine.hclears it up and both of my initial thoughts are wrong although the second is closer; it is yet another definition:presence of
coroutine_fnmeans this function must NOT be called except from a coroutine context. coroutines can call functions with or without the tag, but if they lack the tag, the coroutine must ensure the function won't block.Thus, adding the tag is something we do when writing a function that obeys coroutine rules and requires a coroutine context to already be present, and once a function is then relaxed enough to work from both regular and coroutine functions, we drop the marker. But we keep the _co_ in the function name to remind ourselves that it is coroutine-safe, in addition to normal-safe.
Quoted 6 lines
And your patch is doing just that - we have functions that work from both normal and coroutine context, so we can drop the marker but keep _co_ in the name.
Reviewed-by Eric Blake <[email protected]>
Actually, usually _co_ == coroutine_fn. I don't drop it here because it's the name of the object: CoQueue, so qemu_co_queue_ refers to it..
We also have for example aio_co_wake, which is safe to call from non-coroutine context. And _co_ refers to what function do: wake a coroutine.
However it would be strange to have a function with _co_ in the name (in any meaning) which is unsafe to call from coroutine context.
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH v4 04/32] block/nbd: connect_thread_func(): do qio_channel_set_delay(false)
In reply to Vladimir Sementsov-OgievskiyQuoted 10 lines · Vladimir Sementsov-Ogievskiy
nbd_open()does it (throughnbd_establish_connection()). Actually we lost that call on reconnect path in1dc4718d849e1a1fe"block/nbd: use non-blocking connect: fix vm hang onconnect()" when we have introduced reconnect thread.Fixes 1dc4718d849e1a1fe665ce5241ed79048cfa2cfcSigned-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/nbd.c | 2 ++ 1 file changed, 2 insertions(+)
Quoted 17 lines
block/nbd.c +2
-0@@ -408,6 +408,8 @@ static void *connect_thread_func(void *opaque) thr->sioc =NULL ; } +qio_channel_set_delay (QIO_CHANNEL (thr->sioc), false); +qemu_mutex_lock (&thr->mutex);switch (thr->state) {Signature · 1 line
2.29.2
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 05/32] qemu-sockets: introduce socket_address_parse_named_fd()
In reply to Vladimir Sementsov-OgievskiyQuoted 17 lines · Vladimir Sementsov-Ogievskiy
Add function that transforms named fd inside SocketAddress structure into number representation. This way it may be then used in a context where current monitor is not available.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/qemu/sockets.h | 14 ++++++++++++++ util/qemu-sockets.c | 19 +++++++++++++++++++ 2 files changed, 33 insertions(+)include/qemu/sockets.h +0
-0@@ -111,4 +111,18 @@ SocketAddress *socket_remote_address(int fd, Error **errp);*/ SocketAddress *socket_address_flatten (SocketAddressLegacy *addr);
include/qemu/sockets.h SocketAddress *socket_remote_address(int fd, Error **errp); · line 122
Quoted 10 lines
include/qemu/sockets.h +9
-0+/** +* socket_address_parse_named_fd: +* +* Modify @addr, replacing named fd by corresponding number. +* +* Parsing named fd (by sockget_get_fd) is not possible in context where +* current monitor is not available. So, SocketAddress user may first call +* socket_parse_named_fd() to parse named fd in advance, and then pass @addr to +* the context where monitor is not available.
2 different wrong function names, and reads awkwardly. How about this shorter variant:
Modify @addr, replacing a named fd by its corresponding number. Needed for callers that plan to pass @addr to a context where the current monitor is not available.
util/qemu-sockets.c
Quoted 7 lines
include/qemu/sockets.h +5
-0+* +* Return 0 on success. +*/ +int socket_address_parse_named_fd (SocketAddress *addr,Error **errp); +#endif /* QEMU_SOCKETS_H */ util/qemu-sockets.c +0
-0
But the code looks good.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 06/32] block/nbd: call socket_address_parse_named_fd() in advance
In reply to Vladimir Sementsov-OgievskiyQuoted 4 lines · Vladimir Sementsov-Ogievskiy
Detecting monitor by current coroutine works bad when we are not in coroutine context. And that's exactly so in nbd reconnect code, where
qio_channel_socket_connect_sync()is called from thread.
Quoted 8 lines
Monitor is needed only to parse named file descriptor. So, let's just parse it during
nbd_open(), so that all further users ofs->saddrdon't need to access monitor.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/nbd.c | 6 ++++++ 1 file changed, 6 insertions(+)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 10/32] block/nbd: simplify waking of nbd_co_establish_connection()
In reply to Vladimir Sementsov-OgievskiyQuoted 4 lines · Vladimir Sementsov-Ogievskiy
Instead of managing
connect_bh,bh_ctx, andwait_connectfields, we can use a single link to the waiting coroutine with proper mutex protection.
...
Quoted 11 lines
Also, this commit reduces the dependence of
nbd_co_establish_connection()on the internals of bs (we now use a generic pointer to the coroutine, instead of direct use ofs->connection_co). This is a step towards splitting the connection API out ofnbd.c.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/nbd.c | 55 +++++++++++++++-------------------------------------- 1 file changed, 15 insertions(+), 40 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 05/32] qemu-sockets: introduce socket_address_parse_named_fd()
In reply to Eric BlakeQuoted 32 lines · Eric Blake
Quoted 17 lines · Vladimir Sementsov-Ogievskiy
Add function that transforms named fd inside SocketAddress structure into number representation. This way it may be then used in a context where current monitor is not available.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/qemu/sockets.h | 14 ++++++++++++++ util/qemu-sockets.c | 19 +++++++++++++++++++ 2 files changed, 33 insertions(+)include/qemu/sockets.h +0
-0@@ -111,4 +111,18 @@ SocketAddress *socket_remote_address(int fd, Error **errp);*/ SocketAddress *socket_address_flatten (SocketAddressLegacy *addr);include/qemu/sockets.h SocketAddress *socket_remote_address(int fd, Error **errp); · line 122
Quoted 10 lines
include/qemu/sockets.h +9
-0+/** +* socket_address_parse_named_fd: +* +* Modify @addr, replacing named fd by corresponding number. +* +* Parsing named fd (by sockget_get_fd) is not possible in context where +* current monitor is not available. So, SocketAddress user may first call +* socket_parse_named_fd() to parse named fd in advance, and then pass @addr to +* the context where monitor is not available. 2 different wrong function names, and reads awkwardly. How about this shorter variant:
Quoted 3 lines
Modify @addr, replacing a named fd by its corresponding number. Needed for callers that plan to pass @addr to a context where the current monitor is not available.
A lot better, thanks!
Quoted 10 lines
util/qemu-sockets.c
Quoted 8 lines
include/qemu/sockets.h +5
-0+* +* Return 0 on success. +*/ +int socket_address_parse_named_fd (SocketAddress *addr,Error **errp); +#endif /* QEMU_SOCKETS_H */ util/qemu-sockets.c +0
-0But the code looks good.
Somehow, C is simpler for me than English )
Quoted 3 lines
Reviewed-by Eric Blake <[email protected]>
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH v4 11/32] block/nbd: drop thr->state
In reply to Vladimir Sementsov-OgievskiyQuoted 20 lines · Vladimir Sementsov-Ogievskiy
We don't need all these states. The code refactored to use two boolean variables looks simpler.
While moving the comment in
nbd_co_establish_connection()rework it to give better information. Also, we are going to move the connection code to separate file and mentioning drained section would be confusing.Improve also the comment in NBDConnectThread, while dropping removed state names from it.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/nbd.c | 139 +++++++++++++++++----------------------------------- 1 file changed, 44 insertions(+), 95 deletions(-)typedef struct NBDConnectThread {
/* Initialization constants */ SocketAddress *saddr; /* address to connect to */
block/nbd.c typedef enum NBDClientState { · line 79
Quoted 9 lines
block/nbd.c +6
-2+QemuMutex mutex; +/* -* Result of last attempt. Valid in FAIL and SUCCESS states. -* If you want to steal error, don't forget to set pointer to NULL. +* @sioc and @err present a result of connection attempt. +* While running is true, they are used only by thread, mutex locking is not +* needed. When thread is finished nbd_co_establish_connection steal these +* pointers under mutex.
@sioc and @err represent a connection attempt. While running is true, they are only used by the connection thread, and mutex locking is not needed. Once the thread finishes, nbd_co_establish_connection then steals these pointers under mutex.
block/nbd.c typedef enum NBDClientState { · line 86
Quoted 11 lines
*/ QIOChannelSocket *sioc; Error *err;block/nbd.c +3
-3-QemuMutex mutex; -/* All further fields are protected by mutex */ -NBDConnectThreadState state;/* current state of the thread */ +/* All further fields are accessed only under mutex */ +bool running;/* thread is running now */ +bool detached;/* thread is detached and should cleanup the state */
Okay, I'm understanding this better than I did in v3.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 16/32] block/nbd: introduce nbd_client_connection_release()
In reply to Vladimir Sementsov-OgievskiyQuoted 8 lines · Vladimir Sementsov-Ogievskiy
This is a last step of creating bs-independent nbd connection interface. With next commit we can finally move it to separate file.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/nbd.c | 45 +++++++++++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 18 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 18/32] nbd/client-connection: use QEMU_LOCK_GUARD
In reply to Vladimir Sementsov-OgievskiyQuoted 9 lines · Vladimir Sementsov-Ogievskiy
We don't update
connect_thread_func()to useQEMU_LOCK_GUARD, as it will get more complex critical sections logic in further commit, whereQEMU_LOCK_GUARDdoesn't help.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- nbd/client-connection.c | 99 +++++++++++++++++++---------------------- 1 file changed, 45 insertions(+), 54 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 19/32] nbd/client-connection: add possibility of negotiation
In reply to Vladimir Sementsov-OgievskiyQuoted 10 lines · Vladimir Sementsov-Ogievskiy
Add arguments and logic to support nbd negotiation in the same thread after successful connection.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/block/nbd.h | 9 +++- block/nbd.c | 4 +- nbd/client-connection.c | 105 ++++++++++++++++++++++++++++++++++++++-- 3 files changed, 109 insertions(+), 9 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 20/32] nbd/client-connection: implement connection retry
In reply to Vladimir Sementsov-OgievskiyQuoted 1 line · Vladimir Sementsov-Ogievskiy
Add an option for a thread to retry connection until succeeds. We'll
for a thread to retry connecting until it succeeds.
Quoted 11 lines
use nbd/client-connection both for reconnect and for initial connection in
nbd_open(), so we need a possibility to use same NBDClientConnection instance to connect once innbd_open()and then use retry semantics for reconnect.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/block/nbd.h | 2 ++ nbd/client-connection.c | 56 +++++++++++++++++++++++++++++++---------- 2 files changed, 45 insertions(+), 13 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 21/32] nbd/client-connection: shutdown connection on release
In reply to Vladimir Sementsov-OgievskiyQuoted 10 lines · Vladimir Sementsov-Ogievskiy
Now, when a thread can do negotiation and retry, it may run relatively long. We need a mechanism to stop it, when the user is not interested in a result any more. So, on
nbd_client_connection_release()let's shutdown the socket, and do not retry connection if thread is detached.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- nbd/client-connection.c | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 28/32] block/nbd: split nbd_co_do_establish_connection out of nbd_reconnect_attempt
In reply to Vladimir Sementsov-OgievskiyQuoted 7 lines · Vladimir Sementsov-Ogievskiy
Split out the part that we want to reuse for
nbd_open().Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- block/nbd.c | 80 ++++++++++++++++++++++++++++------------------------- 1 file changed, 42 insertions(+), 38 deletions(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Quoted 10 lines · Vladimir Sementsov-Ogievskiy
v4:
Now based on new Paolo's patch:
Based-on: <[email protected]>Also, I've dropped patch 33 for now, it's too much for this series. I'll resend it later on top of this.
The series is also available at tag up-nbd-client-connection-v4 in git https://src.openvz.org/scm/~vsementsov/qemu.git
I think everything has R-b now, so I'll queue this through my NBD tree including folding in the grammar tweaks where I spotted them.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Quoted 6 lines · Eric Blake
Quoted 5 lines · Vladimir Sementsov-Ogievskiy
v4:
Now based on new Paolo's patch:
Based-on: <[email protected]>
Quoted 9 lines
Quoted 5 lines
Also, I've dropped patch 33 for now, it's too much for this series. I'll resend it later on top of this.
The series is also available at tag up-nbd-client-connection-v4 in git https://src.openvz.org/scm/~vsementsov/qemu.git
I think everything has R-b now, so I'll queue this through my NBD tree including folding in the grammar tweaks where I spotted them.
Thanks a lot!
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH v4 20/32] nbd/client-connection: implement connection retry
In reply to Vladimir Sementsov-OgievskiyReviving this thread, as a good as place as any for my question:
Quoted 26 lines · Vladimir Sementsov-Ogievskiy
Add an option for a thread to retry connection until succeeds. We'll use nbd/client-connection both for reconnect and for initial connection in
nbd_open(), so we need a possibility to use same NBDClientConnection instance to connect once innbd_open()and then use retry semantics for reconnect.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/block/nbd.h | 2 ++ nbd/client-connection.c | 56 +++++++++++++++++++++++++++++++---------- 2 files changed, 45 insertions(+), 13 deletions(-)NBDClientConnection *nbd_client_connection_new(const SocketAddress *saddr,
booldo_negotiation, const char*export_name,nbd/client-connection.c +4
-1@@ -154,23 +164,43 @@ static void *connect_thread_func(void *opaque)NBDClientConnection *conn = opaque;int ret;bool do_free; +uint64_t timeout =1 ; +uint64_t max_timeout =16 ; - conn->sioc =qio_channel_socket_new (); +while (true) { + conn->sioc =qio_channel_socket_new ();
nbd/client-connection.c static void *connect_thread_func(void *opaque) · line 166
Quoted 10 lines
nbd/client-connection.c +3
-6-error_free (conn->err); - conn->err =NULL ; - conn->updated_info = conn->initial_info; +error_free (conn->err); + conn->err =NULL ; + conn->updated_info = conn->initial_info; - ret =nbd_connect (conn->sioc, conn->saddr, - conn->do_negotiation ? &conn->updated_info :NULL , - conn->tlscreds, &conn->ioc, &conn->err);
This says that on each retry attempt, we reset whether to ask the server for structured replies back to our original initial_info values.
But when dealing with NBD retries in general, I suspect we have a bug. Consider what happens if our first connection requests structured replies and base:allocation block status, and we are successful. But later, the server disconnects, triggering a retry. Suppose that on our retry, we encounter a different server that no longer supports structured replies. We would no longer be justified in sending NBD_CMD_BLOCK_STATUS requests to the reconnected server. But I can't find anywhere in the code base that ensures that on a reconnect, the new server supplies at least as many extensions as the original server, nor anywhere that we would be able to gracefully handle an in-flight block status command that can no longer be successfully continued because the reconnect landed on a downgraded server.
In general, you don't expect a server to downgrade its capabilities across restarts, so assuming that a retried connection will hit a server at least as capable as the original server is typical, even if unsafe. But it is easy enough to use nbdkit to write a server that purposefully downgrades its abilities after the first client connection, for testing how qemu falls apart if it continues making assumptions about the current server based solely on what it learned prior to retrying from the first server.
Is this something we need to address quickly for inclusion in 6.2? Maybe by having a retry connect fail if the new server does not have the same capabilities as the old? Do we also need to care about a server reporting a different size export than the old server?
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v4 20/32] nbd/client-connection: implement connection retry
Quoted 66 lines · Eric Blake
Reviving this thread, as a good as place as any for my question:
Quoted 26 lines · Vladimir Sementsov-Ogievskiy
Add an option for a thread to retry connection until succeeds. We'll use nbd/client-connection both for reconnect and for initial connection in
nbd_open(), so we need a possibility to use same NBDClientConnection instance to connect once innbd_open()and then use retry semantics for reconnect.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/block/nbd.h | 2 ++ nbd/client-connection.c | 56 +++++++++++++++++++++++++++++++---------- 2 files changed, 45 insertions(+), 13 deletions(-)NBDClientConnection *nbd_client_connection_new(const SocketAddress *saddr,
booldo_negotiation, const char*export_name,nbd/client-connection.c +4
-1@@ -154,23 +164,43 @@ static void *connect_thread_func(void *opaque)NBDClientConnection *conn = opaque;int ret;bool do_free; +uint64_t timeout =1 ; +uint64_t max_timeout =16 ; - conn->sioc =qio_channel_socket_new (); +while (true) { + conn->sioc =qio_channel_socket_new ();nbd/client-connection.c static void *connect_thread_func(void *opaque) · line 166
Quoted 10 lines
nbd/client-connection.c +3
-6-error_free (conn->err); - conn->err =NULL ; - conn->updated_info = conn->initial_info; +error_free (conn->err); + conn->err =NULL ; + conn->updated_info = conn->initial_info; - ret =nbd_connect (conn->sioc, conn->saddr, - conn->do_negotiation ? &conn->updated_info :NULL , - conn->tlscreds, &conn->ioc, &conn->err);This says that on each retry attempt, we reset whether to ask the server for structured replies back to our original
initial_infovalues.But when dealing with NBD retries in general, I suspect we have a bug. Consider what happens if our first connection requests structured replies and base:allocation block status, and we are successful. But later, the server disconnects, triggering a retry. Suppose that on our retry, we encounter a different server that no longer supports structured replies. We would no longer be justified in sending
NBD_CMD_BLOCK_STATUSrequests to the reconnected server. But I can't find anywhere in the code base that ensures that on a reconnect, the new server supplies at least as many extensions as the original server, nor anywhere that we would be able to gracefully handle an in-flight block status command that can no longer be successfully continued because the reconnect landed on a downgraded server.In general, you don't expect a server to downgrade its capabilities across restarts, so assuming that a retried connection will hit a server at least as capable as the original server is typical, even if unsafe. But it is easy enough to use nbdkit to write a server that purposefully downgrades its abilities after the first client connection, for testing how qemu falls apart if it continues making assumptions about the current server based solely on what it learned prior to retrying from the first server.
Quoted 5 lines
Is this something we need to address quickly for inclusion in 6.2? Maybe by having a retry connect fail if the new server does not have the same capabilities as the old? Do we also need to care about a server reporting a different size export than the old server?
Yes that's a problem. We previously noted it here https://lists.gnu.org/archive/html/qemu-block/2021-06/msg00458.html
Honestly, I didn't start any fix for that :(.. I agree, it would be good to fix it somehow in 6.2. I'll try to make something simple this week. Or did you already started doing some fix?
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH v4 20/32] nbd/client-connection: implement connection retry
Quoted 13 lines · Vladimir Sementsov-Ogievskiy
Quoted 10 lines · Eric Blake
Reviving this thread, as a good as place as any for my question:
But I can't
find anywhere in the code base that ensures that on a reconnect, the new server supplies at least as many extensions as the original server, nor anywhere that we would be able to gracefully handle an in-flight block status command that can no longer be successfully continued because the reconnect landed on a downgraded server.
Quoted 1 line
Yes that's a problem. We previously noted it here https://lists.gnu.org/archive/html/qemu-block/2021-06/msg00458.html
Aha! And oops that we've let it slide this long. But now that we know the problem was also present in 6.1, and not a new regression in 6.2, it is less urgent to get a fix in. If we get one written in time, it's still game for inclusion for -rc2 or maybe -rc3, but as we get further along in the process, it should not hold up the final release (it would not be -rc4 material, for example).
Quoted 2 lines
Honestly, I didn't start any fix for that :(.. I agree, it would be good to fix it somehow in 6.2. I'll try to make something simple this week. Or did you already started doing some fix?
I haven't started writing anything on the topic. I've got some patches that I hope to post soon targetting 7.0 that allow an extension for NBD_CMD_BLOCK_STATUS to do a full round-trip 64-bit operation, which is why I noticed it (if the 64-bit extension is not present on reconnect, we have a problem - but it's no worse than the existing problems). But I'm currently so focused on getting the new feature interoperating between qemu, libnbd, and nbdkit, plus the US Thanksgiving break this week, that I'm happy to let you take first shot at client-side validation that a server reconnect does not lose capabilities.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org