Commit 13a9965d authored by Eric Dumazet's avatar Eric Dumazet Committed by David S. Miller
Browse files

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: default avatarEric Dumazet <edumazet@google.com>
Reviewed-by: default avatarSimon Horman <horms@kernel.org>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 396a0038

net/sched/sch_fq_pie.c

+34 −27
Original line number Diff line number Diff line
@@ -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);