Skip to contentSkip to conversation

Avoid NBD crash on nbd-server-stop

PATCH In review Eric Blake 2 participants 8 messages Aug 2, 2024 – Aug 6, 2024

lore
Share & tools
lore

Eric Blake

author
#0 lore raw

v2 cover Avoid NBD crash on nbd-server-stop

v1 was here:
https://lists.gnu.org/archive/html/qemu-devel/2024-06/msg01609.html

Since then, I've applied with Red Hat to get a CVE assigned (a client not using TLS should never be able to cause the destination qemu to crash during live storage migration), and will update to include that number once it is assigned. But since the issue has already been on list, I see no need to further embargo this patch attempt.

I've also concluded from my audit that Alexander's initial hunch was
right: there's nothing simple we can do to prevent qio coroutines from reaching our callback into nbd_blockdev_client_closed() after a QMP nbd-server-stop (I could not find a graceful way to close the qio channel and then forcefully wait for the coroutine to finish), so that function has to be prepared to handle late clients, but the fix in patch 1 is a bit more involved than Alexander's attempt since we must also not corrupt a subsequent nbd-server-start. Patch 2 is insufficient on its own to prevent the problems, but reduces the amount of time that a client can hang on to server resources after nbd-server-stop (the client will see EPIPE rather than being able to carry on a prolonged NBD_OPT_* conversation).

[I'm also aware of some Coverity analysis pointing to potential race conditions in block/nbd.c; if those need fixes, I hope to also post patches for those in time for inclusion in the same pull request that picks up this series]

Eric Blake (3):
nbd: CVE-XXX: Use cookie to track generation of nbd-server
nbd: CVE-XXX: Close stray client sockets at server shutdown
nbd: Minor style fixes

 include/block/nbd.h |  3 ++-
 blockdev-nbd.c      | 39 ++++++++++++++++++++++++++++++++++-----
 nbd/server.c        | 14 +++++++++-----
 qemu-nbd.c          |  8 +++++---
 4 files changed, 50 insertions(+), 14 deletions(-)
Signature · 1 line
2.45.2
author
#1 lore raw

PATCH v2 1/3 nbd: CVE-XXX: Use cookie to track generation of nbd-server

As part of the QMP command nbd-server-start, the blockdev code was creating a single global nbd_server object, and telling the qio code to accept one or more client connections to the exposed listener socket. But even though we tear down the listener socket during a subsequent QMP nbd-server-stop, the qio code has handed off to a coroutine that may be executing asynchronously with the server shutdown, such that a client that connects to the socket before nbd-server-stop but delays disconnect or completion of the NBD handshake until after the followup QMP command can result in the nbd_blockdev_client_closed() callback running after nbd_server has already been torn down, causing a SEGV. Worse, if a second nbd_server object is created (possibly on a different socket address), a late client resolution from the first server can subtly interfere with the second server. This can be abused by a malicious client that does not know TLS secrets to cause qemu to SEGV after a legitimate client has concluded storage migration to a destination qemu, which can be turned into a denial of service attack even when qemu is set up to require only TLS clients.

For environments without this patch, the CVE can be mitigated by ensuring (such as via a firewall) that only trusted clients can connect to an NBD server; using frameworks like libvirt that ensure that nbd-server-stop is not executed while any trusted clients are still connected will only help if there is also no possibility for an untrusted client to open a connection but then stall on the NBD handshake.

Fix this by passing a cookie through to each client connection (whether or not that client actually knows the TLS details to successfully negotiate); then increment the cookie every time a server is torn down so that we can recognize any late client actions lingering from an old server.

This patch does not address the fact that client sockets can be left open indefinitely after the server is torn down (possibly creating a resource leak, if a malicious client intentionally leaves lots of open sockets paused partway through NBD negotiation); the next patch will add some code to forcefully close any lingering clients as soon as possible when the server is torn down.

---
 include/block/nbd.h |  3 ++-
 blockdev-nbd.c      | 17 ++++++++++++-----
 nbd/server.c        | 12 ++++++++----
 qemu-nbd.c          |  5 +++--
 4 files changed, 25 insertions(+), 12 deletions(-)
include/block/nbd.h +2 -1
index 4e7bd6342f9..9c43bcf8a26 100644
@@ -405,7 +405,8 @@ NBDExport *nbd_export_find(const char *name);
 void nbd_client_new(QIOChannelSocket *sioc,
                     QCryptoTLSCreds *tlscreds,
                     const char *tlsauthz,
-                    void (*close_fn)(NBDClient *, bool));
+                    void (*close_fn)(NBDClient *, uint32_t, bool),
+                    uint32_t cookie);
 void nbd_client_get(NBDClient *client);
 void nbd_client_put(NBDClient *client);
 
blockdev-nbd.c +12 -5
index 213012435f4..1ddcbd7b247 100644
@@ -30,6 +30,7 @@ typedef struct NBDServerData {
 } NBDServerData;
 
 static NBDServerData *nbd_server;
+static uint32_t nbd_cookie; /* Generation count of nbd_server */
 static int qemu_nbd_connections = -1; /* Non-negative if this is qemu-nbd */
 
 static void nbd_update_server_watch(NBDServerData *s);
@@ -49,23 +50,28 @@ int nbd_server_max_connections(void)
     return nbd_server ? nbd_server->max_connections : qemu_nbd_connections;
 }
 
-static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
+static void nbd_blockdev_client_closed(NBDClient *client, uint32_t cookie,
+                                       bool ignored)
 {
     nbd_client_put(client);
-    assert(nbd_server->connections > 0);
-    nbd_server->connections--;
-    nbd_update_server_watch(nbd_server);
+    /* Ignore any (late) connection made under a previous server */
+    if (cookie == nbd_cookie) {
+        assert(nbd_server->connections > 0);
+        nbd_server->connections--;
+        nbd_update_server_watch(nbd_server);
+    }
 }
 
 static void nbd_accept(QIONetListener *listener, QIOChannelSocket *cioc,
                        gpointer opaque)
 {
+    assert(nbd_server);
     nbd_server->connections++;
     nbd_update_server_watch(nbd_server);
 
     qio_channel_set_name(QIO_CHANNEL(cioc), "nbd-server");
     nbd_client_new(cioc, nbd_server->tlscreds, nbd_server->tlsauthz,
-                   nbd_blockdev_client_closed);
+                   nbd_blockdev_client_closed, nbd_cookie);
 }
 
 static void nbd_update_server_watch(NBDServerData *s)
@@ -89,6 +95,7 @@ static void nbd_server_free(NBDServerData *server)
         object_unref(OBJECT(server->tlscreds));
     }
     g_free(server->tlsauthz);
+    nbd_cookie++;
 
     g_free(server);
 }
nbd/server.c +8 -4
index 892797bb111..7c37d9753f0 100644
@@ -123,7 +123,8 @@ struct NBDMetaContexts {
 
 struct NBDClient {
     int refcount; /* atomic */
-    void (*close_fn)(NBDClient *client, bool negotiated);
+    void (*close_fn)(NBDClient *client, uint32_t cookie, bool negotiated);
+    uint32_t close_cookie;
 
     QemuMutex lock;
 
@@ -1621,7 +1622,7 @@ static void client_close(NBDClient *client, bool negotiated)
 
     /* Also tell the client, so that they release their reference.  */
     if (client->close_fn) {
-        client->close_fn(client, negotiated);
+        client->close_fn(client, client->close_cookie, negotiated);
     }
 }
 
@@ -3207,12 +3208,14 @@ static coroutine_fn void nbd_co_client_start(void *opaque)
 /*
  * Create a new client listener using the given channel @sioc.
  * Begin servicing it in a coroutine.  When the connection closes, call
- * @close_fn with an indication of whether the client completed negotiation.
+ * @close_fn with @cookie and an indication of whether the client completed
+ # negotiation.
  */
 void nbd_client_new(QIOChannelSocket *sioc,
                     QCryptoTLSCreds *tlscreds,
                     const char *tlsauthz,
-                    void (*close_fn)(NBDClient *, bool))
+                    void (*close_fn)(NBDClient *, uint32_t, bool),
+                    uint32_t cookie)
 {
     NBDClient *client;
     Coroutine *co;
@@ -3231,6 +3234,7 @@ void nbd_client_new(QIOChannelSocket *sioc,
     client->ioc = QIO_CHANNEL(sioc);
     object_ref(OBJECT(client->ioc));
     client->close_fn = close_fn;
+    client->close_cookie = cookie;
 
     co = qemu_coroutine_create(nbd_co_client_start, client);
     qemu_coroutine_enter(co);
qemu-nbd.c +3 -2
index d7b3ccab21c..3ad50eec18e 100644
@@ -371,7 +371,8 @@ static int nbd_can_accept(void)
 
 static void nbd_update_server_watch(void);
 
-static void nbd_client_closed(NBDClient *client, bool negotiated)
+static void nbd_client_closed(NBDClient *client, uint32_t ignored,
+                              bool negotiated)
 {
     nb_fds--;
     if (negotiated && nb_fds == 0 && !persistent && state == RUNNING) {
@@ -390,7 +391,7 @@ static void nbd_accept(QIONetListener *listener, QIOChannelSocket *cioc,
 
     nb_fds++;
     nbd_update_server_watch();
-    nbd_client_new(cioc, tlscreds, tlsauthz, nbd_client_closed);
+    nbd_client_new(cioc, tlscreds, tlsauthz, nbd_client_closed, 0);
 }
 
 static void nbd_update_server_watch(void)
Signature · 1 line
2.45.2
author
#2 lore raw

Re: [PATCH v2 1/3] nbd: CVE-XXX: Use cookie to track generation of nbd-server

Quoted 10 lines · Eric Blake

As part of the QMP command nbd-server-start, the blockdev code was creating a single global nbd_server object, and telling the qio code to accept one or more client connections to the exposed listener socket. But even though we tear down the listener socket during a subsequent QMP nbd-server-stop, the qio code has handed off to a coroutine that may be executing asynchronously with the server shutdown, such that a client that connects to the socket before nbd-server-stop but delays disconnect or completion of the NBD handshake until after the followup QMP command can result in the nbd_blockdev_client_closed() callback running after nbd_server has

Quoted 8 lines

already been torn down, causing a SEGV. Worse, if a second nbd_server object is created (possibly on a different socket address), a late client resolution from the first server can subtly interfere with the second server. This can be abused by a malicious client that does not know TLS secrets to cause qemu to SEGV after a legitimate client has concluded storage migration to a destination qemu, which can be turned into a denial of service attack even when qemu is set up to require only TLS clients.

Now assigned CVE-2024-7409; I'll make sure that is mentioned in the commit message, whether a v2 is needed or whether this gets a positive review as-is modulo the reference.

I have not (yet?) determined how long the bug has existed, but note that the code in question appears unchanged since at least qemu 6.0 (from 2021), and probably predates that, so it is long-standing.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.
Virtualization:  qemu.org | libguestfs.org
#3 lore raw

Re: [PATCH v2 1/3] nbd: CVE-XXX: Use cookie to track generation of nbd-server

In reply to Eric Blake
Quoted 43 lines · Eric Blake

As part of the QMP command nbd-server-start, the blockdev code was creating a single global nbd_server object, and telling the qio code to accept one or more client connections to the exposed listener socket. But even though we tear down the listener socket during a subsequent QMP nbd-server-stop, the qio code has handed off to a coroutine that may be executing asynchronously with the server shutdown, such that a client that connects to the socket before nbd-server-stop but delays disconnect or completion of the NBD handshake until after the followup QMP command can result in the nbd_blockdev_client_closed() callback running after nbd_server has already been torn down, causing a SEGV. Worse, if a second nbd_server object is created (possibly on a different socket address), a late client resolution from the first server can subtly interfere with the second server. This can be abused by a malicious client that does not know TLS secrets to cause qemu to SEGV after a legitimate client has concluded storage migration to a destination qemu, which can be turned into a denial of service attack even when qemu is set up to require only TLS clients.

For environments without this patch, the CVE can be mitigated by ensuring (such as via a firewall) that only trusted clients can connect to an NBD server; using frameworks like libvirt that ensure that nbd-server-stop is not executed while any trusted clients are still connected will only help if there is also no possibility for an untrusted client to open a connection but then stall on the NBD handshake.

Fix this by passing a cookie through to each client connection (whether or not that client actually knows the TLS details to successfully negotiate); then increment the cookie every time a server is torn down so that we can recognize any late client actions lingering from an old server.

This patch does not address the fact that client sockets can be left open indefinitely after the server is torn down (possibly creating a resource leak, if a malicious client intentionally leaves lots of open sockets paused partway through NBD negotiation); the next patch will add some code to forcefully close any lingering clients as soon as possible when the server is torn down.

---

[..]

blockdev-nbd.c int nbd_server_max_connections(void) · line 58

Quoted 10 lines
blockdev-nbd.c +4 -4
-static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
+static void nbd_blockdev_client_closed(NBDClient *client, uint32_t cookie,
+                                       bool ignored)
  {
      nbd_client_put(client);
-    assert(nbd_server->connections > 0);
-    nbd_server->connections--;
-    nbd_update_server_watch(nbd_server);
+    /* Ignore any (late) connection made under a previous server */
+    if (cookie == nbd_cookie) {

creating a getter nbd_client_get_cookie(client), and use it instead of passing together with client, will simplify the patch a lot. [*]

Hmm.. don't we need some atomic accessors for nbd_cookie? and for nbs_server->connections.. The function is called from client, which live in coroutine and maybe in another thread? At least client code do atomic accesses of client->refcount..

Quoted 6 lines
blockdev-nbd.c +4 -0
+        assert(nbd_server->connections > 0);
+        nbd_server->connections--;
+        nbd_update_server_watch(nbd_server);
+    }
  }

[..]

nbd/server.c static void client_close(NBDClient *client, bool negotiated) · line 1625

Quoted 6 lines
nbd/server.c +1 -1
@@ -1621,7 +1622,7 @@ static void client_close(NBDClient *client, bool negotiated)
 
      /* Also tell the client, so that they release their reference.  */
      if (client->close_fn) {
-        client->close_fn(client, negotiated);
+        client->close_fn(client, client->close_cookie, negotiated);

[*] passing client->close_cokkie together with client itself looks like we lack a getter for .close_cookie

Review static void client_close(NBDClient *client, bool negotiated) · line 1628

Quoted 3 lines
(quoted diff) +0 -0
      }
  }
 

[..]

Hmm, instead of cookies and additional NBDConn objects in the next patch, could we simply have a list of connected NBDClient objects in NBDServer and link to NBDServer in NBDClient? (Ok we actually don't have NBDServer, but NBDServerData in qemu, and several global variables in qemu-nbd, so some refactoring is needed, to put common state to NBDServer, and add clients list to it)

This way, in nbd_server_free we'll just call client_close() in a loop. And in client_close we'll have nbd_server_client_detach(client->server, client), instead of client->close_fn(...). And server is freed only after all clients are closed. And client never try to detach from another server.

This way, we also may implement several NBD servers working simultaneously if we want.

Signature · 2 lines
Best regards,
Vladimir
author
#4 lore raw

Re: [PATCH v2 1/3] nbd: CVE-XXX: Use cookie to track generation of nbd-server

Quoted 4 lines · Vladimir Sementsov-Ogievskiy

On 02.08.24 04:32, Eric Blake wrote:

[..]

Quoted 12 lines

blockdev-nbd.c int nbd_server_max_connections(void) · line 58

Quoted 10 lines
blockdev-nbd.c +4 -4
-static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
+static void nbd_blockdev_client_closed(NBDClient *client, uint32_t cookie,
+                                       bool ignored)
  {
      nbd_client_put(client);
-    assert(nbd_server->connections > 0);
-    nbd_server->connections--;
-    nbd_update_server_watch(nbd_server);
+    /* Ignore any (late) connection made under a previous server */
+    if (cookie == nbd_cookie) {

creating a getter nbd_client_get_cookie(client), and use it instead of passing together with client, will simplify the patch a lot. [*]

I may be able to avoid the cookie altogether if I can add an AIO_WAIT_WHILE(, nbd_server->connections > 0) after forcefully closing all of the client sockets (nbd_client_new _should_ progress pretty rapidly towards eventually calling nbd_blockdev_client_closed once the socket is closed) - but that still requires patch 2 to keep a list of open clients.

Quoted 12 lines

Hmm.. don't we need some atomic accessors for nbd_cookie? and for nbs_server->connections.. The function is called from client, which live in coroutine and maybe in another thread? At least client code do atomic accesses of client->refcount..

Quoted 6 lines
blockdev-nbd.c +4 -0
+        assert(nbd_server->connections > 0);
+        nbd_server->connections--;
+        nbd_update_server_watch(nbd_server);
+    }
  }

[..]

Quoted 8 lines

nbd/server.c static void client_close(NBDClient *client, bool negotiated) · line 1625

Quoted 6 lines
nbd/server.c +1 -1
@@ -1621,7 +1622,7 @@ static void client_close(NBDClient *client, bool negotiated)
 
      /* Also tell the client, so that they release their reference.  */
      if (client->close_fn) {
-        client->close_fn(client, negotiated);
+        client->close_fn(client, client->close_cookie, negotiated);

[*] passing client->close_cokkie together with client itself looks like we lack a getter for .close_cookie

Whether the cookie be a uint32_t or the void* server object itself, it is opaque to the client, but the server needs to track something.

Quoted 5 lines

Review static void client_close(NBDClient *client, bool negotiated) · line 1628

Quoted 4 lines
(quoted diff) +0 -0
      }
  }
 
Quoted 8 lines

[..]

Hmm, instead of cookies and additional NBDConn objects in the next patch, could we simply have a list of connected NBDClient objects in NBDServer and link to NBDServer in NBDClient? (Ok we actually don't have NBDServer, but NBDServerData in qemu, and several global variables in qemu-nbd, so some refactoring is needed, to put common state to NBDServer, and add clients list to it)

This way, in nbd_server_free we'll just call client_close() in a loop. And in client_close we'll have nbd_server_client_detach(client->server, client), instead of client->close_fn(...). And server is freed only after all clients are closed. And client never try to detach from another server.

This way, we also may implement several NBD servers working simultaneously if we want.

Yes, we do eventually want to get to the point of being able to open parallel NBD servers on different ports simultaneously, at which point having a client remember which server it is associated makes sense (so at a bare minimum, pass in a void* instead of a uint32_t to nbd_client_new). And given that we can have an NBD server with more than one export, and with exports running in different threads (if multithread io is enabled), I probably also need to add missing locking to protect nbd_server (whether or not it stays global or we eventually reach the point of having parallel servers on separate ports).

Looks like I have work cut out for me before posting a v3.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.
Virtualization:  qemu.org | libguestfs.org
author
#5 lore raw

Re: [PATCH v2 1/3] nbd: CVE-XXX: Use cookie to track generation of nbd-server

In reply to Vladimir Sementsov-Ogievskiy
Quoted 13 lines · Vladimir Sementsov-Ogievskiy

blockdev-nbd.c int nbd_server_max_connections(void) · line 58

Quoted 10 lines
blockdev-nbd.c +4 -4
-static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
+static void nbd_blockdev_client_closed(NBDClient *client, uint32_t cookie,
+                                       bool ignored)
  {
      nbd_client_put(client);
-    assert(nbd_server->connections > 0);
-    nbd_server->connections--;
-    nbd_update_server_watch(nbd_server);
+    /* Ignore any (late) connection made under a previous server */
+    if (cookie == nbd_cookie) {

creating a getter nbd_client_get_cookie(client), and use it instead of passing together with client, will simplify the patch a lot. [*]

Quoted 5 lines

Hmm.. don't we need some atomic accessors for nbd_cookie? and for nbs_server->connections.. The function is called from client, which live in coroutine and maybe in another thread? At least client code do atomic accesses of client->refcount..

Quoted 3 lines
blockdev-nbd.c +3 -0
+        assert(nbd_server->connections > 0);
+        nbd_server->connections--;
+        nbd_update_server_watch(nbd_server);

The client code already jumps through hoops to make sure nbd_blockdev_client_closed() is the last thing called, and that nbd_client_put() is only reached from the main thread (any coroutines fired off a one-shot bh); but I added asserts in v3 to make it clear I'm relying on the synchronous nature of coroutines yielding only at known points and the code executing only in the main thread as the reason why we don't need explicit locking here.

Signature · 3 lines
Eric Blake, Principal Software Engineer
Red Hat, Inc.
Virtualization:  qemu.org | libguestfs.org
author
#6 lore raw

PATCH v2 2/3 nbd: CVE-XXX: Close stray client sockets at server shutdown

In reply to Eric Blake

A malicious client can attempt to connect to an NBD server, and then intentionally not progress in the handshake. This can form a resource leak for as long as the client wants, when the client does not catch our attention by failing to provide TLS credentials; although it can be bounded by max-connections per NBD server that does not use the default of unlimited. Better is to forcefully disconnect any remaining client sockets when the NBD server is shut down. While less severe than the issue fixed in the previous patch, this can still be considered defense against a potential denial of service attack, so it is still categorized under the same CVE.

---

I do not know if I need to worry about multi-threaded access (is it possible that more than one client trying to connect simultaneously means that I need to access nbd_server->conns atomically)?

 blockdev-nbd.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
blockdev-nbd.c +23 -0
index 1ddcbd7b247..9bbd86ebc31 100644
@@ -21,12 +21,18 @@
 #include "io/channel-socket.h"
 #include "io/net-listener.h"
 
+typedef struct NBDConn {
+    QIOChannelSocket *cioc;
+    QSLIST_ENTRY(NBDConn) next;
+} NBDConn;
+
 typedef struct NBDServerData {
     QIONetListener *listener;
     QCryptoTLSCreds *tlscreds;
     char *tlsauthz;
     uint32_t max_connections;
     uint32_t connections;
+    QSLIST_HEAD(, NBDConn) conns;
 } NBDServerData;
 
 static NBDServerData *nbd_server;
@@ -65,8 +71,13 @@ static void nbd_blockdev_client_closed(NBDClient *client, uint32_t cookie,
 static void nbd_accept(QIONetListener *listener, QIOChannelSocket *cioc,
                        gpointer opaque)
 {
+    NBDConn *conn = g_new0(NBDConn, 1);
+
     assert(nbd_server);
     nbd_server->connections++;
+    object_ref(OBJECT(cioc));
+    conn->cioc = cioc;
+    QSLIST_INSERT_HEAD(&nbd_server->conns, conn, next);
     nbd_update_server_watch(nbd_server);
 
     qio_channel_set_name(QIO_CHANNEL(cioc), "nbd-server");
@@ -89,8 +100,21 @@ static void nbd_server_free(NBDServerData *server)
         return;
     }
 
+    /*
+     * Forcefully close the listener socket, and any clients that have
+     * not yet disconnected on their own.
+     */
     qio_net_listener_disconnect(server->listener);
     object_unref(OBJECT(server->listener));
+    while (!QSLIST_EMPTY(&server->conns)) {
+        NBDConn *conn = QSLIST_FIRST(&server->conns);
+
+        qio_channel_close(QIO_CHANNEL(conn->cioc), NULL);
+        object_unref(OBJECT(conn->cioc));
+        QSLIST_REMOVE_HEAD(&server->conns, next);
+        g_free(conn);
+    }
     if (server->tlscreds) {
         object_unref(OBJECT(server->tlscreds));
     }
Signature · 1 line
2.45.2
author
#7 lore raw

PATCH v2 3/3 nbd: Minor style fixes

In reply to Eric Blake

Touch up a comment with the wrong type name, and an over-long line, both noticed while working on the previous patches.

---
 nbd/server.c | 2 +-
 qemu-nbd.c   | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)
nbd/server.c +1 -1
index 7c37d9753f0..3debc416dd0 100644
@@ -1973,7 +1973,7 @@ static void nbd_export_request_shutdown(BlockExport *blk_exp)
 
     blk_exp_ref(&exp->common);
     /*
-     * TODO: Should we expand QMP NbdServerRemoveNode enum to allow a
+     * TODO: Should we expand QMP BlockExportRemoveMode enum to allow a
      * close mode that stops advertising the export to new clients but
      * still permits existing clients to run to completion? Because of
      * that possibility, nbd_export_close() can be called more than
qemu-nbd.c +2 -1
index 3ad50eec18e..c0bd16217cd 100644
@@ -589,7 +589,8 @@ int main(int argc, char **argv)
     pthread_t client_thread;
     const char *fmt = NULL;
     Error *local_err = NULL;
-    BlockdevDetectZeroesOptions detect_zeroes = BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
+    BlockdevDetectZeroesOptions detect_zeroes =
+        BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF;
     QDict *options = NULL;
     const char *export_name = NULL; /* defaults to "" later for server mode */
     const char *export_description = NULL;
Signature · 1 line
2.45.2