net_sched: sch_fq_pie: implement lockless fq_pie_dump()

Instead of relying on RTNL, fq_pie_dump() can use READ_ONCE()
annotations, paired with WRITE_ONCE() ones in fq_pie_change().

Signed-off-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: Simon Horman <horms@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/sched/sch_fq_pie.c b/net/sched/sch_fq_pie.c
index 358cf30..c38f33f 100644 (file)
--- a/net/sched/sch_fq_pie.c
+++ b/net/sched/sch_fq_pie.c
@@ -299,8 +299,8 @@ static int fq_pie_change(struct Qdisc *sch, struct nlattr *opt,
        if (tb[TCA_FQ_PIE_LIMIT]) {
                u32 limit = nla_get_u32(tb[TCA_FQ_PIE_LIMIT]);
 
-               q->p_params.limit = limit;
-               sch->limit = limit;
+               WRITE_ONCE(q->p_params.limit, limit);
+               WRITE_ONCE(sch->limit, limit);
        }
        if (tb[TCA_FQ_PIE_FLOWS]) {
                if (q->flows) {
@@ -322,39 +322,45 @@ static int fq_pie_change(struct Qdisc *sch, struct nlattr *opt,
                u32 target = nla_get_u32(tb[TCA_FQ_PIE_TARGET]);
 
                /* convert to pschedtime */
-               q->p_params.target =
-                       PSCHED_NS2TICKS((u64)target * NSEC_PER_USEC);
+               WRITE_ONCE(q->p_params.target,
+                          PSCHED_NS2TICKS((u64)target * NSEC_PER_USEC));
        }
 
        /* tupdate is in jiffies */
        if (tb[TCA_FQ_PIE_TUPDATE])
-               q->p_params.tupdate =
-                       usecs_to_jiffies(nla_get_u32(tb[TCA_FQ_PIE_TUPDATE]));
+               WRITE_ONCE(q->p_params.tupdate,
+                       usecs_to_jiffies(nla_get_u32(tb[TCA_FQ_PIE_TUPDATE])));
 
        if (tb[TCA_FQ_PIE_ALPHA])
-               q->p_params.alpha = nla_get_u32(tb[TCA_FQ_PIE_ALPHA]);
+               WRITE_ONCE(q->p_params.alpha,
+                          nla_get_u32(tb[TCA_FQ_PIE_ALPHA]));
 
        if (tb[TCA_FQ_PIE_BETA])
-               q->p_params.beta = nla_get_u32(tb[TCA_FQ_PIE_BETA]);
+               WRITE_ONCE(q->p_params.beta,
+                          nla_get_u32(tb[TCA_FQ_PIE_BETA]));
 
        if (tb[TCA_FQ_PIE_QUANTUM])
-               q->quantum = nla_get_u32(tb[TCA_FQ_PIE_QUANTUM]);
+               WRITE_ONCE(q->quantum, nla_get_u32(tb[TCA_FQ_PIE_QUANTUM]));
 
        if (tb[TCA_FQ_PIE_MEMORY_LIMIT])
-               q->memory_limit = nla_get_u32(tb[TCA_FQ_PIE_MEMORY_LIMIT]);
+               WRITE_ONCE(q->memory_limit,
+                          nla_get_u32(tb[TCA_FQ_PIE_MEMORY_LIMIT]));
 
        if (tb[TCA_FQ_PIE_ECN_PROB])
-               q->ecn_prob = nla_get_u32(tb[TCA_FQ_PIE_ECN_PROB]);
+               WRITE_ONCE(q->ecn_prob,
+                          nla_get_u32(tb[TCA_FQ_PIE_ECN_PROB]));
 
        if (tb[TCA_FQ_PIE_ECN])
-               q->p_params.ecn = nla_get_u32(tb[TCA_FQ_PIE_ECN]);
+               WRITE_ONCE(q->p_params.ecn,
+                          nla_get_u32(tb[TCA_FQ_PIE_ECN]));
 
        if (tb[TCA_FQ_PIE_BYTEMODE])
-               q->p_params.bytemode = nla_get_u32(tb[TCA_FQ_PIE_BYTEMODE]);
+               WRITE_ONCE(q->p_params.bytemode,
+                          nla_get_u32(tb[TCA_FQ_PIE_BYTEMODE]));
 
        if (tb[TCA_FQ_PIE_DQ_RATE_ESTIMATOR])
-               q->p_params.dq_rate_estimator =
-                       nla_get_u32(tb[TCA_FQ_PIE_DQ_RATE_ESTIMATOR]);
+               WRITE_ONCE(q->p_params.dq_rate_estimator,
+                          nla_get_u32(tb[TCA_FQ_PIE_DQ_RATE_ESTIMATOR]));
 
        /* Drop excess packets if new limit is lower */
        while (sch->q.qlen > sch->limit) {
@@ -471,22 +477,23 @@ static int fq_pie_dump(struct Qdisc *sch, struct sk_buff *skb)
                return -EMSGSIZE;
 
        /* convert target from pschedtime to us */
-       if (nla_put_u32(skb, TCA_FQ_PIE_LIMIT, sch->limit) ||
-           nla_put_u32(skb, TCA_FQ_PIE_FLOWS, q->flows_cnt) ||
+       if (nla_put_u32(skb, TCA_FQ_PIE_LIMIT, READ_ONCE(sch->limit)) ||
+           nla_put_u32(skb, TCA_FQ_PIE_FLOWS, READ_ONCE(q->flows_cnt)) ||
            nla_put_u32(skb, TCA_FQ_PIE_TARGET,
-                       ((u32)PSCHED_TICKS2NS(q->p_params.target)) /
+                       ((u32)PSCHED_TICKS2NS(READ_ONCE(q->p_params.target))) /
                        NSEC_PER_USEC) ||
            nla_put_u32(skb, TCA_FQ_PIE_TUPDATE,
-                       jiffies_to_usecs(q->p_params.tupdate)) ||
-           nla_put_u32(skb, TCA_FQ_PIE_ALPHA, q->p_params.alpha) ||
-           nla_put_u32(skb, TCA_FQ_PIE_BETA, q->p_params.beta) ||
-           nla_put_u32(skb, TCA_FQ_PIE_QUANTUM, q->quantum) ||
-           nla_put_u32(skb, TCA_FQ_PIE_MEMORY_LIMIT, q->memory_limit) ||
-           nla_put_u32(skb, TCA_FQ_PIE_ECN_PROB, q->ecn_prob) ||
-           nla_put_u32(skb, TCA_FQ_PIE_ECN, q->p_params.ecn) ||
-           nla_put_u32(skb, TCA_FQ_PIE_BYTEMODE, q->p_params.bytemode) ||
+                       jiffies_to_usecs(READ_ONCE(q->p_params.tupdate))) ||
+           nla_put_u32(skb, TCA_FQ_PIE_ALPHA, READ_ONCE(q->p_params.alpha)) ||
+           nla_put_u32(skb, TCA_FQ_PIE_BETA, READ_ONCE(q->p_params.beta)) ||
+           nla_put_u32(skb, TCA_FQ_PIE_QUANTUM, READ_ONCE(q->quantum)) ||
+           nla_put_u32(skb, TCA_FQ_PIE_MEMORY_LIMIT,
+                       READ_ONCE(q->memory_limit)) ||
+           nla_put_u32(skb, TCA_FQ_PIE_ECN_PROB, READ_ONCE(q->ecn_prob)) ||
+           nla_put_u32(skb, TCA_FQ_PIE_ECN, READ_ONCE(q->p_params.ecn)) ||
+           nla_put_u32(skb, TCA_FQ_PIE_BYTEMODE, READ_ONCE(q->p_params.bytemode)) ||
            nla_put_u32(skb, TCA_FQ_PIE_DQ_RATE_ESTIMATOR,
-                       q->p_params.dq_rate_estimator))
+                       READ_ONCE(q->p_params.dq_rate_estimator)))
                goto nla_put_failure;
 
        return nla_nest_end(skb, opts);