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