[PATCH net-next 14/14] netfilter: cttimeout: annotate data-races around the default timeouts
From: Jiayuan Chen
Date: Sun Nov 08 2026 - 22:08:42 EST
cttimeout_default_set() and cttimeout_default_get() hand the per-netns
default timeout arrays to the l4proto nlattr_to_obj() and obj_to_nlattr()
callbacks, which write and read them with plain accesses while the
nf_conntrack_*_timeout* sysctl handlers update the same fields with
WRITE_ONCE(). Use WRITE_ONCE() and READ_ONCE() in the callbacks.
KCSAN reports both sides when the UDP default timeouts are set over
nfnetlink while UDP traffic goes through conntrack, or while the sysctl
is written:
BUG: KCSAN: data-race in nf_conntrack_udp_packet / udp_timeout_nlattr_to_obj
write to 0xffffffffb0829bc4 of 4 bytes by task 457 on cpu 1:
udp_timeout_nlattr_to_obj+0x3b/0xf0
ctnl_timeout_parse_policy+0xc0/0x100
cttimeout_default_set+0x8f/0xc0
nfnetlink_rcv_msg+0x64c/0xc90
netlink_rcv_skb+0x9c/0x1b0
nfnetlink_rcv+0x9b/0x1e0
netlink_unicast+0x418/0x5c0
netlink_sendmsg+0x3fc/0x750
...
read to 0xffffffffb0829bc4 of 4 bytes by task 459 on cpu 0:
nf_conntrack_udp_packet+0x27b/0x550
nf_conntrack_in+0x767/0xb20
ipv4_conntrack_local+0xb0/0x120
nf_hook_slow+0x7e/0x180
...
value changed: 0x00001e46 -> 0x00001d4c
BUG: KCSAN: data-race in proc_int_u2k_conv_uop / udp_timeout_nlattr_to_obj
write (marked) to 0xffffffffb0829bc4 of 4 bytes by task 475 on cpu 1:
proc_int_u2k_conv_uop+0x92/0xa0
...
proc_dointvec_jiffies+0x15/0x30
proc_sys_call_handler+0x282/0x3a0
proc_sys_write+0x13/0x20
...
read to 0xffffffffb0829bc4 of 4 bytes by task 474 on cpu 0:
udp_timeout_nlattr_to_obj+0x2c/0xf0
ctnl_timeout_parse_policy+0xc0/0x100
cttimeout_default_set+0x8f/0xc0
nfnetlink_rcv_msg+0x64c/0xc90
...
value changed: 0x00001d4c -> 0x00001e46
Signed-off-by: Jiayuan Chen <jiayuan.chen@xxxxxxxxx>
---
net/netfilter/nf_conntrack_proto_generic.c | 8 +--
net/netfilter/nf_conntrack_proto_gre.c | 16 ++---
net/netfilter/nf_conntrack_proto_icmp.c | 8 +--
net/netfilter/nf_conntrack_proto_icmpv6.c | 8 +--
net/netfilter/nf_conntrack_proto_sctp.c | 9 +--
net/netfilter/nf_conntrack_proto_tcp.c | 71 +++++++++++-----------
net/netfilter/nf_conntrack_proto_udp.c | 16 ++---
7 files changed, 69 insertions(+), 67 deletions(-)
diff --git a/net/netfilter/nf_conntrack_proto_generic.c b/net/netfilter/nf_conntrack_proto_generic.c
index cb260eb3d012c..08b8d44c9f402 100644
--- a/net/netfilter/nf_conntrack_proto_generic.c
+++ b/net/netfilter/nf_conntrack_proto_generic.c
@@ -27,11 +27,11 @@ static int generic_timeout_nlattr_to_obj(struct nlattr *tb[],
timeout = &gn->timeout;
if (tb[CTA_TIMEOUT_GENERIC_TIMEOUT])
- *timeout =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_GENERIC_TIMEOUT])) * HZ;
+ WRITE_ONCE(*timeout,
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_GENERIC_TIMEOUT])) * HZ);
else {
/* Set default generic timeout. */
- *timeout = gn->timeout;
+ WRITE_ONCE(*timeout, READ_ONCE(gn->timeout));
}
return 0;
@@ -42,7 +42,7 @@ generic_timeout_obj_to_nlattr(struct sk_buff *skb, const void *data)
{
const unsigned int *timeout = data;
- if (nla_put_be32(skb, CTA_TIMEOUT_GENERIC_TIMEOUT, htonl(*timeout / HZ)))
+ if (nla_put_be32(skb, CTA_TIMEOUT_GENERIC_TIMEOUT, htonl(READ_ONCE(*timeout) / HZ)))
goto nla_put_failure;
return 0;
diff --git a/net/netfilter/nf_conntrack_proto_gre.c b/net/netfilter/nf_conntrack_proto_gre.c
index d8bca1e29797b..e1b99c5a7c7a2 100644
--- a/net/netfilter/nf_conntrack_proto_gre.c
+++ b/net/netfilter/nf_conntrack_proto_gre.c
@@ -318,16 +318,16 @@ static int gre_timeout_nlattr_to_obj(struct nlattr *tb[],
if (!timeouts)
timeouts = gre_get_timeouts(net);
/* set default timeouts for GRE. */
- timeouts[GRE_CT_UNREPLIED] = net_gre->timeouts[GRE_CT_UNREPLIED];
- timeouts[GRE_CT_REPLIED] = net_gre->timeouts[GRE_CT_REPLIED];
+ WRITE_ONCE(timeouts[GRE_CT_UNREPLIED], READ_ONCE(net_gre->timeouts[GRE_CT_UNREPLIED]));
+ WRITE_ONCE(timeouts[GRE_CT_REPLIED], READ_ONCE(net_gre->timeouts[GRE_CT_REPLIED]));
if (tb[CTA_TIMEOUT_GRE_UNREPLIED]) {
- timeouts[GRE_CT_UNREPLIED] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_GRE_UNREPLIED])) * HZ;
+ WRITE_ONCE(timeouts[GRE_CT_UNREPLIED],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_GRE_UNREPLIED])) * HZ);
}
if (tb[CTA_TIMEOUT_GRE_REPLIED]) {
- timeouts[GRE_CT_REPLIED] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_GRE_REPLIED])) * HZ;
+ WRITE_ONCE(timeouts[GRE_CT_REPLIED],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_GRE_REPLIED])) * HZ);
}
return 0;
}
@@ -338,9 +338,9 @@ gre_timeout_obj_to_nlattr(struct sk_buff *skb, const void *data)
const unsigned int *timeouts = data;
if (nla_put_be32(skb, CTA_TIMEOUT_GRE_UNREPLIED,
- htonl(timeouts[GRE_CT_UNREPLIED] / HZ)) ||
+ htonl(READ_ONCE(timeouts[GRE_CT_UNREPLIED]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_GRE_REPLIED,
- htonl(timeouts[GRE_CT_REPLIED] / HZ)))
+ htonl(READ_ONCE(timeouts[GRE_CT_REPLIED]) / HZ)))
goto nla_put_failure;
return 0;
diff --git a/net/netfilter/nf_conntrack_proto_icmp.c b/net/netfilter/nf_conntrack_proto_icmp.c
index 0f6ef0443c6fa..0d8499b54f878 100644
--- a/net/netfilter/nf_conntrack_proto_icmp.c
+++ b/net/netfilter/nf_conntrack_proto_icmp.c
@@ -327,11 +327,11 @@ static int icmp_timeout_nlattr_to_obj(struct nlattr *tb[],
if (tb[CTA_TIMEOUT_ICMP_TIMEOUT]) {
if (!timeout)
timeout = &in->timeout;
- *timeout =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_ICMP_TIMEOUT])) * HZ;
+ WRITE_ONCE(*timeout,
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_ICMP_TIMEOUT])) * HZ);
} else if (timeout) {
/* Set default ICMP timeout. */
- *timeout = in->timeout;
+ WRITE_ONCE(*timeout, READ_ONCE(in->timeout));
}
return 0;
}
@@ -341,7 +341,7 @@ icmp_timeout_obj_to_nlattr(struct sk_buff *skb, const void *data)
{
const unsigned int *timeout = data;
- if (nla_put_be32(skb, CTA_TIMEOUT_ICMP_TIMEOUT, htonl(*timeout / HZ)))
+ if (nla_put_be32(skb, CTA_TIMEOUT_ICMP_TIMEOUT, htonl(READ_ONCE(*timeout) / HZ)))
goto nla_put_failure;
return 0;
diff --git a/net/netfilter/nf_conntrack_proto_icmpv6.c b/net/netfilter/nf_conntrack_proto_icmpv6.c
index e4eebf13950cb..6ed0f7ba60c3d 100644
--- a/net/netfilter/nf_conntrack_proto_icmpv6.c
+++ b/net/netfilter/nf_conntrack_proto_icmpv6.c
@@ -305,11 +305,11 @@ static int icmpv6_timeout_nlattr_to_obj(struct nlattr *tb[],
if (!timeout)
timeout = icmpv6_get_timeouts(net);
if (tb[CTA_TIMEOUT_ICMPV6_TIMEOUT]) {
- *timeout =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_ICMPV6_TIMEOUT])) * HZ;
+ WRITE_ONCE(*timeout,
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_ICMPV6_TIMEOUT])) * HZ);
} else {
/* Set default ICMPv6 timeout. */
- *timeout = in->timeout;
+ WRITE_ONCE(*timeout, READ_ONCE(in->timeout));
}
return 0;
}
@@ -319,7 +319,7 @@ icmpv6_timeout_obj_to_nlattr(struct sk_buff *skb, const void *data)
{
const unsigned int *timeout = data;
- if (nla_put_be32(skb, CTA_TIMEOUT_ICMPV6_TIMEOUT, htonl(*timeout / HZ)))
+ if (nla_put_be32(skb, CTA_TIMEOUT_ICMPV6_TIMEOUT, htonl(READ_ONCE(*timeout) / HZ)))
goto nla_put_failure;
return 0;
diff --git a/net/netfilter/nf_conntrack_proto_sctp.c b/net/netfilter/nf_conntrack_proto_sctp.c
index 047bf69113bf9..ea6dd1ef3df89 100644
--- a/net/netfilter/nf_conntrack_proto_sctp.c
+++ b/net/netfilter/nf_conntrack_proto_sctp.c
@@ -650,16 +650,17 @@ static int sctp_timeout_nlattr_to_obj(struct nlattr *tb[],
/* set default SCTP timeouts. */
for (i=0; i<SCTP_CONNTRACK_MAX; i++)
- timeouts[i] = sn->timeouts[i];
+ WRITE_ONCE(timeouts[i], READ_ONCE(sn->timeouts[i]));
/* there's a 1:1 mapping between attributes and protocol states. */
for (i=CTA_TIMEOUT_SCTP_UNSPEC+1; i<CTA_TIMEOUT_SCTP_MAX+1; i++) {
if (tb[i]) {
- timeouts[i] = ntohl(nla_get_be32(tb[i])) * HZ;
+ WRITE_ONCE(timeouts[i], ntohl(nla_get_be32(tb[i])) * HZ);
}
}
- timeouts[CTA_TIMEOUT_SCTP_UNSPEC] = timeouts[CTA_TIMEOUT_SCTP_CLOSED];
+ WRITE_ONCE(timeouts[CTA_TIMEOUT_SCTP_UNSPEC],
+ READ_ONCE(timeouts[CTA_TIMEOUT_SCTP_CLOSED]));
return 0;
}
@@ -670,7 +671,7 @@ sctp_timeout_obj_to_nlattr(struct sk_buff *skb, const void *data)
int i;
for (i=CTA_TIMEOUT_SCTP_UNSPEC+1; i<CTA_TIMEOUT_SCTP_MAX+1; i++) {
- if (nla_put_be32(skb, i, htonl(timeouts[i] / HZ)))
+ if (nla_put_be32(skb, i, htonl(READ_ONCE(timeouts[i]) / HZ)))
goto nla_put_failure;
}
return 0;
diff --git a/net/netfilter/nf_conntrack_proto_tcp.c b/net/netfilter/nf_conntrack_proto_tcp.c
index 0c61a16fca400..e1db372b9e530 100644
--- a/net/netfilter/nf_conntrack_proto_tcp.c
+++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -1523,55 +1523,56 @@ static int tcp_timeout_nlattr_to_obj(struct nlattr *tb[],
timeouts = tn->timeouts;
/* set default TCP timeouts. */
for (i=0; i<TCP_CONNTRACK_TIMEOUT_MAX; i++)
- timeouts[i] = tn->timeouts[i];
+ WRITE_ONCE(timeouts[i], READ_ONCE(tn->timeouts[i]));
if (tb[CTA_TIMEOUT_TCP_SYN_SENT]) {
- timeouts[TCP_CONNTRACK_SYN_SENT] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_SYN_SENT]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_SYN_SENT],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_SYN_SENT])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_SYN_RECV]) {
- timeouts[TCP_CONNTRACK_SYN_RECV] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_SYN_RECV]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_SYN_RECV],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_SYN_RECV])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_ESTABLISHED]) {
- timeouts[TCP_CONNTRACK_ESTABLISHED] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_ESTABLISHED]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_ESTABLISHED],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_ESTABLISHED])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_FIN_WAIT]) {
- timeouts[TCP_CONNTRACK_FIN_WAIT] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_FIN_WAIT]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_FIN_WAIT],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_FIN_WAIT])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_CLOSE_WAIT]) {
- timeouts[TCP_CONNTRACK_CLOSE_WAIT] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_CLOSE_WAIT]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_CLOSE_WAIT],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_CLOSE_WAIT])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_LAST_ACK]) {
- timeouts[TCP_CONNTRACK_LAST_ACK] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_LAST_ACK]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_LAST_ACK],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_LAST_ACK])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_TIME_WAIT]) {
- timeouts[TCP_CONNTRACK_TIME_WAIT] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_TIME_WAIT]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_TIME_WAIT],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_TIME_WAIT])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_CLOSE]) {
- timeouts[TCP_CONNTRACK_CLOSE] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_CLOSE]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_CLOSE],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_CLOSE])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_SYN_SENT2]) {
- timeouts[TCP_CONNTRACK_SYN_SENT2] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_SYN_SENT2]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_SYN_SENT2],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_SYN_SENT2])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_RETRANS]) {
- timeouts[TCP_CONNTRACK_RETRANS] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_RETRANS]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_RETRANS],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_RETRANS])) * HZ);
}
if (tb[CTA_TIMEOUT_TCP_UNACK]) {
- timeouts[TCP_CONNTRACK_UNACK] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_UNACK]))*HZ;
+ WRITE_ONCE(timeouts[TCP_CONNTRACK_UNACK],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_TCP_UNACK])) * HZ);
}
- timeouts[CTA_TIMEOUT_TCP_UNSPEC] = timeouts[CTA_TIMEOUT_TCP_SYN_SENT];
+ WRITE_ONCE(timeouts[CTA_TIMEOUT_TCP_UNSPEC],
+ READ_ONCE(timeouts[CTA_TIMEOUT_TCP_SYN_SENT]));
return 0;
}
@@ -1581,27 +1582,27 @@ tcp_timeout_obj_to_nlattr(struct sk_buff *skb, const void *data)
const unsigned int *timeouts = data;
if (nla_put_be32(skb, CTA_TIMEOUT_TCP_SYN_SENT,
- htonl(timeouts[TCP_CONNTRACK_SYN_SENT] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_SYN_SENT]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_SYN_RECV,
- htonl(timeouts[TCP_CONNTRACK_SYN_RECV] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_SYN_RECV]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_ESTABLISHED,
- htonl(timeouts[TCP_CONNTRACK_ESTABLISHED] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_ESTABLISHED]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_FIN_WAIT,
- htonl(timeouts[TCP_CONNTRACK_FIN_WAIT] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_FIN_WAIT]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_CLOSE_WAIT,
- htonl(timeouts[TCP_CONNTRACK_CLOSE_WAIT] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_CLOSE_WAIT]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_LAST_ACK,
- htonl(timeouts[TCP_CONNTRACK_LAST_ACK] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_LAST_ACK]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_TIME_WAIT,
- htonl(timeouts[TCP_CONNTRACK_TIME_WAIT] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_TIME_WAIT]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_CLOSE,
- htonl(timeouts[TCP_CONNTRACK_CLOSE] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_CLOSE]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_SYN_SENT2,
- htonl(timeouts[TCP_CONNTRACK_SYN_SENT2] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_SYN_SENT2]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_RETRANS,
- htonl(timeouts[TCP_CONNTRACK_RETRANS] / HZ)) ||
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_RETRANS]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_TCP_UNACK,
- htonl(timeouts[TCP_CONNTRACK_UNACK] / HZ)))
+ htonl(READ_ONCE(timeouts[TCP_CONNTRACK_UNACK]) / HZ)))
goto nla_put_failure;
return 0;
diff --git a/net/netfilter/nf_conntrack_proto_udp.c b/net/netfilter/nf_conntrack_proto_udp.c
index 99eedaa2b1183..777b21da3bcff 100644
--- a/net/netfilter/nf_conntrack_proto_udp.c
+++ b/net/netfilter/nf_conntrack_proto_udp.c
@@ -155,16 +155,16 @@ static int udp_timeout_nlattr_to_obj(struct nlattr *tb[],
timeouts = un->timeouts;
/* set default timeouts for UDP. */
- timeouts[UDP_CT_UNREPLIED] = un->timeouts[UDP_CT_UNREPLIED];
- timeouts[UDP_CT_REPLIED] = un->timeouts[UDP_CT_REPLIED];
+ WRITE_ONCE(timeouts[UDP_CT_UNREPLIED], READ_ONCE(un->timeouts[UDP_CT_UNREPLIED]));
+ WRITE_ONCE(timeouts[UDP_CT_REPLIED], READ_ONCE(un->timeouts[UDP_CT_REPLIED]));
if (tb[CTA_TIMEOUT_UDP_UNREPLIED]) {
- timeouts[UDP_CT_UNREPLIED] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_UDP_UNREPLIED])) * HZ;
+ WRITE_ONCE(timeouts[UDP_CT_UNREPLIED],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_UDP_UNREPLIED])) * HZ);
}
if (tb[CTA_TIMEOUT_UDP_REPLIED]) {
- timeouts[UDP_CT_REPLIED] =
- ntohl(nla_get_be32(tb[CTA_TIMEOUT_UDP_REPLIED])) * HZ;
+ WRITE_ONCE(timeouts[UDP_CT_REPLIED],
+ ntohl(nla_get_be32(tb[CTA_TIMEOUT_UDP_REPLIED])) * HZ);
}
return 0;
}
@@ -175,9 +175,9 @@ udp_timeout_obj_to_nlattr(struct sk_buff *skb, const void *data)
const unsigned int *timeouts = data;
if (nla_put_be32(skb, CTA_TIMEOUT_UDP_UNREPLIED,
- htonl(timeouts[UDP_CT_UNREPLIED] / HZ)) ||
+ htonl(READ_ONCE(timeouts[UDP_CT_UNREPLIED]) / HZ)) ||
nla_put_be32(skb, CTA_TIMEOUT_UDP_REPLIED,
- htonl(timeouts[UDP_CT_REPLIED] / HZ)))
+ htonl(READ_ONCE(timeouts[UDP_CT_REPLIED]) / HZ)))
goto nla_put_failure;
return 0;
--
2.43.0