Re: [PATCH net-next v2 1/2] vsock: support SO_INQ on stream sockets
From: Stefano Garzarella
Date: Fri Oct 16 2026 - 04:17:12 EST
On Thu, Oct 15, 2026 at 04:43:33PM +0100, David Carlier wrote:
SO_INQ makes recvmsg() return the bytes left in the receive queue in an
SCM_INQ cmsg, saving a SIOCINQ call per receive. AF_UNIX stream sockets
support it, AF_VSOCK fails with ENOPROTOOPT.
Add it for SOCK_STREAM, reusing the hint already computed for io_uring.
As with TCP_INQ, 1 is reported once the stream is finished so the caller
reads again and sees EOF, and accepted sockets inherit the setting from
the listener. No cmsg is sent when the transport cannot report the queue
length.
SOCK_SEQPACKET is refused, as on AF_UNIX: its transport callback counts
messages, not bytes.
Signed-off-by: David Carlier <devnexen@xxxxxxxxx>
---
include/net/af_vsock.h | 1 +
net/vmw_vsock/af_vsock.c | 111 +++++++++++++++++++++++++++++----------
2 files changed, 84 insertions(+), 28 deletions(-)
diff --git a/include/net/af_vsock.h b/include/net/af_vsock.h
index 5549298c1ec6..e8481f12312e 100644
--- a/include/net/af_vsock.h
+++ b/include/net/af_vsock.h
@@ -68,6 +68,7 @@ struct vsock_sock {
u64 buffer_size;
u64 buffer_min_size;
u64 buffer_max_size;
+ bool recvmsg_inq;
/* Private to transport. */
void *trans;
diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c
index 1c2d1cea67f4..186ed57fd797 100644
--- a/net/vmw_vsock/af_vsock.c
+++ b/net/vmw_vsock/af_vsock.c
@@ -984,6 +984,7 @@ static struct sock *__vsock_create(struct net *net,
vsk->buffer_size = psk->buffer_size;
vsk->buffer_min_size = psk->buffer_min_size;
vsk->buffer_max_size = psk->buffer_max_size;
+ vsk->recvmsg_inq = psk->recvmsg_inq;
security_sk_clone(parent, sk);
} else {
vsk->trusted = ns_capable_noaudit(&init_user_ns, CAP_NET_ADMIN);
@@ -2014,6 +2015,66 @@ static void vsock_update_buffer_size(struct vsock_sock *vsk,
vsk->buffer_size = val;
}
+static bool vsock_custom_sockopt(int optname)
Looking at the other function, what about vsock_sol_socket_custom()?
+{
+ switch (optname) {
+ case SO_ZEROCOPY:
+ case SO_INQ:
+ return true;
+ default:
+ return false;
+ }
+}
+
+static int vsock_sol_socket_setsockopt(struct sock *sk, int optname,
+ sockptr_t optval, unsigned int optlen)
+{
+ struct vsock_sock *vsk = vsock_sk(sk);
+ int err = 0;
+ int val;
+
+ /* Use 'int' type here, because variable to
nit: why not using at least 80 columns for this comment?
+ * set these options usually has this type.
+ */
+ if (optlen < sizeof(val))
+ return -EINVAL;
+
+ if (copy_from_sockptr(&val, optval, sizeof(val)))
+ return -EFAULT;
+
+ if (val < 0 || val > 1)
+ return -EINVAL;
What about adding an helper with this code, and call it after checks for each SO_, in this way using SO_INQ on sock_dgram with 2 will return -ENOPROTOOPT.
Oh wait, we can use COPY_IN and duplicate the check in each place or add an helper just for that.
+
+ lock_sock(sk);
+
+ switch (optname) {
+ case SO_ZEROCOPY:
+ if (vsk->transport && !vsock_msgzerocopy_allow(vsk->transport)) {
+ err = -EOPNOTSUPP;
+ break;
+ }
+
+ sock_valbool_flag(sk, SOCK_ZEROCOPY, val);
+ break;
+
+ case SO_INQ:
+ if (sk->sk_type != SOCK_STREAM) {
+ err = -ENOPROTOOPT;
+ break;
+ }
+
+ vsk->recvmsg_inq = val;
+ break;
+
+ default:
+ err = -ENOPROTOOPT;
+ break;
+ }
+
+ release_sock(sk);
+ return err;
+}
Now it's much better, but we should not mix a refactoring with a new feature, so please split this patch in 2 patches, first one introducing vsock_sol_socket_setsockopt() just for SO_ZEROCOPY, second one introducing SO_INQ handling.
In this way, if we have to backport a fix to SO_ZEROCOPY handling in a stable branch, we can do it easily.
The rest LGTM,
Stefano
+
static int vsock_connectible_setsockopt(struct socket *sock,
int level,
int optname,
@@ -2045,36 +2106,16 @@ static int vsock_connectible_setsockopt(struct socket *sock,
sk = sock->sk;
vsk = vsock_sk(sk);
- lock_sock(sk);
-
- transport = vsk->transport;
-
if (level == SOL_SOCKET) {
- int zerocopy;
-
- if (optname != SO_ZEROCOPY) {
- release_sock(sk);
+ if (!vsock_custom_sockopt(optname))
return sock_setsockopt(sock, level, optname, optval, optlen);
- }
-
- /* Use 'int' type here, because variable to
- * set this option usually has this type.
- */
- COPY_IN(zerocopy);
- if (zerocopy < 0 || zerocopy > 1) {
- err = -EINVAL;
- goto exit;
- }
+ return vsock_sol_socket_setsockopt(sk, optname, optval, optlen);
+ }
- if (transport && !vsock_msgzerocopy_allow(transport)) {
- err = -EOPNOTSUPP;
- goto exit;
- }
+ lock_sock(sk);
- sock_valbool_flag(sk, SOCK_ZEROCOPY, zerocopy);
- goto exit;
- }
+ transport = vsk->transport;
switch (optname) {
case SO_VM_SOCKETS_BUFFER_SIZE:
@@ -2581,6 +2622,7 @@ __vsock_connectible_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
struct sock *sk;
struct vsock_sock *vsk;
const struct vsock_transport *transport;
+ bool do_cmsg = false;
int err;
sk = sock->sk;
@@ -2637,13 +2679,26 @@ __vsock_connectible_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
err = __vsock_seqpacket_recvmsg(sk, msg, len, flags);
out:
- /* Seqpacket has_data counts messages, while io_uring treats msg_inq as
- * a byte length when sizing retries, so only streams report a hint.
+ /* Seqpacket has_data counts messages, while SCM_INQ reports bytes and
+ * io_uring treats msg_inq as a byte length when sizing retries, so
+ * only streams report it.
*/
- if (msg->msg_get_inq && err >= 0 && sk->sk_type == SOCK_STREAM)
+ if ((vsk->recvmsg_inq || msg->msg_get_inq) && err >= 0 &&
+ sk->sk_type == SOCK_STREAM) {
msg->msg_inq = vsock_stream_inq_hint(sk);
+ /* A negative hint means the transport could not tell. SCM_INQ
+ * has no encoding for that, so report nothing.
+ */
+ do_cmsg = vsk->recvmsg_inq && msg->msg_inq >= 0;
+ }
+
release_sock(sk);
+
+ if (do_cmsg)
+ put_cmsg(msg, SOL_SOCKET, SCM_INQ, sizeof(msg->msg_inq),
+ &msg->msg_inq);
+
return err;
}
--
2.55.0