Netdev List
 help / color / mirror / Atom feed
From: Mahanta Jambigi <mjambigi@linux.ibm.com>
To: andrew+netdev@lunn.ch, davem@davemloft.net, edumazet@google.com,
	kuba@kernel.org, pabeni@redhat.com, alibuda@linux.alibaba.com,
	dust.li@linux.alibaba.com, sidraya@linux.ibm.com
Cc: hidayath@linux.ibm.com, pasic@linux.ibm.com, horms@kernel.org,
	tonylu@linux.alibaba.com, guwen@linux.alibaba.com,
	netdev@vger.kernel.org, linux-s390@vger.kernel.org,
	linux-rdma@vger.kernel.org,
	Mahanta Jambigi <mjambigi@linux.ibm.com>
Subject: [PATCH net-next 2/3] net/smc: remove the clcsock release lock
Date: Fri, 20 Nov 2026 13:45:33 +0100	[thread overview]
Message-ID: <20261120124534.430200-3-mjambigi@linux.ibm.com> (raw)
In-Reply-To: <20261120124534.430200-1-mjambigi@linux.ibm.com>

The clcsock is now freed only when no socket file can reference it, and
that decision is made under the socket lock: smc_accept_dequeue() holds
the same lock across the accept-queue state check and sock_graft(), so a
child that is being accepted cannot lose its clcsock to an asynchronous
close. A socket operation on the file is serialized with smc_release()
by the file reference.

The listen paths that held the lock are covered without it:
smc_clcsock_release() flushes smc_tcp_listen_work() before releasing a
listener's clcsock and waits for smc_listen_work() before releasing a
child's. Remove the lock and the NULL checks and error paths it needed
in getsockopt, setsockopt, getname, ioctl and accept;
smc_switch_to_fallback() can no longer fail and returns void. Detach the
clcsock with xchg() at both release sites, so a second release attempt
is a no-op.

Signed-off-by: Mahanta Jambigi <mjambigi@linux.ibm.com>
---
 net/smc/af_smc.c    | 106 +++++++++++++-------------------------------
 net/smc/smc.h       |   4 --
 net/smc/smc_close.c |  12 ++---
 net/smc/smc_inet.c  |   9 ++--
 4 files changed, 42 insertions(+), 89 deletions(-)

diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
index 1d8a602729c1..cc7fb2d90637 100644
--- a/net/smc/af_smc.c
+++ b/net/smc/af_smc.c
@@ -409,7 +409,6 @@ void smc_sk_init(struct net *net, struct sock *sk, int protocol)
 				      "sk_lock-AF_SMC", &smc_key);
 	spin_lock_init(&smc->accept_q_lock);
 	spin_lock_init(&smc->conn.send_lock);
-	mutex_init(&smc->clcsock_release_lock);
 	smc_init_saved_callbacks(smc);
 	smc->limit_smc_hs = net->smc.limit_smc_hs;
 	smc->use_fallback = false; /* assume rdma capability first */
@@ -932,16 +931,8 @@ static void smc_fback_replace_callbacks(struct smc_sock *smc)
 	write_unlock_bh(&clcsk->sk_callback_lock);
 }

-static int smc_switch_to_fallback(struct smc_sock *smc, int reason_code)
+static void smc_switch_to_fallback(struct smc_sock *smc, int reason_code)
 {
-	int rc = 0;
-
-	mutex_lock(&smc->clcsock_release_lock);
-	if (!smc->clcsock) {
-		rc = -EBADF;
-		goto out;
-	}
-
 	smc->use_fallback = true;
 	smc->fallback_rsn = reason_code;
 	smc_stat_fallback(smc);
@@ -959,24 +950,12 @@ static int smc_switch_to_fallback(struct smc_sock *smc, int reason_code)
 		 */
 		smc_fback_replace_callbacks(smc);
 	}
-out:
-	mutex_unlock(&smc->clcsock_release_lock);
-	return rc;
 }

 /* fall back during connect */
 static int smc_connect_fallback(struct smc_sock *smc, int reason_code)
 {
-	struct net *net = sock_net(&smc->sk);
-	int rc = 0;
-
-	rc = smc_switch_to_fallback(smc, reason_code);
-	if (rc) { /* fallback fails */
-		this_cpu_inc(net->smc.smc_stats->clnt_hshake_err_cnt);
-		if (smc->sk.sk_state == SMC_INIT)
-			sock_put(&smc->sk); /* passive closing */
-		return rc;
-	}
+	smc_switch_to_fallback(smc, reason_code);
 	smc_copy_sock_settings_to_clc(smc);
 	smc->connect_nonblock = 0;
 	if (smc->sk.sk_state == SMC_INIT)
@@ -1757,10 +1736,10 @@ static int smc_clcsock_accept(struct smc_sock *lsmc, struct smc_sock **new_smc)
 	}
 	*new_smc = smc_sk(new_sk);

-	mutex_lock(&lsmc->clcsock_release_lock);
-	if (lsmc->clcsock)
-		rc = kernel_accept(lsmc->clcsock, &new_clcsock, SOCK_NONBLOCK);
-	mutex_unlock(&lsmc->clcsock_release_lock);
+	/* The listener lock is dropped here. smc_clcsock_release() flushes
+	 * smc_tcp_listen_work() before it releases the clcsock.
+	 */
+	rc = kernel_accept(lsmc->clcsock, &new_clcsock, SOCK_NONBLOCK);
 	lock_sock(lsk);
 	if  (rc < 0 && rc != -EAGAIN)
 		lsk->sk_err = -rc;
@@ -1830,18 +1809,26 @@ struct sock *smc_accept_dequeue(struct sock *parent,
 				struct socket *new_sock)
 {
 	struct smc_sock *isk, *n;
+	struct socket *tcp;
 	struct sock *new_sk;

 	list_for_each_entry_safe(isk, n, &smc_sk(parent)->accept_q, accept_q) {
 		new_sk = (struct sock *)isk;

 		smc_accept_unlink(new_sk);
+		/* smc_close_active_abort() and smc_close_passive_work()
+		 * decide under the socket lock whether the clcsock may be
+		 * released. Hold it across the state check and the graft so a
+		 * child that becomes file-referenced here cannot lose its
+		 * clcsock to an asynchronous close.
+		 */
+		lock_sock(new_sk);
 		if (new_sk->sk_state == SMC_CLOSED) {
 			new_sk->sk_prot->unhash(new_sk);
-			if (isk->clcsock) {
-				sock_release(isk->clcsock);
-				isk->clcsock = NULL;
-			}
+			tcp = xchg(&isk->clcsock, NULL);
+			release_sock(new_sk);
+			if (tcp)
+				sock_release(tcp);
 			sock_put(new_sk); /* final */
 			continue;
 		}
@@ -1853,6 +1840,7 @@ struct sock *smc_accept_dequeue(struct sock *parent,
 				isk->clcsock->file->private_data = isk->clcsock;
 			}
 		}
+		release_sock(new_sk);
 		return new_sk;
 	}
 	return NULL;
@@ -1983,12 +1971,12 @@ static void smc_listen_decline(struct smc_sock *new_smc, int reason_code,
 {
 	/* RDMA setup failed, switch back to TCP */
 	smc_conn_abort(new_smc, local_first);
-	if (reason_code < 0 ||
-	    smc_switch_to_fallback(new_smc, reason_code)) {
+	if (reason_code < 0) {
 		/* error, no fallback possible */
 		smc_listen_out_err(new_smc);
 		return;
 	}
+	smc_switch_to_fallback(new_smc, reason_code);
 	if (reason_code && reason_code != SMC_CLC_DECL_PEERDECL) {
 		if (smc_clc_send_decline(new_smc, reason_code, version) < 0) {
 			smc_listen_out_err(new_smc);
@@ -2478,11 +2466,8 @@ static void smc_listen_work(struct work_struct *work)

 	/* check if peer is smc capable */
 	if (!tcp_sk(newclcsock->sk)->syn_smc) {
-		rc = smc_switch_to_fallback(new_smc, SMC_CLC_DECL_PEERNOSMC);
-		if (rc)
-			smc_listen_out_err(new_smc);
-		else
-			smc_listen_out_connected(new_smc);
+		smc_switch_to_fallback(new_smc, SMC_CLC_DECL_PEERNOSMC);
+		smc_listen_out_connected(new_smc);
 		return;
 	}

@@ -2729,7 +2714,8 @@ int smc_accept(struct socket *sock, struct socket *new_sock,

 	lsmc = smc_sk(sk);
 	sock_hold(sk); /* sock_put below */
-	lock_sock(sk);
+	/* smc_accept_dequeue() locks the child socket as well. */
+	lock_sock_nested(sk, SINGLE_DEPTH_NESTING);

 	if (lsmc->sk.sk_state != SMC_LISTEN) {
 		rc = -EINVAL;
@@ -2750,7 +2736,7 @@ int smc_accept(struct socket *sock, struct socket *new_sock,
 		timeo = schedule_timeout(timeo);
 		/* wakeup by sk_data_ready in smc_listen_work() */
 		sched_annotate_sleep();
-		lock_sock(sk);
+		lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 		if (signal_pending(current)) {
 			rc = sock_intr_errno(timeo);
 			break;
@@ -2791,19 +2777,13 @@ int smc_getname(struct socket *sock, struct sockaddr *addr,
 		int peer)
 {
 	struct smc_sock *smc;
-	int rc = -EBADF;

 	if (peer && (sock->sk->sk_state != SMC_ACTIVE) &&
 	    (sock->sk->sk_state != SMC_APPCLOSEWAIT1))
 		return -ENOTCONN;

 	smc = smc_sk(sock->sk);
-
-	mutex_lock(&smc->clcsock_release_lock);
-	if (smc->clcsock)
-		rc = smc->clcsock->ops->getname(smc->clcsock, addr, peer);
-	mutex_unlock(&smc->clcsock_release_lock);
-	return rc;
+	return smc->clcsock->ops->getname(smc->clcsock, addr, peer);
 }

 int smc_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
@@ -2819,9 +2799,7 @@ int smc_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
 	if (msg->msg_flags & MSG_FASTOPEN) {
 		/* not connected yet, fallback */
 		if (sk->sk_state == SMC_INIT && !smc->connect_nonblock) {
-			rc = smc_switch_to_fallback(smc, SMC_CLC_DECL_OPTUNSUPP);
-			if (rc)
-				goto out;
+			smc_switch_to_fallback(smc, SMC_CLC_DECL_OPTUNSUPP);
 		} else {
 			rc = -EINVAL;
 			goto out;
@@ -3110,11 +3088,6 @@ int smc_setsockopt(struct socket *sock, int level, int optname,
 	/* generic setsockopts reaching us here always apply to the
 	 * CLC socket
 	 */
-	mutex_lock(&smc->clcsock_release_lock);
-	if (!smc->clcsock) {
-		mutex_unlock(&smc->clcsock_release_lock);
-		return -EBADF;
-	}
 	if (unlikely(!smc->clcsock->ops->setsockopt))
 		rc = -EOPNOTSUPP;
 	else
@@ -3124,7 +3097,6 @@ int smc_setsockopt(struct socket *sock, int level, int optname,
 		sk->sk_err = smc->clcsock->sk->sk_err;
 		sk_error_report(sk);
 	}
-	mutex_unlock(&smc->clcsock_release_lock);

 	if (optlen < sizeof(int))
 		return -EINVAL;
@@ -3141,7 +3113,7 @@ int smc_setsockopt(struct socket *sock, int level, int optname,
 	case TCP_FASTOPEN_NO_COOKIE:
 		/* option not supported by SMC */
 		if (sk->sk_state == SMC_INIT && !smc->connect_nonblock) {
-			rc = smc_switch_to_fallback(smc, SMC_CLC_DECL_OPTUNSUPP);
+			smc_switch_to_fallback(smc, SMC_CLC_DECL_OPTUNSUPP);
 		} else {
 			rc = -EINVAL;
 		}
@@ -3186,26 +3158,16 @@ int smc_getsockopt(struct socket *sock, int level, int optname,
 		   char __user *optval, int __user *optlen)
 {
 	struct smc_sock *smc;
-	int rc;

 	if (level == SOL_SMC)
 		return __smc_getsockopt(sock, level, optname, optval, optlen);

 	smc = smc_sk(sock->sk);
-	mutex_lock(&smc->clcsock_release_lock);
-	if (!smc->clcsock) {
-		mutex_unlock(&smc->clcsock_release_lock);
-		return -EBADF;
-	}
 	/* socket options apply to the CLC socket */
-	if (unlikely(!smc->clcsock->ops->getsockopt)) {
-		mutex_unlock(&smc->clcsock_release_lock);
+	if (unlikely(!smc->clcsock->ops->getsockopt))
 		return -EOPNOTSUPP;
-	}
-	rc = smc->clcsock->ops->getsockopt(smc->clcsock, level, optname,
-					   optval, optlen);
-	mutex_unlock(&smc->clcsock_release_lock);
-	return rc;
+	return smc->clcsock->ops->getsockopt(smc->clcsock, level, optname,
+					     optval, optlen);
 }

 int smc_ioctl(struct socket *sock, unsigned int cmd,
@@ -3220,10 +3182,6 @@ int smc_ioctl(struct socket *sock, unsigned int cmd,
 	conn = &smc->conn;
 	lock_sock(&smc->sk);
 	if (smc->use_fallback) {
-		if (!smc->clcsock) {
-			release_sock(&smc->sk);
-			return -EBADF;
-		}
 		answ = smc->clcsock->ops->ioctl(smc->clcsock, cmd, arg);
 		release_sock(&smc->sk);
 		return answ;
diff --git a/net/smc/smc.h b/net/smc/smc.h
index 36b243b34a9a..616bb3245f7b 100644
--- a/net/smc/smc.h
+++ b/net/smc/smc.h
@@ -325,10 +325,6 @@ struct smc_sock {				/* smc sock container */
 						/* non-blocking connect in
 						 * flight
 						 */
-	struct mutex            clcsock_release_lock;
-						/* protects clcsock of a listen
-						 * socket
-						 * */
 };

 #define smc_sk(ptr) container_of_const(ptr, struct smc_sock, sk)
diff --git a/net/smc/smc_close.c b/net/smc/smc_close.c
index cf1add1ffda6..e71245dbb296 100644
--- a/net/smc/smc_close.c
+++ b/net/smc/smc_close.c
@@ -27,13 +27,13 @@ void smc_clcsock_release(struct smc_sock *smc)

 	if (smc->listen_smc && current_work() != &smc->smc_listen_work)
 		cancel_work_sync(&smc->smc_listen_work);
-	mutex_lock(&smc->clcsock_release_lock);
-	if (smc->clcsock) {
-		tcp = smc->clcsock;
-		smc->clcsock = NULL;
+	/* smc_tcp_listen_work() dereferences smc->clcsock outside the
+	 * socket lock; wait for it before the clcsock goes away.
+	 */
+	flush_work(&smc->tcp_listen_work);
+	tcp = xchg(&smc->clcsock, NULL);
+	if (tcp)
 		sock_release(tcp);
-	}
-	mutex_unlock(&smc->clcsock_release_lock);
 }

 /* The clcsock can be released once no socket file can reach it; while a
diff --git a/net/smc/smc_inet.c b/net/smc/smc_inet.c
index 520b666fdd8f..76cde321a8ea 100644
--- a/net/smc/smc_inet.c
+++ b/net/smc/smc_inet.c
@@ -122,11 +122,10 @@ static int smc_inet_init_sock(struct sock *sk)

 static void smc_inet_destroy_sock(struct sock *sk)
 {
-	/* The sock is hashed and smc_diag dumps dereference smc->clcsock
-	 * without clcsock_release_lock, while sk_common_release() calls
-	 * .destroy before .unhash. Unhash first, as __smc_release() does,
-	 * so no dump can observe the clcsock being released; the second
-	 * unhash is a no-op.
+	/* The sock is hashed and smc_diag dumps dereference smc->clcsock,
+	 * while sk_common_release() calls .destroy before .unhash. Unhash
+	 * first, as __smc_release() does, so no dump can observe the
+	 * clcsock being released; the second unhash is a no-op.
 	 */
 	sk->sk_prot->unhash(sk);
 	smc_clcsock_release(smc_sk(sk));
-- 
2.50.1 (Apple Git-155)


  parent reply	other threads:[~2026-11-20 12:46 UTC|newest]

Thread overview: 4+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20 12:45 [PATCH net-next 0/3] net/smc: fix clcsock lifetime vs asynchronous paths Mahanta Jambigi
2026-11-20 12:45 ` [PATCH net-next 1/3] net/smc: keep clcsock until socket release Mahanta Jambigi
2026-11-20 12:45 ` Mahanta Jambigi [this message]
2026-11-20 12:45 ` [PATCH net-next 3/3] net/smc: document the clcsock lifetime Mahanta Jambigi

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261120124534.430200-3-mjambigi@linux.ibm.com \
    --to=mjambigi@linux.ibm.com \
    --cc=alibuda@linux.alibaba.com \
    --cc=andrew+netdev@lunn.ch \
    --cc=davem@davemloft.net \
    --cc=dust.li@linux.alibaba.com \
    --cc=edumazet@google.com \
    --cc=guwen@linux.alibaba.com \
    --cc=hidayath@linux.ibm.com \
    --cc=horms@kernel.org \
    --cc=kuba@kernel.org \
    --cc=linux-rdma@vger.kernel.org \
    --cc=linux-s390@vger.kernel.org \
    --cc=netdev@vger.kernel.org \
    --cc=pabeni@redhat.com \
    --cc=pasic@linux.ibm.com \
    --cc=sidraya@linux.ibm.com \
    --cc=tonylu@linux.alibaba.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox