Commit 00ac0dc3 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'net_sched-dump-no-rtnl' 



Eric Dumazet says:

====================
net_sched: first series for RTNL-less qdisc dumps

Medium term goal is to implement "tc qdisc show" without needing
to acquire RTNL.

This first series makes the requested changes in 14 qdisc.

Notes :

 - RTNL is still held in "tc qdisc show", more changes are needed.

 - Qdisc returning many attributes might want/need to provide
   a consistent set of attributes. If that is the case, their
   dump() method could acquire the qdisc spinlock, to pair the
   spinlock acquision in their change() method.

V2: Addressed Simon feedback (Thanks a lot Simon)
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents fdf41237 c85cedb3

include/net/red.h

+6 −6
Original line number Diff line number Diff line
@@ -233,10 +233,10 @@ static inline void red_set_parms(struct red_parms *p, 
	int delta = qth_max - qth_min;

	u32 max_p_delta;



	p->qth_min	= qth_min << Wlog;

	p->qth_max	= qth_max << Wlog;

	p->Wlog		= Wlog;

	p->Plog		= Plog;

	WRITE_ONCE(p->qth_min, qth_min << Wlog);

	WRITE_ONCE(p->qth_max, qth_max << Wlog);

	WRITE_ONCE(p->Wlog, Wlog);

	WRITE_ONCE(p->Plog, Plog);

	if (delta <= 0)

		delta = 1;

	p->qth_delta	= delta;
@@ -244,7 +244,7 @@ static inline void red_set_parms(struct red_parms *p, 
		max_P = red_maxp(Plog);

		max_P *= delta; /* max_P = (qth_max - qth_min)/2^Plog */

	}

	p->max_P = max_P;

	WRITE_ONCE(p->max_P, max_P);

	max_p_delta = max_P / delta;

	max_p_delta = max(max_p_delta, 1U);

	p->max_P_reciprocal  = reciprocal_value(max_p_delta);
@@ -257,7 +257,7 @@ static inline void red_set_parms(struct red_parms *p, 
	p->target_min = qth_min + 2*delta;

	p->target_max = qth_min + 3*delta;



	p->Scell_log	= Scell_log;

	WRITE_ONCE(p->Scell_log, Scell_log);

	p->Scell_max	= (255 << Scell_log);



	if (stab)

net/sched/sch_cake.c

+63 −47
Original line number Diff line number Diff line
@@ -2572,6 +2572,8 @@ static int cake_change(struct Qdisc *sch, struct nlattr *opt, 
{

	struct cake_sched_data *q = qdisc_priv(sch);

	struct nlattr *tb[TCA_CAKE_MAX + 1];

	u16 rate_flags;

	u8 flow_mode;

	int err;



	err = nla_parse_nested_deprecated(tb, TCA_CAKE_MAX, opt, cake_policy,
@@ -2579,10 +2581,11 @@ static int cake_change(struct Qdisc *sch, struct nlattr *opt, 
	if (err < 0)

		return err;



	flow_mode = q->flow_mode;

	if (tb[TCA_CAKE_NAT]) {

#if IS_ENABLED(CONFIG_NF_CONNTRACK)

		q->flow_mode &= ~CAKE_FLOW_NAT_FLAG;

		q->flow_mode |= CAKE_FLOW_NAT_FLAG *

		flow_mode &= ~CAKE_FLOW_NAT_FLAG;

		flow_mode |= CAKE_FLOW_NAT_FLAG *

			!!nla_get_u32(tb[TCA_CAKE_NAT]);

#else

		NL_SET_ERR_MSG_ATTR(extack, tb[TCA_CAKE_NAT],
@@ -2592,29 +2595,34 @@ static int cake_change(struct Qdisc *sch, struct nlattr *opt, 
	}



	if (tb[TCA_CAKE_BASE_RATE64])

		q->rate_bps = nla_get_u64(tb[TCA_CAKE_BASE_RATE64]);

		WRITE_ONCE(q->rate_bps,

			   nla_get_u64(tb[TCA_CAKE_BASE_RATE64]));



	if (tb[TCA_CAKE_DIFFSERV_MODE])

		q->tin_mode = nla_get_u32(tb[TCA_CAKE_DIFFSERV_MODE]);

		WRITE_ONCE(q->tin_mode,

			   nla_get_u32(tb[TCA_CAKE_DIFFSERV_MODE]));



	rate_flags = q->rate_flags;

	if (tb[TCA_CAKE_WASH]) {

		if (!!nla_get_u32(tb[TCA_CAKE_WASH]))

			q->rate_flags |= CAKE_FLAG_WASH;

			rate_flags |= CAKE_FLAG_WASH;

		else

			q->rate_flags &= ~CAKE_FLAG_WASH;

			rate_flags &= ~CAKE_FLAG_WASH;

	}



	if (tb[TCA_CAKE_FLOW_MODE])

		q->flow_mode = ((q->flow_mode & CAKE_FLOW_NAT_FLAG) |

		flow_mode = ((flow_mode & CAKE_FLOW_NAT_FLAG) |

				(nla_get_u32(tb[TCA_CAKE_FLOW_MODE]) &

					CAKE_FLOW_MASK));



	if (tb[TCA_CAKE_ATM])

		q->atm_mode = nla_get_u32(tb[TCA_CAKE_ATM]);

		WRITE_ONCE(q->atm_mode,

			   nla_get_u32(tb[TCA_CAKE_ATM]));



	if (tb[TCA_CAKE_OVERHEAD]) {

		q->rate_overhead = nla_get_s32(tb[TCA_CAKE_OVERHEAD]);

		q->rate_flags |= CAKE_FLAG_OVERHEAD;

		WRITE_ONCE(q->rate_overhead,

			   nla_get_s32(tb[TCA_CAKE_OVERHEAD]));

		rate_flags |= CAKE_FLAG_OVERHEAD;



		q->max_netlen = 0;

		q->max_adjlen = 0;
@@ -2623,7 +2631,7 @@ static int cake_change(struct Qdisc *sch, struct nlattr *opt, 
	}



	if (tb[TCA_CAKE_RAW]) {

		q->rate_flags &= ~CAKE_FLAG_OVERHEAD;

		rate_flags &= ~CAKE_FLAG_OVERHEAD;



		q->max_netlen = 0;

		q->max_adjlen = 0;
@@ -2632,54 +2640,58 @@ static int cake_change(struct Qdisc *sch, struct nlattr *opt, 
	}



	if (tb[TCA_CAKE_MPU])

		q->rate_mpu = nla_get_u32(tb[TCA_CAKE_MPU]);

		WRITE_ONCE(q->rate_mpu,

			   nla_get_u32(tb[TCA_CAKE_MPU]));



	if (tb[TCA_CAKE_RTT]) {

		q->interval = nla_get_u32(tb[TCA_CAKE_RTT]);

		u32 interval = nla_get_u32(tb[TCA_CAKE_RTT]);



		if (!q->interval)

			q->interval = 1;

		WRITE_ONCE(q->interval, max(interval, 1U));

	}



	if (tb[TCA_CAKE_TARGET]) {

		q->target = nla_get_u32(tb[TCA_CAKE_TARGET]);

		u32 target = nla_get_u32(tb[TCA_CAKE_TARGET]);



		if (!q->target)

			q->target = 1;

		WRITE_ONCE(q->target, max(target, 1U));

	}



	if (tb[TCA_CAKE_AUTORATE]) {

		if (!!nla_get_u32(tb[TCA_CAKE_AUTORATE]))

			q->rate_flags |= CAKE_FLAG_AUTORATE_INGRESS;

			rate_flags |= CAKE_FLAG_AUTORATE_INGRESS;

		else

			q->rate_flags &= ~CAKE_FLAG_AUTORATE_INGRESS;

			rate_flags &= ~CAKE_FLAG_AUTORATE_INGRESS;

	}



	if (tb[TCA_CAKE_INGRESS]) {

		if (!!nla_get_u32(tb[TCA_CAKE_INGRESS]))

			q->rate_flags |= CAKE_FLAG_INGRESS;

			rate_flags |= CAKE_FLAG_INGRESS;

		else

			q->rate_flags &= ~CAKE_FLAG_INGRESS;

			rate_flags &= ~CAKE_FLAG_INGRESS;

	}



	if (tb[TCA_CAKE_ACK_FILTER])

		q->ack_filter = nla_get_u32(tb[TCA_CAKE_ACK_FILTER]);

		WRITE_ONCE(q->ack_filter,

			   nla_get_u32(tb[TCA_CAKE_ACK_FILTER]));



	if (tb[TCA_CAKE_MEMORY])

		q->buffer_config_limit = nla_get_u32(tb[TCA_CAKE_MEMORY]);

		WRITE_ONCE(q->buffer_config_limit,

			   nla_get_u32(tb[TCA_CAKE_MEMORY]));



	if (tb[TCA_CAKE_SPLIT_GSO]) {

		if (!!nla_get_u32(tb[TCA_CAKE_SPLIT_GSO]))

			q->rate_flags |= CAKE_FLAG_SPLIT_GSO;

			rate_flags |= CAKE_FLAG_SPLIT_GSO;

		else

			q->rate_flags &= ~CAKE_FLAG_SPLIT_GSO;

			rate_flags &= ~CAKE_FLAG_SPLIT_GSO;

	}



	if (tb[TCA_CAKE_FWMARK]) {

		q->fwmark_mask = nla_get_u32(tb[TCA_CAKE_FWMARK]);

		q->fwmark_shft = q->fwmark_mask ? __ffs(q->fwmark_mask) : 0;

		WRITE_ONCE(q->fwmark_mask, nla_get_u32(tb[TCA_CAKE_FWMARK]));

		WRITE_ONCE(q->fwmark_shft,

			   q->fwmark_mask ? __ffs(q->fwmark_mask) : 0);

	}



	WRITE_ONCE(q->rate_flags, rate_flags);

	WRITE_ONCE(q->flow_mode, flow_mode);

	if (q->tins) {

		sch_tree_lock(sch);

		cake_reconfigure(sch);
@@ -2774,68 +2786,72 @@ static int cake_dump(struct Qdisc *sch, struct sk_buff *skb) 
{

	struct cake_sched_data *q = qdisc_priv(sch);

	struct nlattr *opts;

	u16 rate_flags;

	u8 flow_mode;



	opts = nla_nest_start_noflag(skb, TCA_OPTIONS);

	if (!opts)

		goto nla_put_failure;



	if (nla_put_u64_64bit(skb, TCA_CAKE_BASE_RATE64, q->rate_bps,

			      TCA_CAKE_PAD))

	if (nla_put_u64_64bit(skb, TCA_CAKE_BASE_RATE64,

			      READ_ONCE(q->rate_bps), TCA_CAKE_PAD))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_FLOW_MODE,

			q->flow_mode & CAKE_FLOW_MASK))

	flow_mode = READ_ONCE(q->flow_mode);

	if (nla_put_u32(skb, TCA_CAKE_FLOW_MODE, flow_mode & CAKE_FLOW_MASK))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_RTT, q->interval))

	if (nla_put_u32(skb, TCA_CAKE_RTT, READ_ONCE(q->interval)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_TARGET, q->target))

	if (nla_put_u32(skb, TCA_CAKE_TARGET, READ_ONCE(q->target)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_MEMORY, q->buffer_config_limit))

	if (nla_put_u32(skb, TCA_CAKE_MEMORY,

			READ_ONCE(q->buffer_config_limit)))

		goto nla_put_failure;



	rate_flags = READ_ONCE(q->rate_flags);

	if (nla_put_u32(skb, TCA_CAKE_AUTORATE,

			!!(q->rate_flags & CAKE_FLAG_AUTORATE_INGRESS)))

			!!(rate_flags & CAKE_FLAG_AUTORATE_INGRESS)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_INGRESS,

			!!(q->rate_flags & CAKE_FLAG_INGRESS)))

			!!(rate_flags & CAKE_FLAG_INGRESS)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_ACK_FILTER, q->ack_filter))

	if (nla_put_u32(skb, TCA_CAKE_ACK_FILTER, READ_ONCE(q->ack_filter)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_NAT,

			!!(q->flow_mode & CAKE_FLOW_NAT_FLAG)))

			!!(flow_mode & CAKE_FLOW_NAT_FLAG)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_DIFFSERV_MODE, q->tin_mode))

	if (nla_put_u32(skb, TCA_CAKE_DIFFSERV_MODE, READ_ONCE(q->tin_mode)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_WASH,

			!!(q->rate_flags & CAKE_FLAG_WASH)))

			!!(rate_flags & CAKE_FLAG_WASH)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_OVERHEAD, q->rate_overhead))

	if (nla_put_u32(skb, TCA_CAKE_OVERHEAD, READ_ONCE(q->rate_overhead)))

		goto nla_put_failure;



	if (!(q->rate_flags & CAKE_FLAG_OVERHEAD))

	if (!(rate_flags & CAKE_FLAG_OVERHEAD))

		if (nla_put_u32(skb, TCA_CAKE_RAW, 0))

			goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_ATM, q->atm_mode))

	if (nla_put_u32(skb, TCA_CAKE_ATM, READ_ONCE(q->atm_mode)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_MPU, q->rate_mpu))

	if (nla_put_u32(skb, TCA_CAKE_MPU, READ_ONCE(q->rate_mpu)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_SPLIT_GSO,

			!!(q->rate_flags & CAKE_FLAG_SPLIT_GSO)))

			!!(rate_flags & CAKE_FLAG_SPLIT_GSO)))

		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CAKE_FWMARK, q->fwmark_mask))

	if (nla_put_u32(skb, TCA_CAKE_FWMARK, READ_ONCE(q->fwmark_mask)))

		goto nla_put_failure;



	return nla_nest_end(skb, opts);

net/sched/sch_cbs.c

+10 −10
Original line number Diff line number Diff line
@@ -389,11 +389,11 @@ static int cbs_change(struct Qdisc *sch, struct nlattr *opt, 
	}



	/* Everything went OK, save the parameters used. */

	q->hicredit = qopt->hicredit;

	q->locredit = qopt->locredit;

	q->idleslope = qopt->idleslope * BYTES_PER_KBIT;

	q->sendslope = qopt->sendslope * BYTES_PER_KBIT;

	q->offload = qopt->offload;

	WRITE_ONCE(q->hicredit, qopt->hicredit);

	WRITE_ONCE(q->locredit, qopt->locredit);

	WRITE_ONCE(q->idleslope, qopt->idleslope * BYTES_PER_KBIT);

	WRITE_ONCE(q->sendslope, qopt->sendslope * BYTES_PER_KBIT);

	WRITE_ONCE(q->offload, qopt->offload);



	return 0;

}
@@ -459,11 +459,11 @@ static int cbs_dump(struct Qdisc *sch, struct sk_buff *skb) 
	if (!nest)

		goto nla_put_failure;



	opt.hicredit = q->hicredit;

	opt.locredit = q->locredit;

	opt.sendslope = div64_s64(q->sendslope, BYTES_PER_KBIT);

	opt.idleslope = div64_s64(q->idleslope, BYTES_PER_KBIT);

	opt.offload = q->offload;

	opt.hicredit = READ_ONCE(q->hicredit);

	opt.locredit = READ_ONCE(q->locredit);

	opt.sendslope = div64_s64(READ_ONCE(q->sendslope), BYTES_PER_KBIT);

	opt.idleslope = div64_s64(READ_ONCE(q->idleslope), BYTES_PER_KBIT);

	opt.offload = READ_ONCE(q->offload);



	if (nla_put(skb, TCA_CBS_PARMS, sizeof(opt), &opt))

		goto nla_put_failure;

net/sched/sch_choke.c

+11 −10
Original line number Diff line number Diff line
@@ -405,8 +405,8 @@ static int choke_change(struct Qdisc *sch, struct nlattr *opt, 
	} else

		sch_tree_lock(sch);



	q->flags = ctl->flags;

	q->limit = ctl->limit;

	WRITE_ONCE(q->flags, ctl->flags);

	WRITE_ONCE(q->limit, ctl->limit);



	red_set_parms(&q->parms, ctl->qth_min, ctl->qth_max, ctl->Wlog,

		      ctl->Plog, ctl->Scell_log,
@@ -431,15 +431,16 @@ static int choke_init(struct Qdisc *sch, struct nlattr *opt, 
static int choke_dump(struct Qdisc *sch, struct sk_buff *skb)

{

	struct choke_sched_data *q = qdisc_priv(sch);

	u8 Wlog = READ_ONCE(q->parms.Wlog);

	struct nlattr *opts = NULL;

	struct tc_red_qopt opt = {

		.limit		= q->limit,

		.flags		= q->flags,

		.qth_min	= q->parms.qth_min >> q->parms.Wlog,

		.qth_max	= q->parms.qth_max >> q->parms.Wlog,

		.Wlog		= q->parms.Wlog,

		.Plog		= q->parms.Plog,

		.Scell_log	= q->parms.Scell_log,

		.limit		= READ_ONCE(q->limit),

		.flags		= READ_ONCE(q->flags),

		.qth_min	= READ_ONCE(q->parms.qth_min) >> Wlog,

		.qth_max	= READ_ONCE(q->parms.qth_max) >> Wlog,

		.Wlog		= Wlog,

		.Plog		= READ_ONCE(q->parms.Plog),

		.Scell_log	= READ_ONCE(q->parms.Scell_log),

	};



	opts = nla_nest_start_noflag(skb, TCA_OPTIONS);
@@ -447,7 +448,7 @@ static int choke_dump(struct Qdisc *sch, struct sk_buff *skb) 
		goto nla_put_failure;



	if (nla_put(skb, TCA_CHOKE_PARMS, sizeof(opt), &opt) ||

	    nla_put_u32(skb, TCA_CHOKE_MAX_P, q->parms.max_P))

	    nla_put_u32(skb, TCA_CHOKE_MAX_P, READ_ONCE(q->parms.max_P)))

		goto nla_put_failure;

	return nla_nest_end(skb, opts);

net/sched/sch_codel.c

+18 −11
Original line number Diff line number Diff line
@@ -118,26 +118,31 @@ static int codel_change(struct Qdisc *sch, struct nlattr *opt, 
	if (tb[TCA_CODEL_TARGET]) {

		u32 target = nla_get_u32(tb[TCA_CODEL_TARGET]);



		q->params.target = ((u64)target * NSEC_PER_USEC) >> CODEL_SHIFT;

		WRITE_ONCE(q->params.target,

			   ((u64)target * NSEC_PER_USEC) >> CODEL_SHIFT);

	}



	if (tb[TCA_CODEL_CE_THRESHOLD]) {

		u64 val = nla_get_u32(tb[TCA_CODEL_CE_THRESHOLD]);



		q->params.ce_threshold = (val * NSEC_PER_USEC) >> CODEL_SHIFT;

		WRITE_ONCE(q->params.ce_threshold,

			   (val * NSEC_PER_USEC) >> CODEL_SHIFT);

	}



	if (tb[TCA_CODEL_INTERVAL]) {

		u32 interval = nla_get_u32(tb[TCA_CODEL_INTERVAL]);



		q->params.interval = ((u64)interval * NSEC_PER_USEC) >> CODEL_SHIFT;

		WRITE_ONCE(q->params.interval,

			   ((u64)interval * NSEC_PER_USEC) >> CODEL_SHIFT);

	}



	if (tb[TCA_CODEL_LIMIT])

		sch->limit = nla_get_u32(tb[TCA_CODEL_LIMIT]);

		WRITE_ONCE(sch->limit,

			   nla_get_u32(tb[TCA_CODEL_LIMIT]));



	if (tb[TCA_CODEL_ECN])

		q->params.ecn = !!nla_get_u32(tb[TCA_CODEL_ECN]);

		WRITE_ONCE(q->params.ecn,

			   !!nla_get_u32(tb[TCA_CODEL_ECN]));



	qlen = sch->q.qlen;

	while (sch->q.qlen > sch->limit) {
@@ -183,6 +188,7 @@ static int codel_init(struct Qdisc *sch, struct nlattr *opt, 
static int codel_dump(struct Qdisc *sch, struct sk_buff *skb)

{

	struct codel_sched_data *q = qdisc_priv(sch);

	codel_time_t ce_threshold;

	struct nlattr *opts;



	opts = nla_nest_start_noflag(skb, TCA_OPTIONS);
@@ -190,17 +196,18 @@ static int codel_dump(struct Qdisc *sch, struct sk_buff *skb) 
		goto nla_put_failure;



	if (nla_put_u32(skb, TCA_CODEL_TARGET,

			codel_time_to_us(q->params.target)) ||

			codel_time_to_us(READ_ONCE(q->params.target))) ||

	    nla_put_u32(skb, TCA_CODEL_LIMIT,

			sch->limit) ||

			READ_ONCE(sch->limit)) ||

	    nla_put_u32(skb, TCA_CODEL_INTERVAL,

			codel_time_to_us(q->params.interval)) ||

			codel_time_to_us(READ_ONCE(q->params.interval))) ||

	    nla_put_u32(skb, TCA_CODEL_ECN,

			q->params.ecn))

			READ_ONCE(q->params.ecn)))

		goto nla_put_failure;

	if (q->params.ce_threshold != CODEL_DISABLED_THRESHOLD &&

	ce_threshold = READ_ONCE(q->params.ce_threshold);

	if (ce_threshold != CODEL_DISABLED_THRESHOLD &&

	    nla_put_u32(skb, TCA_CODEL_CE_THRESHOLD,

			codel_time_to_us(q->params.ce_threshold)))

			codel_time_to_us(ce_threshold)))

		goto nla_put_failure;

	return nla_nest_end(skb, opts);