af_unix: Don't use skb_recv_datagram() in unix_stream_read_skb().

unix_stream_read_skb() calls skb_recv_datagram() with MSG_DONTWAIT,
which is mostly equivalent to sock_error(sk) + skb_dequeue().

In the following patch, we will add a new field to cache the number
of bytes in the receive queue.  Then, we want to avoid introducing
atomic ops in the fast path, so we will reuse the receive queue lock.

As a preparation for the change, let's not use skb_recv_datagram()
in unix_stream_read_skb().

Note that sock_error() is now moved out of the u->iolock mutex as
the mutex does not synchronise the peer's close() at all.

Signed-off-by: Kuniyuki Iwashima <kuniyu@google.com>
Link: https://patch.msgid.link/20250702223606.1054680-4-kuniyu@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 34ddea34e87e6d95b6e64377cdca2d3e7f994053..94596d6c37e91b71856a0550812dee9a2b6e90b8 100644 (file)
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -2786,6 +2786,7 @@ unlock:
 
 static int unix_stream_read_skb(struct sock *sk, skb_read_actor_t recv_actor)
 {
+       struct sk_buff_head *queue = &sk->sk_receive_queue;
        struct unix_sock *u = unix_sk(sk);
        struct sk_buff *skb;
        int err;
@@ -2793,30 +2794,34 @@ static int unix_stream_read_skb(struct sock *sk, skb_read_actor_t recv_actor)
        if (unlikely(READ_ONCE(sk->sk_state) != TCP_ESTABLISHED))
                return -ENOTCONN;
 
-       mutex_lock(&u->iolock);
-       skb = skb_recv_datagram(sk, MSG_DONTWAIT, &err);
-       mutex_unlock(&u->iolock);
-       if (!skb)
+       err = sock_error(sk);
+       if (err)
                return err;
 
-#if IS_ENABLED(CONFIG_AF_UNIX_OOB)
-       if (unlikely(skb == READ_ONCE(u->oob_skb))) {
-               bool drop = false;
+       mutex_lock(&u->iolock);
+       spin_lock(&queue->lock);
 
-               spin_lock(&sk->sk_receive_queue.lock);
-               if (likely(skb == u->oob_skb)) {
-                       WRITE_ONCE(u->oob_skb, NULL);
-                       drop = true;
-               }
-               spin_unlock(&sk->sk_receive_queue.lock);
+       skb = __skb_dequeue(queue);
+       if (!skb) {
+               spin_unlock(&queue->lock);
+               mutex_unlock(&u->iolock);
+               return -EAGAIN;
+       }
 
-               if (drop) {
-                       kfree_skb_reason(skb, SKB_DROP_REASON_UNIX_SKIP_OOB);
-                       return -EAGAIN;
-               }
+#if IS_ENABLED(CONFIG_AF_UNIX_OOB)
+       if (skb == u->oob_skb) {
+               WRITE_ONCE(u->oob_skb, NULL);
+               spin_unlock(&queue->lock);
+               mutex_unlock(&u->iolock);
+
+               kfree_skb_reason(skb, SKB_DROP_REASON_UNIX_SKIP_OOB);
+               return -EAGAIN;
        }
 #endif
 
+       spin_unlock(&queue->lock);
+       mutex_unlock(&u->iolock);
+
        return recv_actor(sk, skb);
 }