Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

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

Merge branch 'cbq-kill-drop' 



Florian Westphal says:

====================
sched, cbq: remove OVL_STRATEGY/POLICE support

iproute2 does not implement any options that result in the
TCA_CBQ_OVL_STRATEGY/TCA_CBQ_POLICE attributes being set/used.

This series removes these two attributes from cbq and makes kernel reject
 them via EOPNOTSUPP in case they are present.

The two followup changes then remove several features from qdisc
infrastructure that are then no longer used/needed.  These are:
 - The 'drop' method provided by most qdiscs
 - the 'reshape_fail' function used by some qdiscs
 - the __parent member in struct Qdisc

I tested this with allmod and allyesconfig builds and also with
a brief cbq script:

  tc qdisc add dev eth0 root handle 1:0 cbq bandwidth 10Mbit avpkt 1000 cell 8
  tc class add dev eth0 parent 1:0 classid 1:1 est 1sec 8sec cbq bandwidth 10Mbit rate 5Mbit prio 1 allot 1514 maxburst 20 cell 8 avpkt 1000 bounded split 1:0 defmap 3f
  tc class add dev eth0 parent 1:0 classid 1:2 est 1sec 8sec cbq bandwidth 10Mbit rate 5Mbit prio 1 allot 1514 maxburst 20 cell 8 avpkt 1000 bounded split 1:0 defmap 3f
  tc filter add dev eth0 parent 1:0 protocol ip prio 1 u32 match ip tos 0x10 0xff classid 1:1 police rate 2Mbit burst 10K reclassify
  tc filter add dev eth0 parent 1:0 protocol ip prio 1 u32 match ip tos 0x0c 0xff classid 1:2
  tc filter add dev eth0 parent 1:0 protocol ip prio 2 u32 match ip tos 0x10 0xff classid 1:2
  tc filter add dev eth0 parent 1:0 protocol ip prio 3 u32 match ip tos 0x0 0x0 classid 1:2

No changes since v1 except patch #5 to fix up struct Qdisc layout.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 76e48f9f c8945043

include/net/sch_generic.h

+2 −61
Original line number Diff line number Diff line
@@ -63,26 +63,19 @@ struct Qdisc { 
	struct list_head	list;

	u32			handle;

	u32			parent;

	int			(*reshape_fail)(struct sk_buff *skb,

					struct Qdisc *q);



	void			*u32_node;



	/* This field is deprecated, but it is still used by CBQ

	 * and it will live until better solution will be invented.

	 */

	struct Qdisc		*__parent;

	struct netdev_queue	*dev_queue;



	struct gnet_stats_rate_est64	rate_est;

	struct gnet_stats_basic_cpu __percpu *cpu_bstats;

	struct gnet_stats_queue	__percpu *cpu_qstats;



	struct Qdisc		*next_sched;

	struct sk_buff		*gso_skb;

	/*

	 * For performance sake on SMP, we put highly modified fields at the end

	 */

	struct Qdisc		*next_sched ____cacheline_aligned_in_smp;

	struct sk_buff		*gso_skb;

	unsigned long		state;

	struct sk_buff_head	q;

	struct gnet_stats_basic_packed bstats;
@@ -181,7 +174,6 @@ struct Qdisc_ops { 
	int 			(*enqueue)(struct sk_buff *, struct Qdisc *);

	struct sk_buff *	(*dequeue)(struct Qdisc *);

	struct sk_buff *	(*peek)(struct Qdisc *);

	unsigned int		(*drop)(struct Qdisc *);



	int			(*init)(struct Qdisc *, struct nlattr *arg);

	void			(*reset)(struct Qdisc *);
@@ -665,22 +657,6 @@ static inline unsigned int qdisc_queue_drop_head(struct Qdisc *sch) 
	return __qdisc_queue_drop_head(sch, &sch->q);

}



static inline struct sk_buff *__qdisc_dequeue_tail(struct Qdisc *sch,

						   struct sk_buff_head *list)

{

	struct sk_buff *skb = __skb_dequeue_tail(list);



	if (likely(skb != NULL))

		qdisc_qstats_backlog_dec(sch, skb);



	return skb;

}



static inline struct sk_buff *qdisc_dequeue_tail(struct Qdisc *sch)

{

	return __qdisc_dequeue_tail(sch, &sch->q);

}



static inline struct sk_buff *qdisc_peek_head(struct Qdisc *sch)

{

	return skb_peek(&sch->q);
@@ -748,25 +724,6 @@ static inline struct Qdisc *qdisc_replace(struct Qdisc *sch, struct Qdisc *new, 
	return old;

}



static inline unsigned int __qdisc_queue_drop(struct Qdisc *sch,

					      struct sk_buff_head *list)

{

	struct sk_buff *skb = __qdisc_dequeue_tail(sch, list);



	if (likely(skb != NULL)) {

		unsigned int len = qdisc_pkt_len(skb);

		kfree_skb(skb);

		return len;

	}



	return 0;

}



static inline unsigned int qdisc_queue_drop(struct Qdisc *sch)

{

	return __qdisc_queue_drop(sch, &sch->q);

}



static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)

{

	kfree_skb(skb);
@@ -775,22 +732,6 @@ static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch) 
	return NET_XMIT_DROP;

}



static inline int qdisc_reshape_fail(struct sk_buff *skb, struct Qdisc *sch)

{

	qdisc_qstats_drop(sch);



#ifdef CONFIG_NET_CLS_ACT

	if (sch->reshape_fail == NULL || sch->reshape_fail(skb, sch))

		goto drop;



	return NET_XMIT_SUCCESS;



drop:

#endif

	kfree_skb(skb);

	return NET_XMIT_DROP;

}



/* Length to Time (L2T) lookup in a qdisc_rate_table, to determine how

   long it will take to send a packet given its size.

 */

net/sched/sch_atm.c

+0 −15
Original line number Diff line number Diff line
@@ -519,20 +519,6 @@ static struct sk_buff *atm_tc_peek(struct Qdisc *sch) 
	return p->link.q->ops->peek(p->link.q);

}



static unsigned int atm_tc_drop(struct Qdisc *sch)

{

	struct atm_qdisc_data *p = qdisc_priv(sch);

	struct atm_flow_data *flow;

	unsigned int len;



	pr_debug("atm_tc_drop(sch %p,[qdisc %p])\n", sch, p);

	list_for_each_entry(flow, &p->flows, list) {

		if (flow->q->ops->drop && (len = flow->q->ops->drop(flow->q)))

			return len;

	}

	return 0;

}



static int atm_tc_init(struct Qdisc *sch, struct nlattr *opt)

{

	struct atm_qdisc_data *p = qdisc_priv(sch);
@@ -672,7 +658,6 @@ static struct Qdisc_ops atm_qdisc_ops __read_mostly = { 
	.enqueue	= atm_tc_enqueue,

	.dequeue	= atm_tc_dequeue,

	.peek		= atm_tc_peek,

	.drop		= atm_tc_drop,

	.init		= atm_tc_init,

	.reset		= atm_tc_reset,

	.destroy	= atm_tc_destroy,

net/sched/sch_cbq.c

+6 −279
Original line number Diff line number Diff line
@@ -80,10 +80,6 @@ struct cbq_class { 
	unsigned char		priority;	/* class priority */

	unsigned char		priority2;	/* priority to be used after overlimit */

	unsigned char		ewma_log;	/* time constant for idle time calculation */

	unsigned char		ovl_strategy;

#ifdef CONFIG_NET_CLS_ACT

	unsigned char		police;

#endif



	u32			defmap;
@@ -94,10 +90,6 @@ struct cbq_class { 
	u32			avpkt;

	struct qdisc_rate_table	*R_tab;



	/* Overlimit strategy parameters */

	void			(*overlimit)(struct cbq_class *cl);

	psched_tdiff_t		penalty;



	/* General scheduler (WRR) parameters */

	long			allot;

	long			quantum;	/* Allotment per WRR round */
@@ -382,9 +374,6 @@ cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch) 
		return ret;

	}



#ifdef CONFIG_NET_CLS_ACT

	cl->q->__parent = sch;

#endif

	ret = qdisc_enqueue(skb, cl->q);

	if (ret == NET_XMIT_SUCCESS) {

		sch->q.qlen++;
@@ -402,11 +391,8 @@ cbq_enqueue(struct sk_buff *skb, struct Qdisc *sch) 
	return ret;

}



/* Overlimit actions */



/* TC_CBQ_OVL_CLASSIC: (default) penalize leaf class by adding offtime */



static void cbq_ovl_classic(struct cbq_class *cl)

/* Overlimit action: penalize leaf class by adding offtime */

static void cbq_overlimit(struct cbq_class *cl)

{

	struct cbq_sched_data *q = qdisc_priv(cl->qdisc);

	psched_tdiff_t delay = cl->undertime - q->now;
@@ -456,99 +442,6 @@ static void cbq_ovl_classic(struct cbq_class *cl) 
	}

}



/* TC_CBQ_OVL_RCLASSIC: penalize by offtime classes in hierarchy, when

 * they go overlimit

 */



static void cbq_ovl_rclassic(struct cbq_class *cl)

{

	struct cbq_sched_data *q = qdisc_priv(cl->qdisc);

	struct cbq_class *this = cl;



	do {

		if (cl->level > q->toplevel) {

			cl = NULL;

			break;

		}

	} while ((cl = cl->borrow) != NULL);



	if (cl == NULL)

		cl = this;

	cbq_ovl_classic(cl);

}



/* TC_CBQ_OVL_DELAY: delay until it will go to underlimit */



static void cbq_ovl_delay(struct cbq_class *cl)

{

	struct cbq_sched_data *q = qdisc_priv(cl->qdisc);

	psched_tdiff_t delay = cl->undertime - q->now;



	if (test_bit(__QDISC_STATE_DEACTIVATED,

		     &qdisc_root_sleeping(cl->qdisc)->state))

		return;



	if (!cl->delayed) {

		psched_time_t sched = q->now;

		ktime_t expires;



		delay += cl->offtime;

		if (cl->avgidle < 0)

			delay -= (-cl->avgidle) - ((-cl->avgidle) >> cl->ewma_log);

		if (cl->avgidle < cl->minidle)

			cl->avgidle = cl->minidle;

		cl->undertime = q->now + delay;



		if (delay > 0) {

			sched += delay + cl->penalty;

			cl->penalized = sched;

			cl->cpriority = TC_CBQ_MAXPRIO;

			q->pmask |= (1<<TC_CBQ_MAXPRIO);



			expires = ns_to_ktime(PSCHED_TICKS2NS(sched));

			if (hrtimer_try_to_cancel(&q->delay_timer) &&

			    ktime_to_ns(ktime_sub(

					hrtimer_get_expires(&q->delay_timer),

					expires)) > 0)

				hrtimer_set_expires(&q->delay_timer, expires);

			hrtimer_restart(&q->delay_timer);

			cl->delayed = 1;

			cl->xstats.overactions++;

			return;

		}

		delay = 1;

	}

	if (q->wd_expires == 0 || q->wd_expires > delay)

		q->wd_expires = delay;

}



/* TC_CBQ_OVL_LOWPRIO: penalize class by lowering its priority band */



static void cbq_ovl_lowprio(struct cbq_class *cl)

{

	struct cbq_sched_data *q = qdisc_priv(cl->qdisc);



	cl->penalized = q->now + cl->penalty;



	if (cl->cpriority != cl->priority2) {

		cl->cpriority = cl->priority2;

		q->pmask |= (1<<cl->cpriority);

		cl->xstats.overactions++;

	}

	cbq_ovl_classic(cl);

}



/* TC_CBQ_OVL_DROP: penalize class by dropping */



static void cbq_ovl_drop(struct cbq_class *cl)

{

	if (cl->q->ops->drop)

		if (cl->q->ops->drop(cl->q))

			cl->qdisc->q.qlen--;

	cl->xstats.overactions++;

	cbq_ovl_classic(cl);

}



static psched_tdiff_t cbq_undelay_prio(struct cbq_sched_data *q, int prio,

				       psched_time_t now)

{
@@ -625,40 +518,6 @@ static enum hrtimer_restart cbq_undelay(struct hrtimer *timer) 
	return HRTIMER_NORESTART;

}



#ifdef CONFIG_NET_CLS_ACT

static int cbq_reshape_fail(struct sk_buff *skb, struct Qdisc *child)

{

	struct Qdisc *sch = child->__parent;

	struct cbq_sched_data *q = qdisc_priv(sch);

	struct cbq_class *cl = q->rx_class;



	q->rx_class = NULL;



	if (cl && (cl = cbq_reclassify(skb, cl)) != NULL) {

		int ret;



		cbq_mark_toplevel(q, cl);



		q->rx_class = cl;

		cl->q->__parent = sch;



		ret = qdisc_enqueue(skb, cl->q);

		if (ret == NET_XMIT_SUCCESS) {

			sch->q.qlen++;

			if (!cl->next_alive)

				cbq_activate_class(cl);

			return 0;

		}

		if (net_xmit_drop_count(ret))

			qdisc_qstats_drop(sch);

		return 0;

	}



	qdisc_qstats_drop(sch);

	return -1;

}

#endif



/*

 * It is mission critical procedure.

 *
@@ -807,7 +666,7 @@ cbq_under_limit(struct cbq_class *cl) 
		cl = cl->borrow;

		if (!cl) {

			this_cl->qstats.overlimits++;

			this_cl->overlimit(this_cl);

			cbq_overlimit(this_cl);

			return NULL;

		}

		if (cl->level > q->toplevel)
@@ -1166,31 +1025,6 @@ static void cbq_link_class(struct cbq_class *this) 
	}

}



static unsigned int cbq_drop(struct Qdisc *sch)

{

	struct cbq_sched_data *q = qdisc_priv(sch);

	struct cbq_class *cl, *cl_head;

	int prio;

	unsigned int len;



	for (prio = TC_CBQ_MAXPRIO; prio >= 0; prio--) {

		cl_head = q->active[prio];

		if (!cl_head)

			continue;



		cl = cl_head;

		do {

			if (cl->q->ops->drop && (len = cl->q->ops->drop(cl->q))) {

				sch->q.qlen--;

				if (!cl->q->q.qlen)

					cbq_deactivate_class(cl);

				return len;

			}

		} while ((cl = cl->next_alive) != cl_head);

	}

	return 0;

}



static void

cbq_reset(struct Qdisc *sch)

{
@@ -1280,50 +1114,6 @@ static int cbq_set_wrr(struct cbq_class *cl, struct tc_cbq_wrropt *wrr) 
	return 0;

}



static int cbq_set_overlimit(struct cbq_class *cl, struct tc_cbq_ovl *ovl)

{

	switch (ovl->strategy) {

	case TC_CBQ_OVL_CLASSIC:

		cl->overlimit = cbq_ovl_classic;

		break;

	case TC_CBQ_OVL_DELAY:

		cl->overlimit = cbq_ovl_delay;

		break;

	case TC_CBQ_OVL_LOWPRIO:

		if (ovl->priority2 - 1 >= TC_CBQ_MAXPRIO ||

		    ovl->priority2 - 1 <= cl->priority)

			return -EINVAL;

		cl->priority2 = ovl->priority2 - 1;

		cl->overlimit = cbq_ovl_lowprio;

		break;

	case TC_CBQ_OVL_DROP:

		cl->overlimit = cbq_ovl_drop;

		break;

	case TC_CBQ_OVL_RCLASSIC:

		cl->overlimit = cbq_ovl_rclassic;

		break;

	default:

		return -EINVAL;

	}

	cl->penalty = ovl->penalty;

	return 0;

}



#ifdef CONFIG_NET_CLS_ACT

static int cbq_set_police(struct cbq_class *cl, struct tc_cbq_police *p)

{

	cl->police = p->police;



	if (cl->q->handle) {

		if (p->police == TC_POLICE_RECLASSIFY)

			cl->q->reshape_fail = cbq_reshape_fail;

		else

			cl->q->reshape_fail = NULL;

	}

	return 0;

}

#endif



static int cbq_set_fopt(struct cbq_class *cl, struct tc_cbq_fopt *fopt)

{

	cbq_change_defmap(cl, fopt->split, fopt->defmap, fopt->defchange);
@@ -1375,8 +1165,6 @@ static int cbq_init(struct Qdisc *sch, struct nlattr *opt) 
	q->link.priority = TC_CBQ_MAXPRIO - 1;

	q->link.priority2 = TC_CBQ_MAXPRIO - 1;

	q->link.cpriority = TC_CBQ_MAXPRIO - 1;

	q->link.ovl_strategy = TC_CBQ_OVL_CLASSIC;

	q->link.overlimit = cbq_ovl_classic;

	q->link.allot = psched_mtu(qdisc_dev(sch));

	q->link.quantum = q->link.allot;

	q->link.weight = q->link.R_tab->rate.rate;
@@ -1463,24 +1251,6 @@ static int cbq_dump_wrr(struct sk_buff *skb, struct cbq_class *cl) 
	return -1;

}



static int cbq_dump_ovl(struct sk_buff *skb, struct cbq_class *cl)

{

	unsigned char *b = skb_tail_pointer(skb);

	struct tc_cbq_ovl opt;



	opt.strategy = cl->ovl_strategy;

	opt.priority2 = cl->priority2 + 1;

	opt.pad = 0;

	opt.penalty = cl->penalty;

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

		goto nla_put_failure;

	return skb->len;



nla_put_failure:

	nlmsg_trim(skb, b);

	return -1;

}



static int cbq_dump_fopt(struct sk_buff *skb, struct cbq_class *cl)

{

	unsigned char *b = skb_tail_pointer(skb);
@@ -1500,36 +1270,11 @@ static int cbq_dump_fopt(struct sk_buff *skb, struct cbq_class *cl) 
	return -1;

}



#ifdef CONFIG_NET_CLS_ACT

static int cbq_dump_police(struct sk_buff *skb, struct cbq_class *cl)

{

	unsigned char *b = skb_tail_pointer(skb);

	struct tc_cbq_police opt;



	if (cl->police) {

		opt.police = cl->police;

		opt.__res1 = 0;

		opt.__res2 = 0;

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

			goto nla_put_failure;

	}

	return skb->len;



nla_put_failure:

	nlmsg_trim(skb, b);

	return -1;

}

#endif



static int cbq_dump_attr(struct sk_buff *skb, struct cbq_class *cl)

{

	if (cbq_dump_lss(skb, cl) < 0 ||

	    cbq_dump_rate(skb, cl) < 0 ||

	    cbq_dump_wrr(skb, cl) < 0 ||

	    cbq_dump_ovl(skb, cl) < 0 ||

#ifdef CONFIG_NET_CLS_ACT

	    cbq_dump_police(skb, cl) < 0 ||

#endif

	    cbq_dump_fopt(skb, cl) < 0)

		return -1;

	return 0;
@@ -1619,11 +1364,6 @@ static int cbq_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new, 
					&pfifo_qdisc_ops, cl->common.classid);

		if (new == NULL)

			return -ENOBUFS;

	} else {

#ifdef CONFIG_NET_CLS_ACT

		if (cl->police == TC_POLICE_RECLASSIFY)

			new->reshape_fail = cbq_reshape_fail;

#endif

	}



	*old = qdisc_replace(sch, new, &cl->q);
@@ -1736,6 +1476,9 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct nlattr **t 
	if (err < 0)

		return err;



	if (tb[TCA_CBQ_OVL_STRATEGY] || tb[TCA_CBQ_POLICE])

		return -EOPNOTSUPP;



	if (cl) {

		/* Check parent */

		if (parentid) {
@@ -1784,14 +1527,6 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct nlattr **t 
			cbq_set_wrr(cl, nla_data(tb[TCA_CBQ_WRROPT]));

		}



		if (tb[TCA_CBQ_OVL_STRATEGY])

			cbq_set_overlimit(cl, nla_data(tb[TCA_CBQ_OVL_STRATEGY]));



#ifdef CONFIG_NET_CLS_ACT

		if (tb[TCA_CBQ_POLICE])

			cbq_set_police(cl, nla_data(tb[TCA_CBQ_POLICE]));

#endif



		if (tb[TCA_CBQ_FOPT])

			cbq_set_fopt(cl, nla_data(tb[TCA_CBQ_FOPT]));
@@ -1887,13 +1622,6 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct nlattr **t 
		cl->maxidle = q->link.maxidle;

	if (cl->avpkt == 0)

		cl->avpkt = q->link.avpkt;

	cl->overlimit = cbq_ovl_classic;

	if (tb[TCA_CBQ_OVL_STRATEGY])

		cbq_set_overlimit(cl, nla_data(tb[TCA_CBQ_OVL_STRATEGY]));

#ifdef CONFIG_NET_CLS_ACT

	if (tb[TCA_CBQ_POLICE])

		cbq_set_police(cl, nla_data(tb[TCA_CBQ_POLICE]));

#endif

	if (tb[TCA_CBQ_FOPT])

		cbq_set_fopt(cl, nla_data(tb[TCA_CBQ_FOPT]));

	sch_tree_unlock(sch);
@@ -2038,7 +1766,6 @@ static struct Qdisc_ops cbq_qdisc_ops __read_mostly = { 
	.enqueue	=	cbq_enqueue,

	.dequeue	=	cbq_dequeue,

	.peek		=	qdisc_peek_dequeued,

	.drop		=	cbq_drop,

	.init		=	cbq_init,

	.reset		=	cbq_reset,

	.destroy	=	cbq_destroy,

net/sched/sch_choke.c

+0 −17
Original line number Diff line number Diff line
@@ -365,22 +365,6 @@ static struct sk_buff *choke_dequeue(struct Qdisc *sch) 
	return skb;

}



static unsigned int choke_drop(struct Qdisc *sch)

{

	struct choke_sched_data *q = qdisc_priv(sch);

	unsigned int len;



	len = qdisc_queue_drop(sch);

	if (len > 0)

		q->stats.other++;

	else {

		if (!red_is_idling(&q->vars))

			red_start_of_idle_period(&q->vars);

	}



	return len;

}



static void choke_reset(struct Qdisc *sch)

{

	struct choke_sched_data *q = qdisc_priv(sch);
@@ -569,7 +553,6 @@ static struct Qdisc_ops choke_qdisc_ops __read_mostly = { 
	.enqueue	=	choke_enqueue,

	.dequeue	=	choke_dequeue,

	.peek		=	choke_peek_head,

	.drop		=	choke_drop,

	.init		=	choke_init,

	.destroy	=	choke_destroy,

	.reset		=	choke_reset,

net/sched/sch_drr.c

+0 −21
Original line number Diff line number Diff line
@@ -421,26 +421,6 @@ static struct sk_buff *drr_dequeue(struct Qdisc *sch) 
	return NULL;

}



static unsigned int drr_drop(struct Qdisc *sch)

{

	struct drr_sched *q = qdisc_priv(sch);

	struct drr_class *cl;

	unsigned int len;



	list_for_each_entry(cl, &q->active, alist) {

		if (cl->qdisc->ops->drop) {

			len = cl->qdisc->ops->drop(cl->qdisc);

			if (len > 0) {

				sch->q.qlen--;

				if (cl->qdisc->q.qlen == 0)

					list_del(&cl->alist);

				return len;

			}

		}

	}

	return 0;

}



static int drr_init_qdisc(struct Qdisc *sch, struct nlattr *opt)

{

	struct drr_sched *q = qdisc_priv(sch);
@@ -509,7 +489,6 @@ static struct Qdisc_ops drr_qdisc_ops __read_mostly = { 
	.enqueue	= drr_enqueue,

	.dequeue	= drr_dequeue,

	.peek		= qdisc_peek_dequeued,

	.drop		= drr_drop,

	.init		= drr_init_qdisc,

	.reset		= drr_reset_qdisc,

	.destroy	= drr_destroy_qdisc,