Linux Audio

Check our new training course

Loading...
v4.17
 
  1/*
  2 * net/sched/sch_prio.c	Simple 3-band priority "scheduler".
  3 *
  4 *		This program is free software; you can redistribute it and/or
  5 *		modify it under the terms of the GNU General Public License
  6 *		as published by the Free Software Foundation; either version
  7 *		2 of the License, or (at your option) any later version.
  8 *
  9 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 10 * Fixes:       19990609: J Hadi Salim <hadi@nortelnetworks.com>:
 11 *              Init --  EINVAL when opt undefined
 12 */
 13
 14#include <linux/module.h>
 15#include <linux/slab.h>
 16#include <linux/types.h>
 17#include <linux/kernel.h>
 18#include <linux/string.h>
 19#include <linux/errno.h>
 20#include <linux/skbuff.h>
 21#include <net/netlink.h>
 22#include <net/pkt_sched.h>
 23#include <net/pkt_cls.h>
 24
 25struct prio_sched_data {
 26	int bands;
 27	struct tcf_proto __rcu *filter_list;
 28	struct tcf_block *block;
 29	u8  prio2band[TC_PRIO_MAX+1];
 30	struct Qdisc *queues[TCQ_PRIO_BANDS];
 31};
 32
 33
 34static struct Qdisc *
 35prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
 36{
 37	struct prio_sched_data *q = qdisc_priv(sch);
 38	u32 band = skb->priority;
 39	struct tcf_result res;
 40	struct tcf_proto *fl;
 41	int err;
 42
 43	*qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 44	if (TC_H_MAJ(skb->priority) != sch->handle) {
 45		fl = rcu_dereference_bh(q->filter_list);
 46		err = tcf_classify(skb, fl, &res, false);
 47#ifdef CONFIG_NET_CLS_ACT
 48		switch (err) {
 49		case TC_ACT_STOLEN:
 50		case TC_ACT_QUEUED:
 51		case TC_ACT_TRAP:
 52			*qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
 53			/* fall through */
 54		case TC_ACT_SHOT:
 55			return NULL;
 56		}
 57#endif
 58		if (!fl || err < 0) {
 59			if (TC_H_MAJ(band))
 60				band = 0;
 61			return q->queues[q->prio2band[band & TC_PRIO_MAX]];
 62		}
 63		band = res.classid;
 64	}
 65	band = TC_H_MIN(band) - 1;
 66	if (band >= q->bands)
 67		return q->queues[q->prio2band[0]];
 68
 69	return q->queues[band];
 70}
 71
 72static int
 73prio_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free)
 74{
 
 75	struct Qdisc *qdisc;
 76	int ret;
 77
 78	qdisc = prio_classify(skb, sch, &ret);
 79#ifdef CONFIG_NET_CLS_ACT
 80	if (qdisc == NULL) {
 81
 82		if (ret & __NET_XMIT_BYPASS)
 83			qdisc_qstats_drop(sch);
 84		__qdisc_drop(skb, to_free);
 85		return ret;
 86	}
 87#endif
 88
 89	ret = qdisc_enqueue(skb, qdisc, to_free);
 90	if (ret == NET_XMIT_SUCCESS) {
 91		qdisc_qstats_backlog_inc(sch, skb);
 92		sch->q.qlen++;
 93		return NET_XMIT_SUCCESS;
 94	}
 95	if (net_xmit_drop_count(ret))
 96		qdisc_qstats_drop(sch);
 97	return ret;
 98}
 99
100static struct sk_buff *prio_peek(struct Qdisc *sch)
101{
102	struct prio_sched_data *q = qdisc_priv(sch);
103	int prio;
104
105	for (prio = 0; prio < q->bands; prio++) {
106		struct Qdisc *qdisc = q->queues[prio];
107		struct sk_buff *skb = qdisc->ops->peek(qdisc);
108		if (skb)
109			return skb;
110	}
111	return NULL;
112}
113
114static struct sk_buff *prio_dequeue(struct Qdisc *sch)
115{
116	struct prio_sched_data *q = qdisc_priv(sch);
117	int prio;
118
119	for (prio = 0; prio < q->bands; prio++) {
120		struct Qdisc *qdisc = q->queues[prio];
121		struct sk_buff *skb = qdisc_dequeue_peeked(qdisc);
122		if (skb) {
123			qdisc_bstats_update(sch, skb);
124			qdisc_qstats_backlog_dec(sch, skb);
125			sch->q.qlen--;
126			return skb;
127		}
128	}
129	return NULL;
130
131}
132
133static void
134prio_reset(struct Qdisc *sch)
135{
136	int prio;
137	struct prio_sched_data *q = qdisc_priv(sch);
138
139	for (prio = 0; prio < q->bands; prio++)
140		qdisc_reset(q->queues[prio]);
141	sch->qstats.backlog = 0;
142	sch->q.qlen = 0;
143}
144
145static int prio_offload(struct Qdisc *sch, struct tc_prio_qopt *qopt)
146{
147	struct net_device *dev = qdisc_dev(sch);
148	struct tc_prio_qopt_offload opt = {
149		.handle = sch->handle,
150		.parent = sch->parent,
151	};
152
153	if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc)
154		return -EOPNOTSUPP;
155
156	if (qopt) {
157		opt.command = TC_PRIO_REPLACE;
158		opt.replace_params.bands = qopt->bands;
159		memcpy(&opt.replace_params.priomap, qopt->priomap,
160		       TC_PRIO_MAX + 1);
161		opt.replace_params.qstats = &sch->qstats;
162	} else {
163		opt.command = TC_PRIO_DESTROY;
164	}
165
166	return dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_PRIO, &opt);
167}
168
169static void
170prio_destroy(struct Qdisc *sch)
171{
172	int prio;
173	struct prio_sched_data *q = qdisc_priv(sch);
174
175	tcf_block_put(q->block);
176	prio_offload(sch, NULL);
177	for (prio = 0; prio < q->bands; prio++)
178		qdisc_destroy(q->queues[prio]);
179}
180
181static int prio_tune(struct Qdisc *sch, struct nlattr *opt,
182		     struct netlink_ext_ack *extack)
183{
184	struct prio_sched_data *q = qdisc_priv(sch);
185	struct Qdisc *queues[TCQ_PRIO_BANDS];
186	int oldbands = q->bands, i;
187	struct tc_prio_qopt *qopt;
188
189	if (nla_len(opt) < sizeof(*qopt))
190		return -EINVAL;
191	qopt = nla_data(opt);
192
193	if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2)
194		return -EINVAL;
195
196	for (i = 0; i <= TC_PRIO_MAX; i++) {
197		if (qopt->priomap[i] >= qopt->bands)
198			return -EINVAL;
199	}
200
201	/* Before commit, make sure we can allocate all new qdiscs */
202	for (i = oldbands; i < qopt->bands; i++) {
203		queues[i] = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,
204					      TC_H_MAKE(sch->handle, i + 1),
205					      extack);
206		if (!queues[i]) {
207			while (i > oldbands)
208				qdisc_destroy(queues[--i]);
209			return -ENOMEM;
210		}
211	}
212
213	prio_offload(sch, qopt);
214	sch_tree_lock(sch);
215	q->bands = qopt->bands;
216	memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
217
218	for (i = q->bands; i < oldbands; i++) {
219		struct Qdisc *child = q->queues[i];
220
221		qdisc_tree_reduce_backlog(child, child->q.qlen,
222					  child->qstats.backlog);
223		qdisc_destroy(child);
224	}
225
226	for (i = oldbands; i < q->bands; i++) {
227		q->queues[i] = queues[i];
228		if (q->queues[i] != &noop_qdisc)
229			qdisc_hash_add(q->queues[i], true);
230	}
231
232	sch_tree_unlock(sch);
 
 
 
233	return 0;
234}
235
236static int prio_init(struct Qdisc *sch, struct nlattr *opt,
237		     struct netlink_ext_ack *extack)
238{
239	struct prio_sched_data *q = qdisc_priv(sch);
240	int err;
241
242	if (!opt)
243		return -EINVAL;
244
245	err = tcf_block_get(&q->block, &q->filter_list, sch, extack);
246	if (err)
247		return err;
248
249	return prio_tune(sch, opt, extack);
250}
251
252static int prio_dump_offload(struct Qdisc *sch)
253{
254	struct net_device *dev = qdisc_dev(sch);
255	struct tc_prio_qopt_offload hw_stats = {
256		.command = TC_PRIO_STATS,
257		.handle = sch->handle,
258		.parent = sch->parent,
259		{
260			.stats = {
261				.bstats = &sch->bstats,
262				.qstats = &sch->qstats,
263			},
264		},
265	};
266	int err;
267
268	sch->flags &= ~TCQ_F_OFFLOADED;
269	if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc)
270		return 0;
271
272	err = dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_PRIO,
273					    &hw_stats);
274	if (err == -EOPNOTSUPP)
275		return 0;
276
277	if (!err)
278		sch->flags |= TCQ_F_OFFLOADED;
279
280	return err;
281}
282
283static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
284{
285	struct prio_sched_data *q = qdisc_priv(sch);
286	unsigned char *b = skb_tail_pointer(skb);
287	struct tc_prio_qopt opt;
288	int err;
289
290	opt.bands = q->bands;
291	memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX + 1);
292
293	err = prio_dump_offload(sch);
294	if (err)
295		goto nla_put_failure;
296
297	if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
298		goto nla_put_failure;
299
300	return skb->len;
301
302nla_put_failure:
303	nlmsg_trim(skb, b);
304	return -1;
305}
306
307static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
308		      struct Qdisc **old, struct netlink_ext_ack *extack)
309{
310	struct prio_sched_data *q = qdisc_priv(sch);
311	struct tc_prio_qopt_offload graft_offload;
312	struct net_device *dev = qdisc_dev(sch);
313	unsigned long band = arg - 1;
314	bool any_qdisc_is_offloaded;
315	int err;
316
317	if (new == NULL)
318		new = &noop_qdisc;
319
320	*old = qdisc_replace(sch, new, &q->queues[band]);
321
322	if (!tc_can_offload(dev))
323		return 0;
324
325	graft_offload.handle = sch->handle;
326	graft_offload.parent = sch->parent;
327	graft_offload.graft_params.band = band;
328	graft_offload.graft_params.child_handle = new->handle;
329	graft_offload.command = TC_PRIO_GRAFT;
330
331	err = dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_PRIO,
332					    &graft_offload);
333
334	/* Don't report error if the graft is part of destroy operation. */
335	if (err && new != &noop_qdisc) {
336		/* Don't report error if the parent, the old child and the new
337		 * one are not offloaded.
338		 */
339		any_qdisc_is_offloaded = sch->flags & TCQ_F_OFFLOADED;
340		any_qdisc_is_offloaded |= new->flags & TCQ_F_OFFLOADED;
341		if (*old)
342			any_qdisc_is_offloaded |= (*old)->flags &
343						   TCQ_F_OFFLOADED;
344
345		if (any_qdisc_is_offloaded)
346			NL_SET_ERR_MSG(extack, "Offloading graft operation failed.");
347	}
348
349	return 0;
350}
351
352static struct Qdisc *
353prio_leaf(struct Qdisc *sch, unsigned long arg)
354{
355	struct prio_sched_data *q = qdisc_priv(sch);
356	unsigned long band = arg - 1;
357
358	return q->queues[band];
359}
360
361static unsigned long prio_find(struct Qdisc *sch, u32 classid)
362{
363	struct prio_sched_data *q = qdisc_priv(sch);
364	unsigned long band = TC_H_MIN(classid);
365
366	if (band - 1 >= q->bands)
367		return 0;
368	return band;
369}
370
371static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
372{
373	return prio_find(sch, classid);
374}
375
376
377static void prio_unbind(struct Qdisc *q, unsigned long cl)
378{
379}
380
381static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,
382			   struct tcmsg *tcm)
383{
384	struct prio_sched_data *q = qdisc_priv(sch);
385
386	tcm->tcm_handle |= TC_H_MIN(cl);
387	tcm->tcm_info = q->queues[cl-1]->handle;
388	return 0;
389}
390
391static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
392				 struct gnet_dump *d)
393{
394	struct prio_sched_data *q = qdisc_priv(sch);
395	struct Qdisc *cl_q;
396
397	cl_q = q->queues[cl - 1];
398	if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch),
399				  d, NULL, &cl_q->bstats) < 0 ||
400	    gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0)
401		return -1;
402
403	return 0;
404}
405
406static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
407{
408	struct prio_sched_data *q = qdisc_priv(sch);
409	int prio;
410
411	if (arg->stop)
412		return;
413
414	for (prio = 0; prio < q->bands; prio++) {
415		if (arg->count < arg->skip) {
416			arg->count++;
417			continue;
418		}
419		if (arg->fn(sch, prio + 1, arg) < 0) {
420			arg->stop = 1;
421			break;
422		}
423		arg->count++;
424	}
425}
426
427static struct tcf_block *prio_tcf_block(struct Qdisc *sch, unsigned long cl,
428					struct netlink_ext_ack *extack)
429{
430	struct prio_sched_data *q = qdisc_priv(sch);
431
432	if (cl)
433		return NULL;
434	return q->block;
435}
436
437static const struct Qdisc_class_ops prio_class_ops = {
438	.graft		=	prio_graft,
439	.leaf		=	prio_leaf,
440	.find		=	prio_find,
441	.walk		=	prio_walk,
442	.tcf_block	=	prio_tcf_block,
443	.bind_tcf	=	prio_bind,
444	.unbind_tcf	=	prio_unbind,
445	.dump		=	prio_dump_class,
446	.dump_stats	=	prio_dump_class_stats,
447};
448
449static struct Qdisc_ops prio_qdisc_ops __read_mostly = {
450	.next		=	NULL,
451	.cl_ops		=	&prio_class_ops,
452	.id		=	"prio",
453	.priv_size	=	sizeof(struct prio_sched_data),
454	.enqueue	=	prio_enqueue,
455	.dequeue	=	prio_dequeue,
456	.peek		=	prio_peek,
457	.init		=	prio_init,
458	.reset		=	prio_reset,
459	.destroy	=	prio_destroy,
460	.change		=	prio_tune,
461	.dump		=	prio_dump,
462	.owner		=	THIS_MODULE,
463};
464
465static int __init prio_module_init(void)
466{
467	return register_qdisc(&prio_qdisc_ops);
468}
469
470static void __exit prio_module_exit(void)
471{
472	unregister_qdisc(&prio_qdisc_ops);
473}
474
475module_init(prio_module_init)
476module_exit(prio_module_exit)
477
478MODULE_LICENSE("GPL");
v5.4
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * net/sched/sch_prio.c	Simple 3-band priority "scheduler".
  4 *
 
 
 
 
 
  5 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  6 * Fixes:       19990609: J Hadi Salim <hadi@nortelnetworks.com>:
  7 *              Init --  EINVAL when opt undefined
  8 */
  9
 10#include <linux/module.h>
 11#include <linux/slab.h>
 12#include <linux/types.h>
 13#include <linux/kernel.h>
 14#include <linux/string.h>
 15#include <linux/errno.h>
 16#include <linux/skbuff.h>
 17#include <net/netlink.h>
 18#include <net/pkt_sched.h>
 19#include <net/pkt_cls.h>
 20
 21struct prio_sched_data {
 22	int bands;
 23	struct tcf_proto __rcu *filter_list;
 24	struct tcf_block *block;
 25	u8  prio2band[TC_PRIO_MAX+1];
 26	struct Qdisc *queues[TCQ_PRIO_BANDS];
 27};
 28
 29
 30static struct Qdisc *
 31prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
 32{
 33	struct prio_sched_data *q = qdisc_priv(sch);
 34	u32 band = skb->priority;
 35	struct tcf_result res;
 36	struct tcf_proto *fl;
 37	int err;
 38
 39	*qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 40	if (TC_H_MAJ(skb->priority) != sch->handle) {
 41		fl = rcu_dereference_bh(q->filter_list);
 42		err = tcf_classify(skb, fl, &res, false);
 43#ifdef CONFIG_NET_CLS_ACT
 44		switch (err) {
 45		case TC_ACT_STOLEN:
 46		case TC_ACT_QUEUED:
 47		case TC_ACT_TRAP:
 48			*qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
 49			/* fall through */
 50		case TC_ACT_SHOT:
 51			return NULL;
 52		}
 53#endif
 54		if (!fl || err < 0) {
 55			if (TC_H_MAJ(band))
 56				band = 0;
 57			return q->queues[q->prio2band[band & TC_PRIO_MAX]];
 58		}
 59		band = res.classid;
 60	}
 61	band = TC_H_MIN(band) - 1;
 62	if (band >= q->bands)
 63		return q->queues[q->prio2band[0]];
 64
 65	return q->queues[band];
 66}
 67
 68static int
 69prio_enqueue(struct sk_buff *skb, struct Qdisc *sch, struct sk_buff **to_free)
 70{
 71	unsigned int len = qdisc_pkt_len(skb);
 72	struct Qdisc *qdisc;
 73	int ret;
 74
 75	qdisc = prio_classify(skb, sch, &ret);
 76#ifdef CONFIG_NET_CLS_ACT
 77	if (qdisc == NULL) {
 78
 79		if (ret & __NET_XMIT_BYPASS)
 80			qdisc_qstats_drop(sch);
 81		__qdisc_drop(skb, to_free);
 82		return ret;
 83	}
 84#endif
 85
 86	ret = qdisc_enqueue(skb, qdisc, to_free);
 87	if (ret == NET_XMIT_SUCCESS) {
 88		sch->qstats.backlog += len;
 89		sch->q.qlen++;
 90		return NET_XMIT_SUCCESS;
 91	}
 92	if (net_xmit_drop_count(ret))
 93		qdisc_qstats_drop(sch);
 94	return ret;
 95}
 96
 97static struct sk_buff *prio_peek(struct Qdisc *sch)
 98{
 99	struct prio_sched_data *q = qdisc_priv(sch);
100	int prio;
101
102	for (prio = 0; prio < q->bands; prio++) {
103		struct Qdisc *qdisc = q->queues[prio];
104		struct sk_buff *skb = qdisc->ops->peek(qdisc);
105		if (skb)
106			return skb;
107	}
108	return NULL;
109}
110
111static struct sk_buff *prio_dequeue(struct Qdisc *sch)
112{
113	struct prio_sched_data *q = qdisc_priv(sch);
114	int prio;
115
116	for (prio = 0; prio < q->bands; prio++) {
117		struct Qdisc *qdisc = q->queues[prio];
118		struct sk_buff *skb = qdisc_dequeue_peeked(qdisc);
119		if (skb) {
120			qdisc_bstats_update(sch, skb);
121			qdisc_qstats_backlog_dec(sch, skb);
122			sch->q.qlen--;
123			return skb;
124		}
125	}
126	return NULL;
127
128}
129
130static void
131prio_reset(struct Qdisc *sch)
132{
133	int prio;
134	struct prio_sched_data *q = qdisc_priv(sch);
135
136	for (prio = 0; prio < q->bands; prio++)
137		qdisc_reset(q->queues[prio]);
138	sch->qstats.backlog = 0;
139	sch->q.qlen = 0;
140}
141
142static int prio_offload(struct Qdisc *sch, struct tc_prio_qopt *qopt)
143{
144	struct net_device *dev = qdisc_dev(sch);
145	struct tc_prio_qopt_offload opt = {
146		.handle = sch->handle,
147		.parent = sch->parent,
148	};
149
150	if (!tc_can_offload(dev) || !dev->netdev_ops->ndo_setup_tc)
151		return -EOPNOTSUPP;
152
153	if (qopt) {
154		opt.command = TC_PRIO_REPLACE;
155		opt.replace_params.bands = qopt->bands;
156		memcpy(&opt.replace_params.priomap, qopt->priomap,
157		       TC_PRIO_MAX + 1);
158		opt.replace_params.qstats = &sch->qstats;
159	} else {
160		opt.command = TC_PRIO_DESTROY;
161	}
162
163	return dev->netdev_ops->ndo_setup_tc(dev, TC_SETUP_QDISC_PRIO, &opt);
164}
165
166static void
167prio_destroy(struct Qdisc *sch)
168{
169	int prio;
170	struct prio_sched_data *q = qdisc_priv(sch);
171
172	tcf_block_put(q->block);
173	prio_offload(sch, NULL);
174	for (prio = 0; prio < q->bands; prio++)
175		qdisc_put(q->queues[prio]);
176}
177
178static int prio_tune(struct Qdisc *sch, struct nlattr *opt,
179		     struct netlink_ext_ack *extack)
180{
181	struct prio_sched_data *q = qdisc_priv(sch);
182	struct Qdisc *queues[TCQ_PRIO_BANDS];
183	int oldbands = q->bands, i;
184	struct tc_prio_qopt *qopt;
185
186	if (nla_len(opt) < sizeof(*qopt))
187		return -EINVAL;
188	qopt = nla_data(opt);
189
190	if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2)
191		return -EINVAL;
192
193	for (i = 0; i <= TC_PRIO_MAX; i++) {
194		if (qopt->priomap[i] >= qopt->bands)
195			return -EINVAL;
196	}
197
198	/* Before commit, make sure we can allocate all new qdiscs */
199	for (i = oldbands; i < qopt->bands; i++) {
200		queues[i] = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,
201					      TC_H_MAKE(sch->handle, i + 1),
202					      extack);
203		if (!queues[i]) {
204			while (i > oldbands)
205				qdisc_put(queues[--i]);
206			return -ENOMEM;
207		}
208	}
209
210	prio_offload(sch, qopt);
211	sch_tree_lock(sch);
212	q->bands = qopt->bands;
213	memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
214
215	for (i = q->bands; i < oldbands; i++)
216		qdisc_tree_flush_backlog(q->queues[i]);
 
 
 
 
 
217
218	for (i = oldbands; i < q->bands; i++) {
219		q->queues[i] = queues[i];
220		if (q->queues[i] != &noop_qdisc)
221			qdisc_hash_add(q->queues[i], true);
222	}
223
224	sch_tree_unlock(sch);
225
226	for (i = q->bands; i < oldbands; i++)
227		qdisc_put(q->queues[i]);
228	return 0;
229}
230
231static int prio_init(struct Qdisc *sch, struct nlattr *opt,
232		     struct netlink_ext_ack *extack)
233{
234	struct prio_sched_data *q = qdisc_priv(sch);
235	int err;
236
237	if (!opt)
238		return -EINVAL;
239
240	err = tcf_block_get(&q->block, &q->filter_list, sch, extack);
241	if (err)
242		return err;
243
244	return prio_tune(sch, opt, extack);
245}
246
247static int prio_dump_offload(struct Qdisc *sch)
248{
 
249	struct tc_prio_qopt_offload hw_stats = {
250		.command = TC_PRIO_STATS,
251		.handle = sch->handle,
252		.parent = sch->parent,
253		{
254			.stats = {
255				.bstats = &sch->bstats,
256				.qstats = &sch->qstats,
257			},
258		},
259	};
 
 
 
 
 
 
 
 
 
 
 
 
 
260
261	return qdisc_offload_dump_helper(sch, TC_SETUP_QDISC_PRIO, &hw_stats);
262}
263
264static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
265{
266	struct prio_sched_data *q = qdisc_priv(sch);
267	unsigned char *b = skb_tail_pointer(skb);
268	struct tc_prio_qopt opt;
269	int err;
270
271	opt.bands = q->bands;
272	memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX + 1);
273
274	err = prio_dump_offload(sch);
275	if (err)
276		goto nla_put_failure;
277
278	if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
279		goto nla_put_failure;
280
281	return skb->len;
282
283nla_put_failure:
284	nlmsg_trim(skb, b);
285	return -1;
286}
287
288static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
289		      struct Qdisc **old, struct netlink_ext_ack *extack)
290{
291	struct prio_sched_data *q = qdisc_priv(sch);
292	struct tc_prio_qopt_offload graft_offload;
 
293	unsigned long band = arg - 1;
 
 
294
295	if (new == NULL)
296		new = &noop_qdisc;
297
298	*old = qdisc_replace(sch, new, &q->queues[band]);
299
 
 
 
300	graft_offload.handle = sch->handle;
301	graft_offload.parent = sch->parent;
302	graft_offload.graft_params.band = band;
303	graft_offload.graft_params.child_handle = new->handle;
304	graft_offload.command = TC_PRIO_GRAFT;
305
306	qdisc_offload_graft_helper(qdisc_dev(sch), sch, new, *old,
307				   TC_SETUP_QDISC_PRIO, &graft_offload,
308				   extack);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
309	return 0;
310}
311
312static struct Qdisc *
313prio_leaf(struct Qdisc *sch, unsigned long arg)
314{
315	struct prio_sched_data *q = qdisc_priv(sch);
316	unsigned long band = arg - 1;
317
318	return q->queues[band];
319}
320
321static unsigned long prio_find(struct Qdisc *sch, u32 classid)
322{
323	struct prio_sched_data *q = qdisc_priv(sch);
324	unsigned long band = TC_H_MIN(classid);
325
326	if (band - 1 >= q->bands)
327		return 0;
328	return band;
329}
330
331static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
332{
333	return prio_find(sch, classid);
334}
335
336
337static void prio_unbind(struct Qdisc *q, unsigned long cl)
338{
339}
340
341static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,
342			   struct tcmsg *tcm)
343{
344	struct prio_sched_data *q = qdisc_priv(sch);
345
346	tcm->tcm_handle |= TC_H_MIN(cl);
347	tcm->tcm_info = q->queues[cl-1]->handle;
348	return 0;
349}
350
351static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
352				 struct gnet_dump *d)
353{
354	struct prio_sched_data *q = qdisc_priv(sch);
355	struct Qdisc *cl_q;
356
357	cl_q = q->queues[cl - 1];
358	if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch),
359				  d, NULL, &cl_q->bstats) < 0 ||
360	    qdisc_qstats_copy(d, cl_q) < 0)
361		return -1;
362
363	return 0;
364}
365
366static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
367{
368	struct prio_sched_data *q = qdisc_priv(sch);
369	int prio;
370
371	if (arg->stop)
372		return;
373
374	for (prio = 0; prio < q->bands; prio++) {
375		if (arg->count < arg->skip) {
376			arg->count++;
377			continue;
378		}
379		if (arg->fn(sch, prio + 1, arg) < 0) {
380			arg->stop = 1;
381			break;
382		}
383		arg->count++;
384	}
385}
386
387static struct tcf_block *prio_tcf_block(struct Qdisc *sch, unsigned long cl,
388					struct netlink_ext_ack *extack)
389{
390	struct prio_sched_data *q = qdisc_priv(sch);
391
392	if (cl)
393		return NULL;
394	return q->block;
395}
396
397static const struct Qdisc_class_ops prio_class_ops = {
398	.graft		=	prio_graft,
399	.leaf		=	prio_leaf,
400	.find		=	prio_find,
401	.walk		=	prio_walk,
402	.tcf_block	=	prio_tcf_block,
403	.bind_tcf	=	prio_bind,
404	.unbind_tcf	=	prio_unbind,
405	.dump		=	prio_dump_class,
406	.dump_stats	=	prio_dump_class_stats,
407};
408
409static struct Qdisc_ops prio_qdisc_ops __read_mostly = {
410	.next		=	NULL,
411	.cl_ops		=	&prio_class_ops,
412	.id		=	"prio",
413	.priv_size	=	sizeof(struct prio_sched_data),
414	.enqueue	=	prio_enqueue,
415	.dequeue	=	prio_dequeue,
416	.peek		=	prio_peek,
417	.init		=	prio_init,
418	.reset		=	prio_reset,
419	.destroy	=	prio_destroy,
420	.change		=	prio_tune,
421	.dump		=	prio_dump,
422	.owner		=	THIS_MODULE,
423};
424
425static int __init prio_module_init(void)
426{
427	return register_qdisc(&prio_qdisc_ops);
428}
429
430static void __exit prio_module_exit(void)
431{
432	unregister_qdisc(&prio_qdisc_ops);
433}
434
435module_init(prio_module_init)
436module_exit(prio_module_exit)
437
438MODULE_LICENSE("GPL");