Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'net-lockless-sk_sndtimeo-and-sk_rcvtimeo'
Eric Dumazet says:
====================
net: lockless sk_sndtimeo and sk_rcvtimeo
This series completes the task of making sk->sk_sndtimeo and
sk->sk_rcvtimeo lockless.
====================
Link: https://patch.msgid.link/20250620155536.335520-1-edumazet@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+31
-39
+2
-4
fs/smb/server/transport_tcp.c
+2
-4
fs/smb/server/transport_tcp.c
···
58
58
59
59
static inline void ksmbd_tcp_rcv_timeout(struct socket *sock, s64 secs)
60
60
{
61
-
lock_sock(sock->sk);
62
61
if (secs && secs < MAX_SCHEDULE_TIMEOUT / HZ - 1)
63
-
sock->sk->sk_rcvtimeo = secs * HZ;
62
+
WRITE_ONCE(sock->sk->sk_rcvtimeo, secs * HZ);
64
63
else
65
-
sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
66
-
release_sock(sock->sk);
64
+
WRITE_ONCE(sock->sk->sk_rcvtimeo, MAX_SCHEDULE_TIMEOUT);
67
65
}
68
66
69
67
static inline void ksmbd_tcp_snd_timeout(struct socket *sock, s64 secs)
+2
-2
include/net/sock.h
+2
-2
include/net/sock.h
···
2596
2596
2597
2597
static inline long sock_rcvtimeo(const struct sock *sk, bool noblock)
2598
2598
{
2599
-
return noblock ? 0 : sk->sk_rcvtimeo;
2599
+
return noblock ? 0 : READ_ONCE(sk->sk_rcvtimeo);
2600
2600
}
2601
2601
2602
2602
static inline long sock_sndtimeo(const struct sock *sk, bool noblock)
2603
2603
{
2604
-
return noblock ? 0 : sk->sk_sndtimeo;
2604
+
return noblock ? 0 : READ_ONCE(sk->sk_sndtimeo);
2605
2605
}
2606
2606
2607
2607
static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
+2
-2
net/bluetooth/iso.c
+2
-2
net/bluetooth/iso.c
···
413
413
sk->sk_state = BT_CONNECT;
414
414
} else {
415
415
sk->sk_state = BT_CONNECT;
416
-
iso_sock_set_timer(sk, sk->sk_sndtimeo);
416
+
iso_sock_set_timer(sk, READ_ONCE(sk->sk_sndtimeo));
417
417
}
418
418
419
419
release_sock(sk);
···
503
503
sk->sk_state = BT_CONNECT;
504
504
} else {
505
505
sk->sk_state = BT_CONNECT;
506
-
iso_sock_set_timer(sk, sk->sk_sndtimeo);
506
+
iso_sock_set_timer(sk, READ_ONCE(sk->sk_sndtimeo));
507
507
}
508
508
509
509
release_sock(sk);
+2
-2
net/bluetooth/l2cap_sock.c
+2
-2
net/bluetooth/l2cap_sock.c
···
255
255
256
256
err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
257
257
&la.l2_bdaddr, la.l2_bdaddr_type,
258
-
sk->sk_sndtimeo);
258
+
READ_ONCE(sk->sk_sndtimeo));
259
259
if (err)
260
260
return err;
261
261
···
1725
1725
{
1726
1726
struct sock *sk = chan->data;
1727
1727
1728
-
return sk->sk_sndtimeo;
1728
+
return READ_ONCE(sk->sk_sndtimeo);
1729
1729
}
1730
1730
1731
1731
static struct pid *l2cap_sock_get_peer_pid_cb(struct l2cap_chan *chan)
+2
-2
net/bluetooth/sco.c
+2
-2
net/bluetooth/sco.c
···
338
338
339
339
hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
340
340
sco_pi(sk)->setting, &sco_pi(sk)->codec,
341
-
sk->sk_sndtimeo);
341
+
READ_ONCE(sk->sk_sndtimeo));
342
342
if (IS_ERR(hcon)) {
343
343
err = PTR_ERR(hcon);
344
344
goto unlock;
···
367
367
sk->sk_state = BT_CONNECTED;
368
368
} else {
369
369
sk->sk_state = BT_CONNECT;
370
-
sco_sock_set_timer(sk, sk->sk_sndtimeo);
370
+
sco_sock_set_timer(sk, READ_ONCE(sk->sk_sndtimeo));
371
371
}
372
372
373
373
release_sock(sk);
+8
-14
net/core/sock.c
+8
-14
net/core/sock.c
···
818
818
819
819
void sock_set_sndtimeo(struct sock *sk, s64 secs)
820
820
{
821
-
lock_sock(sk);
822
821
if (secs && secs < MAX_SCHEDULE_TIMEOUT / HZ - 1)
823
822
WRITE_ONCE(sk->sk_sndtimeo, secs * HZ);
824
823
else
825
824
WRITE_ONCE(sk->sk_sndtimeo, MAX_SCHEDULE_TIMEOUT);
826
-
release_sock(sk);
827
825
}
828
826
EXPORT_SYMBOL(sock_set_sndtimeo);
829
827
···
1285
1287
case SO_DEVMEM_DONTNEED:
1286
1288
return sock_devmem_dontneed(sk, optval, optlen);
1287
1289
#endif
1290
+
case SO_SNDTIMEO_OLD:
1291
+
case SO_SNDTIMEO_NEW:
1292
+
return sock_set_timeout(&sk->sk_sndtimeo, optval,
1293
+
optlen, optname == SO_SNDTIMEO_OLD);
1294
+
case SO_RCVTIMEO_OLD:
1295
+
case SO_RCVTIMEO_NEW:
1296
+
return sock_set_timeout(&sk->sk_rcvtimeo, optval,
1297
+
optlen, optname == SO_RCVTIMEO_OLD);
1288
1298
}
1289
1299
1290
1300
sockopt_lock_sock(sk);
···
1448
1442
WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
1449
1443
break;
1450
1444
}
1451
-
case SO_RCVTIMEO_OLD:
1452
-
case SO_RCVTIMEO_NEW:
1453
-
ret = sock_set_timeout(&sk->sk_rcvtimeo, optval,
1454
-
optlen, optname == SO_RCVTIMEO_OLD);
1455
-
break;
1456
-
1457
-
case SO_SNDTIMEO_OLD:
1458
-
case SO_SNDTIMEO_NEW:
1459
-
ret = sock_set_timeout(&sk->sk_sndtimeo, optval,
1460
-
optlen, optname == SO_SNDTIMEO_OLD);
1461
-
break;
1462
-
1463
1445
case SO_ATTACH_FILTER: {
1464
1446
struct sock_fprog fprog;
1465
1447
+3
-3
net/llc/af_llc.c
+3
-3
net/llc/af_llc.c
···
210
210
dprintk("%s: closing local(%02X) remote(%02X)\n", __func__,
211
211
llc->laddr.lsap, llc->daddr.lsap);
212
212
if (!llc_send_disc(sk))
213
-
llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
213
+
llc_ui_wait_for_disc(sk, READ_ONCE(sk->sk_rcvtimeo));
214
214
if (!sock_flag(sk, SOCK_ZAPPED)) {
215
215
struct llc_sap *sap = llc->sap;
216
216
···
455
455
goto out;
456
456
rc = llc_send_disc(sk);
457
457
if (!rc)
458
-
rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
458
+
rc = llc_ui_wait_for_disc(sk, READ_ONCE(sk->sk_rcvtimeo));
459
459
/* Wake up anyone sleeping in poll */
460
460
sk->sk_state_change(sk);
461
461
out:
···
712
712
goto out;
713
713
/* wait for a connection to arrive. */
714
714
if (skb_queue_empty(&sk->sk_receive_queue)) {
715
-
rc = llc_wait_data(sk, sk->sk_rcvtimeo);
715
+
rc = llc_wait_data(sk, READ_ONCE(sk->sk_rcvtimeo));
716
716
if (rc)
717
717
goto out;
718
718
}
+2
-2
net/sctp/socket.c
+2
-2
net/sctp/socket.c
···
9492
9492
newsk->sk_sndbuf = sk->sk_sndbuf;
9493
9493
newsk->sk_rcvbuf = sk->sk_rcvbuf;
9494
9494
newsk->sk_lingertime = sk->sk_lingertime;
9495
-
newsk->sk_rcvtimeo = sk->sk_rcvtimeo;
9496
-
newsk->sk_sndtimeo = sk->sk_sndtimeo;
9495
+
newsk->sk_rcvtimeo = READ_ONCE(sk->sk_rcvtimeo);
9496
+
newsk->sk_sndtimeo = READ_ONCE(sk->sk_sndtimeo);
9497
9497
newsk->sk_rxhash = sk->sk_rxhash;
9498
9498
9499
9499
newinet = inet_sk(newsk);
+3
-3
net/smc/af_smc.c
+3
-3
net/smc/af_smc.c
···
486
486
{
487
487
/* options we don't get control via setsockopt for */
488
488
nsk->sk_type = osk->sk_type;
489
-
nsk->sk_sndtimeo = osk->sk_sndtimeo;
490
-
nsk->sk_rcvtimeo = osk->sk_rcvtimeo;
489
+
nsk->sk_sndtimeo = READ_ONCE(osk->sk_sndtimeo);
490
+
nsk->sk_rcvtimeo = READ_ONCE(osk->sk_rcvtimeo);
491
491
nsk->sk_mark = READ_ONCE(osk->sk_mark);
492
492
nsk->sk_priority = READ_ONCE(osk->sk_priority);
493
493
nsk->sk_rcvlowat = osk->sk_rcvlowat;
···
1585
1585
{
1586
1586
struct smc_sock *smc = container_of(work, struct smc_sock,
1587
1587
connect_work);
1588
-
long timeo = smc->sk.sk_sndtimeo;
1588
+
long timeo = READ_ONCE(smc->sk.sk_sndtimeo);
1589
1589
int rc = 0;
1590
1590
1591
1591
if (!timeo)
+3
-3
net/smc/smc_clc.c
+3
-3
net/smc/smc_clc.c
···
688
688
int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
689
689
u8 expected_type, unsigned long timeout)
690
690
{
691
-
long rcvtimeo = smc->clcsock->sk->sk_rcvtimeo;
691
+
long rcvtimeo = READ_ONCE(smc->clcsock->sk->sk_rcvtimeo);
692
692
struct sock *clc_sk = smc->clcsock->sk;
693
693
struct smc_clc_msg_hdr *clcm = buf;
694
694
struct msghdr msg = {NULL, 0};
···
707
707
* sizeof(struct smc_clc_msg_hdr)
708
708
*/
709
709
krflags = MSG_PEEK | MSG_WAITALL;
710
-
clc_sk->sk_rcvtimeo = timeout;
710
+
WRITE_ONCE(clc_sk->sk_rcvtimeo, timeout);
711
711
iov_iter_kvec(&msg.msg_iter, ITER_DEST, &vec, 1,
712
712
sizeof(struct smc_clc_msg_hdr));
713
713
len = sock_recvmsg(smc->clcsock, &msg, krflags);
···
795
795
}
796
796
797
797
out:
798
-
clc_sk->sk_rcvtimeo = rcvtimeo;
798
+
WRITE_ONCE(clc_sk->sk_rcvtimeo, rcvtimeo);
799
799
return reason_code;
800
800
}
801
801
+1
-1
net/strparser/strparser.c
+1
-1
net/strparser/strparser.c
···
333
333
struct strparser *strp = (struct strparser *)desc->arg.data;
334
334
335
335
return __strp_recv(desc, orig_skb, orig_offset, orig_len,
336
-
strp->sk->sk_rcvbuf, strp->sk->sk_rcvtimeo);
336
+
strp->sk->sk_rcvbuf, READ_ONCE(strp->sk->sk_rcvtimeo));
337
337
}
338
338
339
339
static int default_read_sock_done(struct strparser *strp, int err)