All of lore.kernel.org
 help / color / mirror / Atom feed
* [PULL for-11.2 0/3] NBD patches through 2026-11-19
@ 2026-11-19 20:23 Eric Blake
  2026-11-19 20:23 ` [PULL 1/3] nbd: Refactor structured payload interpretation Eric Blake
                   ` (4 more replies)
  0 siblings, 5 replies; 7+ messages in thread
From: Eric Blake @ 2026-11-19 20:23 UTC (permalink / raw)
  To: qemu-devel

The following changes since commit 08c9bbb825148dec9669f5184ecf18823bb6d631:

  Update version for v11.2.0-rc1 release (2026-11-18 12:57:24 -0800)

are available in the Git repository at:

  https://gitlab.com/ebblake/qemu.git tags/pull-nbd-2026-11-19

for you to fetch changes up to 470888ffb0220911a0ab58f9ffd41d95f36e4a22:

  nbd/client: Don't leak uninitialized memory on malicious server (2026-11-19 14:21:23 -0600)

----------------------------------------------------------------
NBD patches for 2026-11-19

- Eric Blake: CVE-2026-126657: heap leak on client to malicious NBD server

----------------------------------------------------------------
Eric Blake (3):
      nbd: Refactor structured payload interpretation
      nbd: Pass back offset/length for all structured read replies
      nbd/client: Don't leak uninitialized memory on malicious server

 block/nbd.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 73 insertions(+), 14 deletions(-)

-- 
2.56.1



^ permalink raw reply	[flat|nested] 7+ messages in thread

* [PULL 1/3] nbd: Refactor structured payload interpretation
  2026-11-19 20:23 [PULL for-11.2 0/3] NBD patches through 2026-11-19 Eric Blake
@ 2026-11-19 20:23 ` Eric Blake
  2026-11-19 20:23 ` [PULL 2/3] nbd: Pass back offset/length for all structured read replies Eric Blake
                   ` (3 subsequent siblings)
  4 siblings, 0 replies; 7+ messages in thread
From: Eric Blake @ 2026-11-19 20:23 UTC (permalink / raw)
  To: qemu-devel
  Cc: Stefan Hajnoczi, Vladimir Sementsov-Ogievskiy, Kevin Wolf,
	Hanna Reitz, open list:Network Block Dev...

An upcoming patch wants to reuse the payload of a structured reply
chunk in further code for additional safety checks on the server's
response.  It will be easiest if the initial parse converts the
payload from network order into host order along the way, so that I
don't introduce subtle endian-specific bugs in that upcoming code. A
quick audit shows that none of the current callers of
payload_advance*() were reading a memory location within the payload
after its initial parse.

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-ID: <20261113223742.2546619-7-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/nbd.c | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/block/nbd.c b/block/nbd.c
index e5e16722ba2..052469b3547 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -578,24 +578,36 @@ err:
     return rc;
 }

+/* Consume a field of payload, while swapping it in place to host-endian. */
 static inline uint16_t payload_advance16(uint8_t **payload)
 {
+    uint16_t value = lduw_be_p(*payload);
+    stw_he_p(*payload, value);
     *payload += 2;
-    return lduw_be_p(*payload - 2);
+    return value;
 }

 static inline uint32_t payload_advance32(uint8_t **payload)
 {
+    uint32_t value = ldl_be_p(*payload);
+    stl_he_p(*payload, value);
     *payload += 4;
-    return ldl_be_p(*payload - 4);
+    return value;
 }

 static inline uint64_t payload_advance64(uint8_t **payload)
 {
+    uint64_t value = ldq_be_p(*payload);
+    stq_he_p(*payload, value);
     *payload += 8;
-    return ldq_be_p(*payload - 8);
+    return value;
 }

+/*
+ * nbd_parse_offset_hole_payload:
+ * Parse a chunk for NBD_REPLY_TYPE_OFFSET_HOLE, updating payload in
+ * place to a host-endian description of the region described.
+ */
 static int nbd_parse_offset_hole_payload(BDRVNBDState *s,
                                          NBDStructuredReplyChunk *chunk,
                                          uint8_t *payload, uint64_t orig_offset,
-- 
2.56.1



^ permalink raw reply related	[flat|nested] 7+ messages in thread

* [PULL 2/3] nbd: Pass back offset/length for all structured read replies
  2026-11-19 20:23 [PULL for-11.2 0/3] NBD patches through 2026-11-19 Eric Blake
  2026-11-19 20:23 ` [PULL 1/3] nbd: Refactor structured payload interpretation Eric Blake
@ 2026-11-19 20:23 ` Eric Blake
  2026-11-19 20:23 ` [PULL 3/3] nbd/client: Don't leak uninitialized memory on malicious server Eric Blake
                   ` (2 subsequent siblings)
  4 siblings, 0 replies; 7+ messages in thread
From: Eric Blake @ 2026-11-19 20:23 UTC (permalink / raw)
  To: qemu-devel
  Cc: Stefan Hajnoczi, Vladimir Sementsov-Ogievskiy, Kevin Wolf,
	Hanna Reitz, open list:Network Block Dev...

The NBD spec allows a server that has negotiated structured replies to
respond in any order among its various reply chunks. Although most
known servers happen to give replies in sequential order, QEMU must be
prepared for a server that intentionally returns out-of-order read
chunks (a malicious server could exploit that in an effort to attempt
to convince QEMU to expose uninitialized memory to a guest that is
using the NBD client as storage). Although this patch does not
actually add any new validation of the server's response chunks, it
does make it easier for the next patch to do so by providing a
centralized location in the code.  Now, in
nbd_co_receive_cmdread_reply(), payload contains a host-endian
offset+length after either the nbd_co_receive_one_chunk for
OFFSET_DATA or the nbd_parse_offset_hole_payload() for OFFSET_HOLE.

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-ID: <20261113223742.2546619-8-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/nbd.c | 45 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 35 insertions(+), 10 deletions(-)

diff --git a/block/nbd.c b/block/nbd.c
index 052469b3547..d873892c197 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -786,9 +786,17 @@ static int nbd_parse_error_payload(NBDStructuredReplyChunk *chunk,
     return 0;
 }

+/*
+ * nbd_co_receive_offset_data_payload:
+ * Helper to nbd_co_do_receive_one_chunk when server replies with
+ * structured reply to NBD_CMD_READ with an OFFSET_DATA chunk. On
+ * success, synthesize an NBDStructuredReadHole into @payload
+ * describing the same region that was populated into @qiov.
+ */
 static int coroutine_fn
 nbd_co_receive_offset_data_payload(BDRVNBDState *s, uint64_t orig_offset,
-                                   QEMUIOVector *qiov, Error **errp)
+                                   QEMUIOVector *qiov, void **payload,
+                                   Error **errp)
 {
     QEMUIOVector sub_qiov;
     uint64_t offset;
@@ -797,6 +805,7 @@ nbd_co_receive_offset_data_payload(BDRVNBDState *s, uint64_t orig_offset,
     NBDStructuredReplyChunk *chunk = &s->reply.structured;

     assert(nbd_reply_is_structured(&s->reply));
+    assert(payload);

     /* The NBD spec requires at least one byte of payload */
     if (chunk->length <= sizeof(offset)) {
@@ -826,6 +835,18 @@ nbd_co_receive_offset_data_payload(BDRVNBDState *s, uint64_t orig_offset,
     ret = qio_channel_readv_all(s->ioc, sub_qiov.iov, sub_qiov.niov, errp);
     qemu_iovec_destroy(&sub_qiov);

+    if (ret == 0) {
+        /*
+         * Give the caller a struct describing the same region we
+         * populated here, to allow for easier followup accounting
+         * between data and hole reads.
+         */
+        NBDStructuredReadHole *synth = g_new(NBDStructuredReadHole, 1);
+        synth->offset = offset;
+        synth->length = data_size;
+        *payload = synth;
+    }
+
     return ret < 0 ? -EIO : 0;
 }

@@ -867,18 +888,21 @@ static coroutine_fn int nbd_co_receive_structured_payload(

 /*
  * nbd_co_do_receive_one_chunk
+ * @qiov is non-NULL for NBD_CMD_READ, NULL for all other commands.
  * for simple reply:
  *   set request_ret to received reply error
- *   if qiov is not NULL: read payload to @qiov
+ *   if qiov is not NULL: read data to @qiov
+ *   either way, @payload stays NULL
  * for structured reply chunk:
- *   if error chunk: read payload, set @request_ret, do not set @payload
- *   else if offset_data chunk: read payload data to @qiov, do not set @payload
- *   else: read payload to @payload
+ *   if error chunk: read chunk payload, set @request_ret, @payload is NULL
+ *   else if offset_data chunk and @qiov: read data to @qiov, allocate
+ *     @payload as NBDStructuredReadHole describing region just populated
+ *   else: read payload to @payload; caller checks size and contents
  *
- * If function fails, @errp contains corresponding error message, and the
- * connection with the server is suspect.  If it returns 0, then the
- * transaction succeeded (although @request_ret may be a negative errno
- * corresponding to the server's error reply), and errp is unchanged.
+ * If function fails, @errp contains corresponding error message, @payload
+ * is NULL, and the connection with the server is suspect.  If it returns 0,
+ * then the transaction succeeded (although @request_ret may be a negative
+ * errno corresponding to the server's error reply), and errp is unchanged.
  */
 static coroutine_fn int nbd_co_do_receive_one_chunk(
         BDRVNBDState *s, uint64_t cookie, bool only_structured,
@@ -945,7 +969,7 @@ static coroutine_fn int nbd_co_do_receive_one_chunk(

         return nbd_co_receive_offset_data_payload(
                 s, nbd_request_by_cookie(s, cookie, &error_abort)->offset,
-                qiov, errp);
+                qiov, payload, errp);
     }

     if (nbd_reply_type_is_error(chunk->type)) {
@@ -1093,6 +1117,7 @@ static bool coroutine_fn nbd_reply_chunk_iter_receive(BDRVNBDState *s,
     return true;

 break_loop:
+    assert(payload == NULL || *payload == NULL);
     qemu_mutex_lock(&s->requests_lock);
     nbd_request_by_cookie(s, cookie, &error_abort)->coroutine = NULL;
     s->in_flight--;
-- 
2.56.1



^ permalink raw reply related	[flat|nested] 7+ messages in thread

* [PULL 3/3] nbd/client: Don't leak uninitialized memory on malicious server
  2026-11-19 20:23 [PULL for-11.2 0/3] NBD patches through 2026-11-19 Eric Blake
  2026-11-19 20:23 ` [PULL 1/3] nbd: Refactor structured payload interpretation Eric Blake
  2026-11-19 20:23 ` [PULL 2/3] nbd: Pass back offset/length for all structured read replies Eric Blake
@ 2026-11-19 20:23 ` Eric Blake
  2026-11-20  0:27 ` [PULL for-11.2 0/3] NBD patches through 2026-11-19 Richard Henderson
  2026-11-20  8:52 ` Michael Tokarev
  4 siblings, 0 replies; 7+ messages in thread
From: Eric Blake @ 2026-11-19 20:23 UTC (permalink / raw)
  To: qemu-devel
  Cc: Feifan Qian, qemu-stable, Stefan Hajnoczi,
	Vladimir Sementsov-Ogievskiy, Kevin Wolf, Hanna Reitz,
	open list:Network Block Dev...

The NBD spec[1] permits servers to send out-of-order replies for a
structured read, which the client must re-assemble into the final
buffer of its NBD_CMD_READ request. The standard states a server must
send chunks covering the entire region, but leaves the burden on the
client for double-checking whether a server actually sent sufficient
reply chunks. If the client never checks for a server omitting chunks,
or even sending multiple chunks that re-write the same portion of the
buffer, then the NBD spec says behavior is unspecified.  But ever
since we added structured reads to QEMU, the actual behavior is that
we would end up silently leaking QEMU host heap contents into the
guest's view, which the guest blindly assumes is legitimate data sent
by the server.  A proof of concept reported by Feifan Qian with the
help of AI analysis demonstrated the ability to leak 0x5a bytes from a
qemu-kvm process with MALLOC_PERTURB_=165, which implies a malicious
server can coerce QEMU into divulging other parts of its heap to a
guest for exfiltration, where knowing unscrubbed heap contents may
make further attacks against QEMU easier.

[1] https://github.com/NetworkBlockDevice/nbd/blob/master/doc/proto.md

In terms of the security risk, a guest cannot detect when a server
does a short reply, and may misbehave if successive reads of the same
portion of the disk come back with different contents, based on
changes to QEMU's heap between those reads, making it easy for an
attacker to attempt to provoke a silent form of data corruption to
guests, even though the server cannot control the actual sequence of
guest reads or QEMU heap contents between those reads.  And although
modern computing tends to isolate heap contents to prevent
cross-process leaks, it is feasible that a determined attacker could
try to set up a scenario in a multi-tenant environment where a guest
under attacker control using a disk backed by an NBD server supplied
by the attacker could then exfiltrate unrelated information learned
from other guests on the same host.  As a mitigating factor, QEMU
recommends that NBD client connections utilize TLS traffic and x509
certificates to avoid connecting to untrusted NBD servers.  See also
CVE-2022-0485 for a similar issue with clients being made more robust
to a non-compliant server in libnbd.

It may be worth proposing a future enhancement to the NBD protocol to
allow the client and server to negotiate an additional handshake
guarantee that structured reads must occur in order (the client can
detect a non-compliant server with less overhead, or even refuse to
talk to a server that doesn't know the new protocol).  But for now,
tracking the highwater mark of what has been covered in the buffer,
even if portions of the buffer get covered more than once, is
sufficient to guarantee that data left uninitialized by the server is
at least deterministic of showing as all zero in the guest's view.

At the time I wrote this patch, I also had an AI-assisted unit test
ready for qemu-iotests, but the policy update on LLM contributions was
not yet ready.  I also investigated modifying the existing
tests/qemu-iotests/nbd-fault-injector.py to add a way for it to become
a non-compliant structured read server, but that would itself require
quite a bit of refactoring effort (the fault injector currently
negotiates only simple replies, not structured), and would be rendered
moot by later use of an AI-assisted unit test. So instead, I am
documenting the following two-line patch to turn QEMU into a
non-compliant server that transmits less data than normal for holes:

| diff --git a/nbd/server.c b/nbd/server.c
| index 8c45f9fc43f..5d754cefa29 100644
| --- a/nbd/server.c
| +++ b/nbd/server.c
| @@ -2251,7 +2251,8 @@ static int coroutine_fn nbd_co_send_sparse_read(NBDClient *client,
|                           final ? NBD_REPLY_FLAG_DONE : 0,
|                           NBD_REPLY_TYPE_OFFSET_HOLE, request);
|              stq_be_p(&chunk.offset, offset + progress);
| -            stl_be_p(&chunk.length, pnum);
| +            /* HACK - truncate size of hole to test client response */
| +            stl_be_p(&chunk.length, 1 /* pnum */);
|              ret = nbd_co_send_iov(client, iov, 2, errp);
|          } else {
|              ret = blk_co_pread(exp->common.blk, offset + progress, pnum,

With that patch applied, you can see the difference in behavior by the
following setup (recall that qemu-io hard-codes 0xab content after
malloc() and before blk_pread(), so this behavior is unaffected by
your choice of MALLOC_PERTURB_):

$ qemu-img create -f qcow2 sample.qcow2 1m
$ $hacked/qemu-nbd -f qcow2 sample.qcow2 &
$ $old/qemu-io nbd://localhost:10809 -f raw -c 'read -v 0 16'
00000000:  00 ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab  ................
$ $patched/qemu-io nbd://localhost:10809 -f raw -c 'read -v 0 16'
00000000:  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
$ kill %1

Reported-by: Feifan Qian <bea1e@proton.me>
Fixes: CVE-2026-126657
Fixes: https://gitlab.com/qemu-project/qemu/-/work_items/3815
Fixes: f140e300 ("nbd: Minimal structured read for client", v2.11.0)
CC: qemu-stable@nongnu.org
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-ID: <20261113223742.2546619-9-eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
[eblake: Commit message enhanced with reproducer]
Signed-off-by: Eric Blake <eblake@redhat.com>
---
 block/nbd.c | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/block/nbd.c b/block/nbd.c
index d873892c197..fb4295bb235 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -1151,6 +1151,7 @@ nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t cookie,
     NBDReply reply;
     void *payload = NULL;
     Error *local_err = NULL;
+    uint64_t highwater = offset;

     NBD_FOREACH_REPLY_CHUNK(s, iter, cookie,
                             s->info.mode >= NBD_MODE_STRUCTURED,
@@ -1158,6 +1159,7 @@ nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t cookie,
     {
         int ret;
         NBDStructuredReplyChunk *chunk = &reply.structured;
+        NBDStructuredReadHole *slice = NULL;

         assert(nbd_reply_is_structured(&reply));

@@ -1165,8 +1167,9 @@ nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t cookie,
         case NBD_REPLY_TYPE_OFFSET_DATA:
             /*
              * special cased in nbd_co_receive_one_chunk, data is already
-             * in qiov
+             * in qiov, and payload is host-endian offset+length.
              */
+            slice = payload;
             break;
         case NBD_REPLY_TYPE_OFFSET_HOLE:
             ret = nbd_parse_offset_hole_payload(s, &reply.structured, payload,
@@ -1174,6 +1177,9 @@ nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t cookie,
             if (ret < 0) {
                 nbd_channel_error(s, ret);
                 nbd_iter_channel_error(&iter, ret, &local_err);
+            } else {
+                /* Successful parse swapped payload to host-endian. */
+                slice = payload;
             }
             break;
         default:
@@ -1187,10 +1193,26 @@ nbd_co_receive_cmdread_reply(BDRVNBDState *s, uint64_t cookie,
             }
         }

+        /* Initialize any region skipped by a malicious server. */
+        if (slice) {
+            if (slice->offset > highwater) {
+                qemu_iovec_memset(qiov, highwater - offset, 0,
+                                  slice->offset - highwater);
+            }
+            highwater = MAX(highwater, slice->offset + slice->length);
+        }
+
         g_free(payload);
         payload = NULL;
     }

+    /* Initialize any trailing region not touched by server. */
+    if (iter.only_structured && iter.ret == 0 &&
+        highwater < offset + qiov->size) {
+        qemu_iovec_memset(qiov, highwater - offset, 0,
+                          offset + qiov->size - highwater);
+    }
+
     error_propagate(errp, iter.err);
     *request_ret = iter.request_ret;
     return iter.ret;
-- 
2.56.1



^ permalink raw reply related	[flat|nested] 7+ messages in thread

* Re: [PULL for-11.2 0/3] NBD patches through 2026-11-19
  2026-11-19 20:23 [PULL for-11.2 0/3] NBD patches through 2026-11-19 Eric Blake
                   ` (2 preceding siblings ...)
  2026-11-19 20:23 ` [PULL 3/3] nbd/client: Don't leak uninitialized memory on malicious server Eric Blake
@ 2026-11-20  0:27 ` Richard Henderson
  2026-11-20  8:52 ` Michael Tokarev
  4 siblings, 0 replies; 7+ messages in thread
From: Richard Henderson @ 2026-11-20  0:27 UTC (permalink / raw)
  To: Eric Blake, qemu-devel

On 11/19/26 12:23, Eric Blake wrote:
> The following changes since commit 08c9bbb825148dec9669f5184ecf18823bb6d631:
> 
>    Update version for v11.2.0-rc1 release (2026-11-18 12:57:24 -0800)
> 
> are available in the Git repository at:
> 
>    https://gitlab.com/ebblake/qemu.git tags/pull-nbd-2026-11-19
> 
> for you to fetch changes up to 470888ffb0220911a0ab58f9ffd41d95f36e4a22:
> 
>    nbd/client: Don't leak uninitialized memory on malicious server (2026-11-19 14:21:23 -0600)
> 
> ----------------------------------------------------------------
> NBD patches for 2026-11-19
> 
> - Eric Blake: CVE-2026-126657: heap leak on client to malicious NBD server

Applied, thanks.

r~


^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: [PULL for-11.2 0/3] NBD patches through 2026-11-19
  2026-11-19 20:23 [PULL for-11.2 0/3] NBD patches through 2026-11-19 Eric Blake
                   ` (3 preceding siblings ...)
  2026-11-20  0:27 ` [PULL for-11.2 0/3] NBD patches through 2026-11-19 Richard Henderson
@ 2026-11-20  8:52 ` Michael Tokarev
  2026-11-20 18:17   ` Eric Blake
  4 siblings, 1 reply; 7+ messages in thread
From: Michael Tokarev @ 2026-11-20  8:52 UTC (permalink / raw)
  To: Eric Blake, qemu-devel; +Cc: QEMU Stable

On 11/19/26 23:23, Eric Blake wrote:

> NBD patches for 2026-11-19
> 
> - Eric Blake: CVE-2026-126657: heap leak on client to malicious NBD server
> 
> ----------------------------------------------------------------
> Eric Blake (3):
>        nbd: Refactor structured payload interpretation
>        nbd: Pass back offset/length for all structured read replies
>        nbd/client: Don't leak uninitialized memory on malicious server
> 
>   block/nbd.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++----------
>   1 file changed, 73 insertions(+), 14 deletions(-)
> 

Hi Eric!

This patchset contains a single patch which is marked for-stable, the
last one.  The first two are not marked as-such.  However, when picking
up just the patch 3, I'm seeing iotest failures, for example:

# running qcow2 140
not ok qcow2 140
--- /build/qemu/10.0/tests/qemu-iotests/140.out
+++ /tmp/q10/scratch/qcow2-file-140/140.out.bad
@@ -11,6 +11,7 @@
  { 'execute': 'nbd-server-add',
         'arguments': { 'device': 'drv' }}
  {"return": {}}
+Pattern verification failed at offset 0, 65536 bytes
  read 65536/65536 bytes at offset 0
  64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  { 'execute': 'eject',

(it's always "Pattern verification failed").

but when applying all 3, the failures goes away.

I'm picking up all 3.  Please let me know if I should not  :)

Thanks,

/mjt


^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: [PULL for-11.2 0/3] NBD patches through 2026-11-19
  2026-11-20  8:52 ` Michael Tokarev
@ 2026-11-20 18:17   ` Eric Blake
  0 siblings, 0 replies; 7+ messages in thread
From: Eric Blake @ 2026-11-20 18:17 UTC (permalink / raw)
  To: Michael Tokarev; +Cc: qemu-devel, QEMU Stable

On Fri, Nov 20, 2026 at 11:52:25AM +0300, Michael Tokarev wrote:
> On 11/19/26 23:23, Eric Blake wrote:
> 
> > NBD patches for 2026-11-19
> > 
> > - Eric Blake: CVE-2026-126657: heap leak on client to malicious NBD server
> > 
> > ----------------------------------------------------------------
> > Eric Blake (3):
> >        nbd: Refactor structured payload interpretation
> >        nbd: Pass back offset/length for all structured read replies
> >        nbd/client: Don't leak uninitialized memory on malicious server
> > 
> >   block/nbd.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++----------
> >   1 file changed, 73 insertions(+), 14 deletions(-)
> > 
> 
> Hi Eric!
> 
> This patchset contains a single patch which is marked for-stable, the
> last one.  The first two are not marked as-such.
...

> I'm picking up all 3.  Please let me know if I should not  :)

All three should be backported to stable; the third depends on the
first two being in place. My fault for not applying the tag
consistently, and thanks for double-checking!

-- 
Eric Blake, Principal Software Engineer
Red Hat, Inc.
Virtualization:  qemu.org | libguestfs.org



^ permalink raw reply	[flat|nested] 7+ messages in thread

end of thread, other threads:[~2026-11-20 18:18 UTC | newest]

Thread overview: 7+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-19 20:23 [PULL for-11.2 0/3] NBD patches through 2026-11-19 Eric Blake
2026-11-19 20:23 ` [PULL 1/3] nbd: Refactor structured payload interpretation Eric Blake
2026-11-19 20:23 ` [PULL 2/3] nbd: Pass back offset/length for all structured read replies Eric Blake
2026-11-19 20:23 ` [PULL 3/3] nbd/client: Don't leak uninitialized memory on malicious server Eric Blake
2026-11-20  0:27 ` [PULL for-11.2 0/3] NBD patches through 2026-11-19 Richard Henderson
2026-11-20  8:52 ` Michael Tokarev
2026-11-20 18:17   ` Eric Blake

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.