Skip to contentSkip to conversation

nbd/server: Quiesce server on drained section

PATCH Applied Sergio Lopez 3 participants 8 messages Jun 2, 2021 Block layer

lore
Share & tools
lore
#0 lore raw

v2 cover nbd/server: Quiesce server on drained section

Before switching between AioContexts we need to make sure that we're fully quiesced ("nb_requests == 0" for every client) when entering the drained section. Otherwise, coroutines may be run in the wrong context after the switch, leading to a number of critical issues.

To accomplish this, we add ".drained_poll" to BlockDevOps and use it in the NBD server, along with ".drained_being" and "drained_end", to coordinate the quiescing of the server while entering a drained section.

v2:
- Use a bool for the value returned by .drained_poll [Kevin]
- Change .drained_poll comment to reflect that the returned boolean value will be true if the device is still busy, or false otherwise
- Drop yield_co_list and use recv_coroutine and read_yielding [Kevin]
- Return "true" or "false" in nbd_drained_poll [Kevin]
- Fix grammar in the commit message of patch 2 [Eric]

Sergio Lopez (2):
block-backend: add drained_poll
nbd/server: Use drained block ops to quiesce the server

 block/block-backend.c          |  7 ++-
 include/sysemu/block-backend.h |  4 ++
 nbd/server.c                   | 82 +++++++++++++++++++++++++---------
 3 files changed, 71 insertions(+), 22 deletions(-)
Signature · 1 line
2.26.2
#1 lore raw

PATCH v2 1/2 block-backend: add drained_poll

Allow block backends to poll their devices/users to check if they have been quiesced when entering a drained section.

This will be used in the next patch to wait for the NBD server to be completely quiesced.

---
 block/block-backend.c          | 7 ++++++-
 include/sysemu/block-backend.h | 4 ++++
 2 files changed, 10 insertions(+), 1 deletion(-)
block/block-backend.c +6 -1
index de5496af66..8fcc2b4b3d 100644
@@ -2393,8 +2393,13 @@ static void blk_root_drained_begin(BdrvChild *child)
 static bool blk_root_drained_poll(BdrvChild *child)
 {
     BlockBackend *blk = child->opaque;
+    bool busy = false;
     assert(blk->quiesce_counter);
-    return !!blk->in_flight;
+
+    if (blk->dev_ops && blk->dev_ops->drained_poll) {
+        busy = blk->dev_ops->drained_poll(blk->dev_opaque);
+    }
+    return busy || !!blk->in_flight;
 }
 
 static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)
include/sysemu/block-backend.h +4 -0
index 880e903293..5423e3d9c6 100644
@@ -66,6 +66,10 @@ typedef struct BlockDevOps {
      * Runs when the backend's last drain request ends.
      */
     void (*drained_end)(void *opaque);
+    /*
+     * Is the device still busy?
+     */
+    bool (*drained_poll)(void *opaque);
 } BlockDevOps;
 
 /* This struct is embedded in (the private) BlockBackend struct and contains
Signature · 1 line
2.26.2
Reviewed-by on v2 1/2
#2 lore raw

Re: [PATCH v2 1/2] block-backend: add drained_poll

Quoted 10 lines · Sergio Lopez

Allow block backends to poll their devices/users to check if they have been quiesced when entering a drained section.

This will be used in the next patch to wait for the NBD server to be completely quiesced.

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

PATCH v2 2/2 nbd/server: Use drained block ops to quiesce the server

In reply to Sergio Lopez

Before switching between AioContexts we need to make sure that we're fully quiesced ("nb_requests == 0" for every client) when entering the drained section.

To do this, we set "quiescing = true" for every client on ".drained_begin" to prevent new coroutines from being created, and check if "nb_requests == 0" on ".drained_poll". Finally, once we're exiting the drained section, on ".drained_end" we set "quiescing = false" and call "nbd_client_receive_next_request()" to resume the processing of new requests.

With these changes, "blk_aio_attach()" and "blk_aio_detach()" can be reverted to be as simple as they were before f148ae7d36.

RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1960137

---
 nbd/server.c | 82 ++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 61 insertions(+), 21 deletions(-)
nbd/server.c +61 -21
index 86a44a9b41..b60ebc3ab6 100644
@@ -1513,6 +1513,11 @@ static void nbd_request_put(NBDRequestData *req)
     g_free(req);
 
     client->nb_requests--;
+
+    if (client->quiescing && client->nb_requests == 0) {
+        aio_wait_kick();
+    }
+
     nbd_client_receive_next_request(client);
 
     nbd_client_put(client);
@@ -1530,49 +1535,68 @@ static void blk_aio_attached(AioContext *ctx, void *opaque)
     QTAILQ_FOREACH(client, &exp->clients, next) {
         qio_channel_attach_aio_context(client->ioc, ctx);
 
+        assert(client->nb_requests == 0);
         assert(client->recv_coroutine == NULL);
         assert(client->send_coroutine == NULL);
-
-        if (client->quiescing) {
-            client->quiescing = false;
-            nbd_client_receive_next_request(client);
-        }
     }
 }
 
-static void nbd_aio_detach_bh(void *opaque)
+static void blk_aio_detach(void *opaque)
 {
     NBDExport *exp = opaque;
     NBDClient *client;
 
+    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+
     QTAILQ_FOREACH(client, &exp->clients, next) {
         qio_channel_detach_aio_context(client->ioc);
+    }
+
+    exp->common.ctx = NULL;
+}
+
+static void nbd_drained_begin(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
+
+    QTAILQ_FOREACH(client, &exp->clients, next) {
         client->quiescing = true;
+    }
+}
 
-        if (client->recv_coroutine) {
-            if (client->read_yielding) {
-                qemu_aio_coroutine_enter(exp->common.ctx,
-                                         client->recv_coroutine);
-            } else {
-                AIO_WAIT_WHILE(exp->common.ctx, client->recv_coroutine != NULL);
-            }
-        }
+static void nbd_drained_end(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
 
-        if (client->send_coroutine) {
-            AIO_WAIT_WHILE(exp->common.ctx, client->send_coroutine != NULL);
-        }
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        client->quiescing = false;
+        nbd_client_receive_next_request(client);
     }
 }
 
-static void blk_aio_detach(void *opaque)
+static bool nbd_drained_poll(void *opaque)
 {
     NBDExport *exp = opaque;
+    NBDClient *client;
 
-    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        if (client->nb_requests != 0) {
+            /*
+             * If there's a coroutine waiting for a request on nbd_read_eof()
+             * enter it here so we don't depend on the client to wake it up.
+             */
+            if (client->recv_coroutine != NULL && client->read_yielding) {
+                qemu_aio_coroutine_enter(exp->common.ctx,
+                                         client->recv_coroutine);
+            }
 
-    aio_wait_bh_oneshot(exp->common.ctx, nbd_aio_detach_bh, exp);
+            return true;
+        }
+    }
 
-    exp->common.ctx = NULL;
+    return false;
 }
 
 static void nbd_eject_notifier(Notifier *n, void *data)
@@ -1594,6 +1618,12 @@ void nbd_export_set_on_eject_blk(BlockExport *exp, BlockBackend *blk)
     blk_add_remove_bs_notifier(blk, &nbd_exp->eject_notifier);
 }
 
+static const BlockDevOps nbd_block_ops = {
+    .drained_begin = nbd_drained_begin,
+    .drained_end = nbd_drained_end,
+    .drained_poll = nbd_drained_poll,
+};
+
 static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
                              Error **errp)
 {
@@ -1715,8 +1745,17 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
 
     exp->allocation_depth = arg->allocation_depth;
 
+    /*
+     * We need to inhibit request queuing in the block layer to ensure we can
+     * be properly quiesced when entering a drained section, as our coroutines
+     * servicing pending requests might enter blk_pread().
+     */
+    blk_set_disable_request_queuing(blk, true);
+
     blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
 
+    blk_set_dev_ops(blk, &nbd_block_ops, exp);
+
     QTAILQ_INSERT_TAIL(&exports, exp, next);
 
     return 0;
@@ -1788,6 +1827,7 @@ static void nbd_export_delete(BlockExport *blk_exp)
         }
         blk_remove_aio_context_notifier(exp->common.blk, blk_aio_attached,
                                         blk_aio_detach, exp);
+        blk_set_disable_request_queuing(exp->common.blk, false);
     }
 
     for (i = 0; i < exp->nr_export_bitmaps; i++) {
Signature · 1 line
2.26.2
Reviewed-by on v2 2/2
#4 lore raw

Re: [PATCH v2 2/2] nbd/server: Use drained block ops to quiesce the server

Quoted 141 lines · Sergio Lopez

Before switching between AioContexts we need to make sure that we're fully quiesced ("nb_requests == 0" for every client) when entering the drained section.

To do this, we set "quiescing = true" for every client on ".drained_begin" to prevent new coroutines from being created, and check if "nb_requests == 0" on ".drained_poll". Finally, once we're exiting the drained section, on ".drained_end" we set "quiescing = false" and call "nbd_client_receive_next_request()" to resume the processing of new requests.

With these changes, "blk_aio_attach()" and "blk_aio_detach()" can be reverted to be as simple as they were before f148ae7d36.

RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1960137

---
  nbd/server.c | 82 ++++++++++++++++++++++++++++++++++++++--------------
  1 file changed, 61 insertions(+), 21 deletions(-)
nbd/server.c +51 -21
index 86a44a9b41..b60ebc3ab6 100644
@@ -1513,6 +1513,11 @@ static void nbd_request_put(NBDRequestData *req)
      g_free(req);
 
      client->nb_requests--;
+
+    if (client->quiescing && client->nb_requests == 0) {
+        aio_wait_kick();
+    }
+
      nbd_client_receive_next_request(client);
 
      nbd_client_put(client);
@@ -1530,49 +1535,68 @@ static void blk_aio_attached(AioContext *ctx, void *opaque)
      QTAILQ_FOREACH(client, &exp->clients, next) {
          qio_channel_attach_aio_context(client->ioc, ctx);
 
+        assert(client->nb_requests == 0);
          assert(client->recv_coroutine == NULL);
          assert(client->send_coroutine == NULL);
-
-        if (client->quiescing) {
-            client->quiescing = false;
-            nbd_client_receive_next_request(client);
-        }
      }
  }
 
-static void nbd_aio_detach_bh(void *opaque)
+static void blk_aio_detach(void *opaque)
  {
      NBDExport *exp = opaque;
      NBDClient *client;
 
+    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+
      QTAILQ_FOREACH(client, &exp->clients, next) {
          qio_channel_detach_aio_context(client->ioc);
+    }
+
+    exp->common.ctx = NULL;
+}
+
+static void nbd_drained_begin(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
+
+    QTAILQ_FOREACH(client, &exp->clients, next) {
          client->quiescing = true;
+    }
+}
 
-        if (client->recv_coroutine) {
-            if (client->read_yielding) {
-                qemu_aio_coroutine_enter(exp->common.ctx,
-                                         client->recv_coroutine);
-            } else {
-                AIO_WAIT_WHILE(exp->common.ctx, client->recv_coroutine != NULL);
-            }
-        }
+static void nbd_drained_end(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
 
-        if (client->send_coroutine) {
-            AIO_WAIT_WHILE(exp->common.ctx, client->send_coroutine != NULL);
-        }
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        client->quiescing = false;
+        nbd_client_receive_next_request(client);
      }
  }
 
-static void blk_aio_detach(void *opaque)
+static bool nbd_drained_poll(void *opaque)
  {
      NBDExport *exp = opaque;
+    NBDClient *client;
 
-    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        if (client->nb_requests != 0) {
+            /*
+             * If there's a coroutine waiting for a request on nbd_read_eof()
+             * enter it here so we don't depend on the client to wake it up.
+             */
+            if (client->recv_coroutine != NULL && client->read_yielding) {
+                qemu_aio_coroutine_enter(exp->common.ctx,
+                                         client->recv_coroutine);
+            }
 
-    aio_wait_bh_oneshot(exp->common.ctx, nbd_aio_detach_bh, exp);
+            return true;
+        }
+    }
 
-    exp->common.ctx = NULL;
+    return false;
  }
 
  static void nbd_eject_notifier(Notifier *n, void *data)
@@ -1594,6 +1618,12 @@ void nbd_export_set_on_eject_blk(BlockExport *exp, BlockBackend *blk)
      blk_add_remove_bs_notifier(blk, &nbd_exp->eject_notifier);
  }
 
+static const BlockDevOps nbd_block_ops = {
+    .drained_begin = nbd_drained_begin,
+    .drained_end = nbd_drained_end,
+    .drained_poll = nbd_drained_poll,
+};
+
  static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
                               Error **errp)
  {

nbd/server.c static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args, · line 1752

Quoted 8 lines
nbd/server.c +5 -0
@@ -1715,8 +1745,17 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
 
      exp->allocation_depth = arg->allocation_depth;
 
+    /*
+     * We need to inhibit request queuing in the block layer to ensure we can
+     * be properly quiesced when entering a drained section, as our coroutines
+     * servicing pending requests might enter blk_pread().
+     */

Not very understandable to me :(. What's bad in queuing requests at blk layer during drained section?

Quoted 11 lines
nbd/server.c +4 -0
+    blk_set_disable_request_queuing(blk, true);
+
      blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
 
+    blk_set_dev_ops(blk, &nbd_block_ops, exp);
+
      QTAILQ_INSERT_TAIL(&exports, exp, next);
 
      return 0;

nbd/server.c static void nbd_export_delete(BlockExport *blk_exp) · line 1833

Quoted 7 lines
nbd/server.c +1 -0
@@ -1788,6 +1827,7 @@ static void nbd_export_delete(BlockExport *blk_exp)
          }
          blk_remove_aio_context_notifier(exp->common.blk, blk_aio_attached,
                                          blk_aio_detach, exp);
+        blk_set_disable_request_queuing(exp->common.blk, false);
      }
 
      for (i = 0; i < exp->nr_export_bitmaps; i++) {

I don't follow the whole logic of clients quiescing, but overall looks good to me. As I understand, prior to patch we have a kind of drain_begin realization in blk_aio_detach handler, and after patch we instead utilize generic code of drained sections with help of appropriate devops handlers.

weak:

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

Re: [PATCH v2 2/2] nbd/server: Use drained block ops to quiesce the server

Quoted 129 lines · Vladimir Sementsov-Ogievskiy
Quoted 128 lines · Sergio Lopez

Before switching between AioContexts we need to make sure that we're fully quiesced ("nb_requests == 0" for every client) when entering the drained section.

To do this, we set "quiescing = true" for every client on ".drained_begin" to prevent new coroutines from being created, and check if "nb_requests == 0" on ".drained_poll". Finally, once we're exiting the drained section, on ".drained_end" we set "quiescing = false" and call "nbd_client_receive_next_request()" to resume the processing of new requests.

With these changes, "blk_aio_attach()" and "blk_aio_detach()" can be reverted to be as simple as they were before f148ae7d36.

RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1960137

---
  nbd/server.c | 82 ++++++++++++++++++++++++++++++++++++++--------------
  1 file changed, 61 insertions(+), 21 deletions(-)
nbd/server.c +51 -21
index 86a44a9b41..b60ebc3ab6 100644
@@ -1513,6 +1513,11 @@ static void nbd_request_put(NBDRequestData *req)
      g_free(req);
      client->nb_requests--;
+
+    if (client->quiescing && client->nb_requests == 0) {
+        aio_wait_kick();
+    }
+
      nbd_client_receive_next_request(client);
      nbd_client_put(client);
@@ -1530,49 +1535,68 @@ static void blk_aio_attached(AioContext *ctx, void *opaque)
      QTAILQ_FOREACH(client, &exp->clients, next) {
          qio_channel_attach_aio_context(client->ioc, ctx);
+        assert(client->nb_requests == 0);
          assert(client->recv_coroutine == NULL);
          assert(client->send_coroutine == NULL);
-
-        if (client->quiescing) {
-            client->quiescing = false;
-            nbd_client_receive_next_request(client);
-        }
      }
  }
-static void nbd_aio_detach_bh(void *opaque)
+static void blk_aio_detach(void *opaque)
  {
      NBDExport *exp = opaque;
      NBDClient *client;
+    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+
      QTAILQ_FOREACH(client, &exp->clients, next) {
          qio_channel_detach_aio_context(client->ioc);
+    }
+
+    exp->common.ctx = NULL;
+}
+
+static void nbd_drained_begin(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
+
+    QTAILQ_FOREACH(client, &exp->clients, next) {
          client->quiescing = true;
+    }
+}
-        if (client->recv_coroutine) {
-            if (client->read_yielding) {
-                qemu_aio_coroutine_enter(exp->common.ctx,
-                                         client->recv_coroutine);
-            } else {
-                AIO_WAIT_WHILE(exp->common.ctx, client->recv_coroutine != NULL);
-            }
-        }
+static void nbd_drained_end(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
-        if (client->send_coroutine) {
-            AIO_WAIT_WHILE(exp->common.ctx, client->send_coroutine != NULL);
-        }
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        client->quiescing = false;
+        nbd_client_receive_next_request(client);
      }
  }
-static void blk_aio_detach(void *opaque)
+static bool nbd_drained_poll(void *opaque)
  {
      NBDExport *exp = opaque;
+    NBDClient *client;
-    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        if (client->nb_requests != 0) {
+            /*
+             * If there's a coroutine waiting for a request on nbd_read_eof()
+             * enter it here so we don't depend on the client to wake it up.
+             */
+            if (client->recv_coroutine != NULL && client->read_yielding) {
+                qemu_aio_coroutine_enter(exp->common.ctx,
+                                         client->recv_coroutine);
+            }
-    aio_wait_bh_oneshot(exp->common.ctx, nbd_aio_detach_bh, exp);
+            return true;
+        }
+    }
-    exp->common.ctx = NULL;
+    return false;
  }
  static void nbd_eject_notifier(Notifier *n, void *data)
@@ -1594,6 +1618,12 @@ void nbd_export_set_on_eject_blk(BlockExport *exp, BlockBackend *blk)
      blk_add_remove_bs_notifier(blk, &nbd_exp->eject_notifier);
  }
+static const BlockDevOps nbd_block_ops = {
+    .drained_begin = nbd_drained_begin,
+    .drained_end = nbd_drained_end,
+    .drained_poll = nbd_drained_poll,
+};
+
  static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
                               Error **errp)
  {
@@ -1715,8 +1745,17 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
Quoted 8 lines

nbd/server.c static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args, · line 1752

Quoted 6 lines
nbd/server.c +5 -0
      exp->allocation_depth = arg->allocation_depth;
+    /*
+     * We need to inhibit request queuing in the block layer to ensure we can
+     * be properly quiesced when entering a drained section, as our coroutines
+     * servicing pending requests might enter blk_pread().
+     */

Not very understandable to me :(. What's bad in queuing requests at blk layer during drained section?

We need to make sure that all coroutines in the NBD server have finished (client->nb_requests == 0) before detaching from the AioContext. If we don't inhibit request queuing, some coroutines may get stuck in blk_pread()->...->blk_wait_while_drained(), causing nbd_drained_poll() to always return that we're busy.

Quoted 9 lines
Quoted 9 lines
nbd/server.c +4 -0
+    blk_set_disable_request_queuing(blk, true);
+
      blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
+    blk_set_dev_ops(blk, &nbd_block_ops, exp);
+
      QTAILQ_INSERT_TAIL(&exports, exp, next);
      return 0;
@@ -1788,6 +1827,7 @@ static void nbd_export_delete(BlockExport *blk_exp)
          }
Quoted 8 lines

nbd/server.c static void nbd_export_delete(BlockExport *blk_exp)

Quoted 6 lines
nbd/server.c +1 -0
          blk_remove_aio_context_notifier(exp->common.blk, blk_aio_attached,
                                          blk_aio_detach, exp);
+        blk_set_disable_request_queuing(exp->common.blk, false);
      }
      for (i = 0; i < exp->nr_export_bitmaps; i++) {
 

I don't follow the whole logic of clients quiescing, but overall looks good to me. As I understand, prior to patch we have a kind of drain_begin realization in blk_aio_detach handler, and after patch we instead utilize generic code of drained sections with help of appropriate devops handlers.

Doing that in blk_aio_detach() was a bit too late since we were already in the drained section, and as stated above, we need it alive to ensure that all of the NBD server coroutines finish properly.

Also, .drained_poll allows us to align quiescing the NBD server with the block layer.

Thanks,
Sergio.

Quoted 9 lines

weak:

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

Re: [PATCH v2 2/2] nbd/server: Use drained block ops to quiesce the server

Quoted 139 lines · Sergio Lopez
Quoted 129 lines · Vladimir Sementsov-Ogievskiy
Quoted 128 lines · Sergio Lopez

Before switching between AioContexts we need to make sure that we're fully quiesced ("nb_requests == 0" for every client) when entering the drained section.

To do this, we set "quiescing = true" for every client on ".drained_begin" to prevent new coroutines from being created, and check if "nb_requests == 0" on ".drained_poll". Finally, once we're exiting the drained section, on ".drained_end" we set "quiescing = false" and call "nbd_client_receive_next_request()" to resume the processing of new requests.

With these changes, "blk_aio_attach()" and "blk_aio_detach()" can be reverted to be as simple as they were before f148ae7d36.

RHBZ: https://bugzilla.redhat.com/show_bug.cgi?id=1960137

---
   nbd/server.c | 82 ++++++++++++++++++++++++++++++++++++++--------------
   1 file changed, 61 insertions(+), 21 deletions(-)
nbd/server.c +51 -21
index 86a44a9b41..b60ebc3ab6 100644
@@ -1513,6 +1513,11 @@ static void nbd_request_put(NBDRequestData *req)
       g_free(req);
       client->nb_requests--;
+
+    if (client->quiescing && client->nb_requests == 0) {
+        aio_wait_kick();
+    }
+
       nbd_client_receive_next_request(client);
       nbd_client_put(client);
@@ -1530,49 +1535,68 @@ static void blk_aio_attached(AioContext *ctx, void *opaque)
       QTAILQ_FOREACH(client, &exp->clients, next) {
           qio_channel_attach_aio_context(client->ioc, ctx);
+        assert(client->nb_requests == 0);
           assert(client->recv_coroutine == NULL);
           assert(client->send_coroutine == NULL);
-
-        if (client->quiescing) {
-            client->quiescing = false;
-            nbd_client_receive_next_request(client);
-        }
       }
   }
-static void nbd_aio_detach_bh(void *opaque)
+static void blk_aio_detach(void *opaque)
   {
       NBDExport *exp = opaque;
       NBDClient *client;
+    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+
       QTAILQ_FOREACH(client, &exp->clients, next) {
           qio_channel_detach_aio_context(client->ioc);
+    }
+
+    exp->common.ctx = NULL;
+}
+
+static void nbd_drained_begin(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
+
+    QTAILQ_FOREACH(client, &exp->clients, next) {
           client->quiescing = true;
+    }
+}
-        if (client->recv_coroutine) {
-            if (client->read_yielding) {
-                qemu_aio_coroutine_enter(exp->common.ctx,
-                                         client->recv_coroutine);
-            } else {
-                AIO_WAIT_WHILE(exp->common.ctx, client->recv_coroutine != NULL);
-            }
-        }
+static void nbd_drained_end(void *opaque)
+{
+    NBDExport *exp = opaque;
+    NBDClient *client;
-        if (client->send_coroutine) {
-            AIO_WAIT_WHILE(exp->common.ctx, client->send_coroutine != NULL);
-        }
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        client->quiescing = false;
+        nbd_client_receive_next_request(client);
       }
   }
-static void blk_aio_detach(void *opaque)
+static bool nbd_drained_poll(void *opaque)
   {
       NBDExport *exp = opaque;
+    NBDClient *client;
-    trace_nbd_blk_aio_detach(exp->name, exp->common.ctx);
+    QTAILQ_FOREACH(client, &exp->clients, next) {
+        if (client->nb_requests != 0) {
+            /*
+             * If there's a coroutine waiting for a request on nbd_read_eof()
+             * enter it here so we don't depend on the client to wake it up.
+             */
+            if (client->recv_coroutine != NULL && client->read_yielding) {
+                qemu_aio_coroutine_enter(exp->common.ctx,
+                                         client->recv_coroutine);
+            }
-    aio_wait_bh_oneshot(exp->common.ctx, nbd_aio_detach_bh, exp);
+            return true;
+        }
+    }
-    exp->common.ctx = NULL;
+    return false;
   }
   static void nbd_eject_notifier(Notifier *n, void *data)
@@ -1594,6 +1618,12 @@ void nbd_export_set_on_eject_blk(BlockExport *exp, BlockBackend *blk)
       blk_add_remove_bs_notifier(blk, &nbd_exp->eject_notifier);
   }
+static const BlockDevOps nbd_block_ops = {
+    .drained_begin = nbd_drained_begin,
+    .drained_end = nbd_drained_end,
+    .drained_poll = nbd_drained_poll,
+};
+
   static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
                                Error **errp)
   {
@@ -1715,8 +1745,17 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
Quoted 8 lines

nbd/server.c static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args, · line 1752

Quoted 6 lines
nbd/server.c +5 -0
       exp->allocation_depth = arg->allocation_depth;
+    /*
+     * We need to inhibit request queuing in the block layer to ensure we can
+     * be properly quiesced when entering a drained section, as our coroutines
+     * servicing pending requests might enter blk_pread().
+     */

Not very understandable to me :(. What's bad in queuing requests at blk layer during drained section?

Quoted 5 lines

We need to make sure that all coroutines in the NBD server have finished (client->nb_requests == 0) before detaching from the AioContext. If we don't inhibit request queuing, some coroutines may get stuck in blk_pread()->...->blk_wait_while_drained(), causing nbd_drained_poll() to always return that we're busy.

Ah, OK. Thanks for explanation.

Quoted 38 lines
Quoted 10 lines
Quoted 10 lines
nbd/server.c +4 -0
+    blk_set_disable_request_queuing(blk, true);
+
       blk_add_aio_context_notifier(blk, blk_aio_attached, blk_aio_detach, exp);
+    blk_set_dev_ops(blk, &nbd_block_ops, exp);
+
       QTAILQ_INSERT_TAIL(&exports, exp, next);
       return 0;
@@ -1788,6 +1827,7 @@ static void nbd_export_delete(BlockExport *blk_exp)
           }
Quoted 8 lines

nbd/server.c static void nbd_export_delete(BlockExport *blk_exp)

Quoted 6 lines
nbd/server.c +1 -0
           blk_remove_aio_context_notifier(exp->common.blk, blk_aio_attached,
                                           blk_aio_detach, exp);
+        blk_set_disable_request_queuing(exp->common.blk, false);
       }
       for (i = 0; i < exp->nr_export_bitmaps; i++) {
 

I don't follow the whole logic of clients quiescing, but overall looks good to me. As I understand, prior to patch we have a kind of drain_begin realization in blk_aio_detach handler, and after patch we instead utilize generic code of drained sections with help of appropriate devops handlers.

Doing that in blk_aio_detach() was a bit too late since we were already in the drained section, and as stated above, we need it alive to ensure that all of the NBD server coroutines finish properly.

Also, .drained_poll allows us to align quiescing the NBD server with the block layer.

Thanks,
Sergio.

Quoted 9 lines

weak:

Signature · 2 lines
Best regards,
Vladimir
Signature · 2 lines
Best regards,
Vladimir
Applied
#7 lore raw
In reply to Sergio Lopez

Am 02.06.2021 um 08:05 hat Sergio Lopez geschrieben:

Quoted 10 lines

Before switching between AioContexts we need to make sure that we're fully quiesced ("nb_requests == 0" for every client) when entering the drained section. Otherwise, coroutines may be run in the wrong context after the switch, leading to a number of critical issues.

To accomplish this, we add ".drained_poll" to BlockDevOps and use it in the NBD server, along with ".drained_being" and "drained_end", to coordinate the quiescing of the server while entering a drained section.

Quoted 7 lines

v2:
- Use a bool for the value returned by .drained_poll [Kevin]
- Change .drained_poll comment to reflect that the returned boolean value will be true if the device is still busy, or false otherwise
- Drop yield_co_list and use recv_coroutine and read_yielding [Kevin]
- Return "true" or "false" in nbd_drained_poll [Kevin]
- Fix grammar in the commit message of patch 2 [Eric]

Thanks, applied to the block branch.

Kevin