Re: [PATCH v3] virtio_console: fix buffer ownership and unplug races in the read path

From
sashiko-bot@kernel.org
Date
2026-11-06 05:50:52
Reply to
Yaohan Li, 2026-11-06
Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Medium] virtio_console: unplug race in fill_readbuf() and
  port_fops_read() returns 0
--

commit eb5deeedcdec231a191fa4aa424df11b809cdf63
Author: Yaohan Li [off-list ref]

virtio_console: fix buffer ownership and unplug races in the read path

This commit tracks ownership of port input buffers across unlocked reads
and adds an unplugging state to prevent use-after-free and buffer reorder
races during concurrent reads and port hot-unplug.
quoted hunk ↗ jump to hunk
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index 019bcae81af5c..d1757017d9bd0 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
[ ... ]
quoted hunk ↗ jump to hunk
@@ -534,19 +551,48 @@ static void discard_port_data(struct port *port)
 			 err);
 }
 
-static bool port_has_data(struct port *port)
+/*
+ * Input state of a port, snapshotted under inbuf_lock.  The distinction
+ * between a buffer that can be acquired now (AVAILABLE) and one that is
+ * owned by another reader (CLAIMED) matters for poll() and for blocking
+ * reads: only AVAILABLE must be reported as readable, while both mean
+ * that unread data may still be pending for the EOF logic.
+ */
+enum port_input_state {
+	PORT_INPUT_EMPTY,
+	PORT_INPUT_AVAILABLE,
+	PORT_INPUT_CLAIMED,
+	PORT_INPUT_UNPLUGGED,
+};
+
+/* Callers must not hold inbuf_lock. */
+static enum port_input_state port_input_state(struct port *port)
 {
 	unsigned long flags;
-	bool ret;
+	enum port_input_state state;
 
-	ret = false;
 	spin_lock_irqsave(&port->inbuf_lock, flags);
-	port->inbuf = get_inbuf(port);
-	if (port->inbuf)
-		ret = true;
+
+	if (port->unplugging || !port->portdev) {
+		state = PORT_INPUT_UNPLUGGED;
+	} else if (port->inbuf_claimed) {
+		state = PORT_INPUT_CLAIMED;
+	} else {
+		port->inbuf = get_inbuf(port);
+		state = port->inbuf ? PORT_INPUT_AVAILABLE
+				    : PORT_INPUT_EMPTY;
+	}
 
 	spin_unlock_irqrestore(&port->inbuf_lock, flags);
-	return ret;
+	return state;
+}
+
+static bool port_has_data(struct port *port)
+{
+	enum port_input_state state = port_input_state(port);
+
+	return state == PORT_INPUT_AVAILABLE ||
+	       state == PORT_INPUT_CLAIMED;
 }
[ ... ]
quoted hunk ↗ jump to hunk
@@ -692,24 +738,112 @@ static ssize_t __send_to_port(struct port *port, struct scatterlist *sg,
[ ... ]
quoted hunk ↗ jump to hunk
+	port->inbuf = get_inbuf(port);
 	buf = port->inbuf;
+	if (!buf) {
+		spin_unlock_irqrestore(&port->inbuf_lock, flags);
+		if (!to_user)
+			return 0;
+		if (nonblock)
+			return READ_ONCE(port->host_connected) ? -EAGAIN : 0;
+		/*
+		 * The data we saw was consumed by another reader while we
+		 * waited for its claim.  Keep blocking like the fops-level
+		 * wait instead of reporting a spurious EOF: wait for new
+		 * data, a disconnect or the unplug fence.
+		 */
+		err = wait_event_freezable(port->waitqueue,
+					   !will_read_block(port));
+		if (err)
+			return err;
+		if (!READ_ONCE(port->guest_connected))
+			return -ENODEV;
+		if (!READ_ONCE(port->host_connected) && !port_has_data(port))
+			return 0;
+		goto retry;
+	}
[Severity: Medium]
Can fill_readbuf() and port_fops_read() still return 0 instead of -ENODEV
when a read races with unplug_port()?

unplug_port() sets port->unplugging = true under inbuf_lock, drops the
lock to remove port->list under ports_lock, and only then re-acquires
inbuf_lock to clear guest_connected and host_connected.  Furthermore,
port_has_data() returns false for PORT_INPUT_UNPLUGGED, and
port->host_connected is read outside inbuf_lock:

CPU0 (fill_readbuf)               CPU1 (unplug_port)
wait_event_freezable(...)
                                  spin_lock_irq(&port->inbuf_lock)
                                  port->unplugging = true
                                  spin_unlock_irq(&port->inbuf_lock)
                                  ...
                                  spin_lock_irq(&port->inbuf_lock)
  !READ_ONCE(port->guest_connected)
    -> false
                                  port->guest_connected = false
                                  port->host_connected = false
                                  spin_unlock_irq(&port->inbuf_lock)
  !READ_ONCE(port->host_connected)
    && !port_has_data(port)
    -> true (PORT_INPUT_UNPLUGGED)
  return 0;  <-- returns EOF instead of -ENODEV

The same split between port_input_state() (or get_inbuf()) and
READ_ONCE(port->host_connected) exists in the non-blocking path above and
at bothPORT_INPUT_EMPTY checks in port_fops_read(): if unplug_port() runs
after port_input_state() returns PORT_INPUT_EMPTY, it clears
port->host_connected and the reader returns 0 instead of -ENODEV.

In addition, because unplug_port() sets port->unplugging before clearing
port->guest_connected, port_fops_poll() can observe port->guest_connected
as true and then call will_read_block(), which sees PORT_INPUT_UNPLUGGED
and returns false, reporting EPOLLIN | EPOLLRDNORM on an unplugging port
with no data.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261106053438.1206065-1-shunsheng1218@gmail.com?part=1
Thread (2 messages) 2 messages, 2 authors, last reply 11d ago
Keyboard shortcuts
hback out one level
jnext message in thread / next series-diff position
kprevious message in thread / previous series-diff position
ldrill in
Escclose help / fold thread tree
?toggle this help