1/*
  2 * net/sched/sch_mq.c		Classful multiqueue dummy scheduler
  3 *
  4 * Copyright (c) 2009 Patrick McHardy <kaber@trash.net>
  5 *
  6 * This program is free software; you can redistribute it and/or
  7 * modify it under the terms of the GNU General Public License
  8 * version 2 as published by the Free Software Foundation.
  9 */
 10
 11#include <linux/types.h>
 12#include <linux/slab.h>
 13#include <linux/kernel.h>
 14#include <linux/export.h>
 15#include <linux/string.h>
 16#include <linux/errno.h>
 17#include <linux/skbuff.h>
 18#include <net/netlink.h>
 19#include <net/pkt_sched.h>
 20
 21struct mq_sched {
 22	struct Qdisc		**qdiscs;
 23};
 24
 25static void mq_destroy(struct Qdisc *sch)
 26{
 27	struct net_device *dev = qdisc_dev(sch);
 28	struct mq_sched *priv = qdisc_priv(sch);
 29	unsigned int ntx;
 30
 31	if (!priv->qdiscs)
 32		return;
 33	for (ntx = 0; ntx < dev->num_tx_queues && priv->qdiscs[ntx]; ntx++)
 34		qdisc_destroy(priv->qdiscs[ntx]);
 35	kfree(priv->qdiscs);
 36}
 37
 38static int mq_init(struct Qdisc *sch, struct nlattr *opt)
 39{
 40	struct net_device *dev = qdisc_dev(sch);
 41	struct mq_sched *priv = qdisc_priv(sch);
 42	struct netdev_queue *dev_queue;
 43	struct Qdisc *qdisc;
 44	unsigned int ntx;
 45
 46	if (sch->parent != TC_H_ROOT)
 47		return -EOPNOTSUPP;
 48
 49	if (!netif_is_multiqueue(dev))
 50		return -EOPNOTSUPP;
 51
 52	/* pre-allocate qdiscs, attachment can't fail */
 53	priv->qdiscs = kcalloc(dev->num_tx_queues, sizeof(priv->qdiscs[0]),
 54			       GFP_KERNEL);
 55	if (priv->qdiscs == NULL)
 56		return -ENOMEM;
 57
 58	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
 59		dev_queue = netdev_get_tx_queue(dev, ntx);
 60		qdisc = qdisc_create_dflt(dev_queue, default_qdisc_ops,
 61					  TC_H_MAKE(TC_H_MAJ(sch->handle),
 62						    TC_H_MIN(ntx + 1)));
 63		if (qdisc == NULL)
 64			goto err;
 65		priv->qdiscs[ntx] = qdisc;
 66		qdisc->flags |= TCQ_F_ONETXQUEUE;
 67	}
 68
 69	sch->flags |= TCQ_F_MQROOT;
 70	return 0;
 71
 72err:
 73	mq_destroy(sch);
 74	return -ENOMEM;
 75}
 76
 77static void mq_attach(struct Qdisc *sch)
 78{
 79	struct net_device *dev = qdisc_dev(sch);
 80	struct mq_sched *priv = qdisc_priv(sch);
 81	struct Qdisc *qdisc, *old;
 82	unsigned int ntx;
 83
 84	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
 85		qdisc = priv->qdiscs[ntx];
 86		old = dev_graft_qdisc(qdisc->dev_queue, qdisc);
 87		if (old)
 88			qdisc_destroy(old);
 89#ifdef CONFIG_NET_SCHED
 90		if (ntx < dev->real_num_tx_queues)
 91			qdisc_list_add(qdisc);
 92#endif
 93
 94	}
 95	kfree(priv->qdiscs);
 96	priv->qdiscs = NULL;
 97}
 98
 99static int mq_dump(struct Qdisc *sch, struct sk_buff *skb)
100{
101	struct net_device *dev = qdisc_dev(sch);
102	struct Qdisc *qdisc;
103	unsigned int ntx;
104
105	sch->q.qlen = 0;
106	memset(&sch->bstats, 0, sizeof(sch->bstats));
107	memset(&sch->qstats, 0, sizeof(sch->qstats));
108
109	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
110		qdisc = netdev_get_tx_queue(dev, ntx)->qdisc_sleeping;
111		spin_lock_bh(qdisc_lock(qdisc));
112		sch->q.qlen		+= qdisc->q.qlen;
113		sch->bstats.bytes	+= qdisc->bstats.bytes;
114		sch->bstats.packets	+= qdisc->bstats.packets;
115		sch->qstats.qlen	+= qdisc->qstats.qlen;
116		sch->qstats.backlog	+= qdisc->qstats.backlog;
117		sch->qstats.drops	+= qdisc->qstats.drops;
118		sch->qstats.requeues	+= qdisc->qstats.requeues;
119		sch->qstats.overlimits	+= qdisc->qstats.overlimits;
120		spin_unlock_bh(qdisc_lock(qdisc));
121	}
122	return 0;
123}
124
125static struct netdev_queue *mq_queue_get(struct Qdisc *sch, unsigned long cl)
126{
127	struct net_device *dev = qdisc_dev(sch);
128	unsigned long ntx = cl - 1;
129
130	if (ntx >= dev->num_tx_queues)
131		return NULL;
132	return netdev_get_tx_queue(dev, ntx);
133}
134
135static struct netdev_queue *mq_select_queue(struct Qdisc *sch,
136					    struct tcmsg *tcm)
137{
138	unsigned int ntx = TC_H_MIN(tcm->tcm_parent);
139	struct netdev_queue *dev_queue = mq_queue_get(sch, ntx);
140
141	if (!dev_queue) {
142		struct net_device *dev = qdisc_dev(sch);
143
144		return netdev_get_tx_queue(dev, 0);
145	}
146	return dev_queue;
147}
148
149static int mq_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new,
150		    struct Qdisc **old)
151{
152	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
153	struct net_device *dev = qdisc_dev(sch);
154
155	if (dev->flags & IFF_UP)
156		dev_deactivate(dev);
157
158	*old = dev_graft_qdisc(dev_queue, new);
159	if (new)
160		new->flags |= TCQ_F_ONETXQUEUE;
161	if (dev->flags & IFF_UP)
162		dev_activate(dev);
163	return 0;
164}
165
166static struct Qdisc *mq_leaf(struct Qdisc *sch, unsigned long cl)
167{
168	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
169
170	return dev_queue->qdisc_sleeping;
171}
172
173static unsigned long mq_get(struct Qdisc *sch, u32 classid)
174{
175	unsigned int ntx = TC_H_MIN(classid);
176
177	if (!mq_queue_get(sch, ntx))
178		return 0;
179	return ntx;
180}
181
182static void mq_put(struct Qdisc *sch, unsigned long cl)
183{
184}
185
186static int mq_dump_class(struct Qdisc *sch, unsigned long cl,
187			 struct sk_buff *skb, struct tcmsg *tcm)
188{
189	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
190
191	tcm->tcm_parent = TC_H_ROOT;
192	tcm->tcm_handle |= TC_H_MIN(cl);
193	tcm->tcm_info = dev_queue->qdisc_sleeping->handle;
194	return 0;
195}
196
197static int mq_dump_class_stats(struct Qdisc *sch, unsigned long cl,
198			       struct gnet_dump *d)
199{
200	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
201
202	sch = dev_queue->qdisc_sleeping;
203	sch->qstats.qlen = sch->q.qlen;
204	if (gnet_stats_copy_basic(d, &sch->bstats) < 0 ||
205	    gnet_stats_copy_queue(d, &sch->qstats) < 0)
206		return -1;
207	return 0;
208}
209
210static void mq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
211{
212	struct net_device *dev = qdisc_dev(sch);
213	unsigned int ntx;
214
215	if (arg->stop)
216		return;
217
218	arg->count = arg->skip;
219	for (ntx = arg->skip; ntx < dev->num_tx_queues; ntx++) {
220		if (arg->fn(sch, ntx + 1, arg) < 0) {
221			arg->stop = 1;
222			break;
223		}
224		arg->count++;
225	}
226}
227
228static const struct Qdisc_class_ops mq_class_ops = {
229	.select_queue	= mq_select_queue,
230	.graft		= mq_graft,
231	.leaf		= mq_leaf,
232	.get		= mq_get,
233	.put		= mq_put,
234	.walk		= mq_walk,
235	.dump		= mq_dump_class,
236	.dump_stats	= mq_dump_class_stats,
237};
238
239struct Qdisc_ops mq_qdisc_ops __read_mostly = {
240	.cl_ops		= &mq_class_ops,
241	.id		= "mq",
242	.priv_size	= sizeof(struct mq_sched),
243	.init		= mq_init,
244	.destroy	= mq_destroy,
245	.attach		= mq_attach,
246	.dump		= mq_dump,
247	.owner		= THIS_MODULE,
248};

  1/*
  2 * net/sched/sch_mq.c		Classful multiqueue dummy scheduler
  3 *
  4 * Copyright (c) 2009 Patrick McHardy <kaber@trash.net>
  5 *
  6 * This program is free software; you can redistribute it and/or
  7 * modify it under the terms of the GNU General Public License
  8 * version 2 as published by the Free Software Foundation.
  9 */
 10
 11#include <linux/types.h>
 12#include <linux/slab.h>
 13#include <linux/kernel.h>
 14#include <linux/export.h>
 15#include <linux/string.h>
 16#include <linux/errno.h>
 17#include <linux/skbuff.h>
 18#include <net/netlink.h>
 19#include <net/pkt_sched.h>
 20
 21struct mq_sched {
 22	struct Qdisc		**qdiscs;
 23};
 24
 25static void mq_destroy(struct Qdisc *sch)
 26{
 27	struct net_device *dev = qdisc_dev(sch);
 28	struct mq_sched *priv = qdisc_priv(sch);
 29	unsigned int ntx;
 30
 31	if (!priv->qdiscs)
 32		return;
 33	for (ntx = 0; ntx < dev->num_tx_queues && priv->qdiscs[ntx]; ntx++)
 34		qdisc_destroy(priv->qdiscs[ntx]);
 35	kfree(priv->qdiscs);
 36}
 37
 38static int mq_init(struct Qdisc *sch, struct nlattr *opt)
 39{
 40	struct net_device *dev = qdisc_dev(sch);
 41	struct mq_sched *priv = qdisc_priv(sch);
 42	struct netdev_queue *dev_queue;
 43	struct Qdisc *qdisc;
 44	unsigned int ntx;
 45
 46	if (sch->parent != TC_H_ROOT)
 47		return -EOPNOTSUPP;
 48
 49	if (!netif_is_multiqueue(dev))
 50		return -EOPNOTSUPP;
 51
 52	/* pre-allocate qdiscs, attachment can't fail */
 53	priv->qdiscs = kcalloc(dev->num_tx_queues, sizeof(priv->qdiscs[0]),
 54			       GFP_KERNEL);
 55	if (priv->qdiscs == NULL)
 56		return -ENOMEM;
 57
 58	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
 59		dev_queue = netdev_get_tx_queue(dev, ntx);
 60		qdisc = qdisc_create_dflt(dev_queue, get_default_qdisc_ops(dev, ntx),
 61					  TC_H_MAKE(TC_H_MAJ(sch->handle),
 62						    TC_H_MIN(ntx + 1)));
 63		if (qdisc == NULL)
 64			goto err;
 65		priv->qdiscs[ntx] = qdisc;
 66		qdisc->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
 67	}
 68
 69	sch->flags |= TCQ_F_MQROOT;
 70	return 0;
 71
 72err:
 73	mq_destroy(sch);
 74	return -ENOMEM;
 75}
 76
 77static void mq_attach(struct Qdisc *sch)
 78{
 79	struct net_device *dev = qdisc_dev(sch);
 80	struct mq_sched *priv = qdisc_priv(sch);
 81	struct Qdisc *qdisc, *old;
 82	unsigned int ntx;
 83
 84	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
 85		qdisc = priv->qdiscs[ntx];
 86		old = dev_graft_qdisc(qdisc->dev_queue, qdisc);
 87		if (old)
 88			qdisc_destroy(old);
 89#ifdef CONFIG_NET_SCHED
 90		if (ntx < dev->real_num_tx_queues)
 91			qdisc_list_add(qdisc);
 92#endif
 93
 94	}
 95	kfree(priv->qdiscs);
 96	priv->qdiscs = NULL;
 97}
 98
 99static int mq_dump(struct Qdisc *sch, struct sk_buff *skb)
100{
101	struct net_device *dev = qdisc_dev(sch);
102	struct Qdisc *qdisc;
103	unsigned int ntx;
104
105	sch->q.qlen = 0;
106	memset(&sch->bstats, 0, sizeof(sch->bstats));
107	memset(&sch->qstats, 0, sizeof(sch->qstats));
108
109	for (ntx = 0; ntx < dev->num_tx_queues; ntx++) {
110		qdisc = netdev_get_tx_queue(dev, ntx)->qdisc_sleeping;
111		spin_lock_bh(qdisc_lock(qdisc));
112		sch->q.qlen		+= qdisc->q.qlen;
113		sch->bstats.bytes	+= qdisc->bstats.bytes;
114		sch->bstats.packets	+= qdisc->bstats.packets;
 
115		sch->qstats.backlog	+= qdisc->qstats.backlog;
116		sch->qstats.drops	+= qdisc->qstats.drops;
117		sch->qstats.requeues	+= qdisc->qstats.requeues;
118		sch->qstats.overlimits	+= qdisc->qstats.overlimits;
119		spin_unlock_bh(qdisc_lock(qdisc));
120	}
121	return 0;
122}
123
124static struct netdev_queue *mq_queue_get(struct Qdisc *sch, unsigned long cl)
125{
126	struct net_device *dev = qdisc_dev(sch);
127	unsigned long ntx = cl - 1;
128
129	if (ntx >= dev->num_tx_queues)
130		return NULL;
131	return netdev_get_tx_queue(dev, ntx);
132}
133
134static struct netdev_queue *mq_select_queue(struct Qdisc *sch,
135					    struct tcmsg *tcm)
136{
137	unsigned int ntx = TC_H_MIN(tcm->tcm_parent);
138	struct netdev_queue *dev_queue = mq_queue_get(sch, ntx);
139
140	if (!dev_queue) {
141		struct net_device *dev = qdisc_dev(sch);
142
143		return netdev_get_tx_queue(dev, 0);
144	}
145	return dev_queue;
146}
147
148static int mq_graft(struct Qdisc *sch, unsigned long cl, struct Qdisc *new,
149		    struct Qdisc **old)
150{
151	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
152	struct net_device *dev = qdisc_dev(sch);
153
154	if (dev->flags & IFF_UP)
155		dev_deactivate(dev);
156
157	*old = dev_graft_qdisc(dev_queue, new);
158	if (new)
159		new->flags |= TCQ_F_ONETXQUEUE | TCQ_F_NOPARENT;
160	if (dev->flags & IFF_UP)
161		dev_activate(dev);
162	return 0;
163}
164
165static struct Qdisc *mq_leaf(struct Qdisc *sch, unsigned long cl)
166{
167	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
168
169	return dev_queue->qdisc_sleeping;
170}
171
172static unsigned long mq_get(struct Qdisc *sch, u32 classid)
173{
174	unsigned int ntx = TC_H_MIN(classid);
175
176	if (!mq_queue_get(sch, ntx))
177		return 0;
178	return ntx;
179}
180
181static void mq_put(struct Qdisc *sch, unsigned long cl)
182{
183}
184
185static int mq_dump_class(struct Qdisc *sch, unsigned long cl,
186			 struct sk_buff *skb, struct tcmsg *tcm)
187{
188	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
189
190	tcm->tcm_parent = TC_H_ROOT;
191	tcm->tcm_handle |= TC_H_MIN(cl);
192	tcm->tcm_info = dev_queue->qdisc_sleeping->handle;
193	return 0;
194}
195
196static int mq_dump_class_stats(struct Qdisc *sch, unsigned long cl,
197			       struct gnet_dump *d)
198{
199	struct netdev_queue *dev_queue = mq_queue_get(sch, cl);
200
201	sch = dev_queue->qdisc_sleeping;
202	if (gnet_stats_copy_basic(d, NULL, &sch->bstats) < 0 ||
203	    gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0)
 
204		return -1;
205	return 0;
206}
207
208static void mq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
209{
210	struct net_device *dev = qdisc_dev(sch);
211	unsigned int ntx;
212
213	if (arg->stop)
214		return;
215
216	arg->count = arg->skip;
217	for (ntx = arg->skip; ntx < dev->num_tx_queues; ntx++) {
218		if (arg->fn(sch, ntx + 1, arg) < 0) {
219			arg->stop = 1;
220			break;
221		}
222		arg->count++;
223	}
224}
225
226static const struct Qdisc_class_ops mq_class_ops = {
227	.select_queue	= mq_select_queue,
228	.graft		= mq_graft,
229	.leaf		= mq_leaf,
230	.get		= mq_get,
231	.put		= mq_put,
232	.walk		= mq_walk,
233	.dump		= mq_dump_class,
234	.dump_stats	= mq_dump_class_stats,
235};
236
237struct Qdisc_ops mq_qdisc_ops __read_mostly = {
238	.cl_ops		= &mq_class_ops,
239	.id		= "mq",
240	.priv_size	= sizeof(struct mq_sched),
241	.init		= mq_init,
242	.destroy	= mq_destroy,
243	.attach		= mq_attach,
244	.dump		= mq_dump,
245	.owner		= THIS_MODULE,
246};