~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sched/sch_multiq.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2008, Intel Corporation.
  3  *
  4  * This program is free software; you can redistribute it and/or modify it
  5  * under the terms and conditions of the GNU General Public License,
  6  * version 2, as published by the Free Software Foundation.
  7  *
  8  * This program is distributed in the hope it will be useful, but WITHOUT
  9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 11  * more details.
 12  *
 13  * You should have received a copy of the GNU General Public License along with
 14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 15  * Place - Suite 330, Boston, MA 02111-1307 USA.
 16  *
 17  * Author: Alexander Duyck <alexander.h.duyck@intel.com>
 18  */
 19 
 20 #include <linux/module.h>
 21 #include <linux/slab.h>
 22 #include <linux/types.h>
 23 #include <linux/kernel.h>
 24 #include <linux/string.h>
 25 #include <linux/errno.h>
 26 #include <linux/skbuff.h>
 27 #include <net/netlink.h>
 28 #include <net/pkt_sched.h>
 29 
 30 
 31 struct multiq_sched_data {
 32         u16 bands;
 33         u16 max_bands;
 34         u16 curband;
 35         struct tcf_proto *filter_list;
 36         struct Qdisc **queues;
 37 };
 38 
 39 
 40 static struct Qdisc *
 41 multiq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
 42 {
 43         struct multiq_sched_data *q = qdisc_priv(sch);
 44         u32 band;
 45         struct tcf_result res;
 46         int err;
 47 
 48         *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 49         err = tc_classify(skb, q->filter_list, &res);
 50 #ifdef CONFIG_NET_CLS_ACT
 51         switch (err) {
 52         case TC_ACT_STOLEN:
 53         case TC_ACT_QUEUED:
 54                 *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
 55         case TC_ACT_SHOT:
 56                 return NULL;
 57         }
 58 #endif
 59         band = skb_get_queue_mapping(skb);
 60 
 61         if (band >= q->bands)
 62                 return q->queues[0];
 63 
 64         return q->queues[band];
 65 }
 66 
 67 static int
 68 multiq_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 69 {
 70         struct Qdisc *qdisc;
 71         int ret;
 72 
 73         qdisc = multiq_classify(skb, sch, &ret);
 74 #ifdef CONFIG_NET_CLS_ACT
 75         if (qdisc == NULL) {
 76 
 77                 if (ret & __NET_XMIT_BYPASS)
 78                         sch->qstats.drops++;
 79                 kfree_skb(skb);
 80                 return ret;
 81         }
 82 #endif
 83 
 84         ret = qdisc_enqueue(skb, qdisc);
 85         if (ret == NET_XMIT_SUCCESS) {
 86                 sch->q.qlen++;
 87                 return NET_XMIT_SUCCESS;
 88         }
 89         if (net_xmit_drop_count(ret))
 90                 sch->qstats.drops++;
 91         return ret;
 92 }
 93 
 94 static struct sk_buff *multiq_dequeue(struct Qdisc *sch)
 95 {
 96         struct multiq_sched_data *q = qdisc_priv(sch);
 97         struct Qdisc *qdisc;
 98         struct sk_buff *skb;
 99         int band;
100 
101         for (band = 0; band < q->bands; band++) {
102                 /* cycle through bands to ensure fairness */
103                 q->curband++;
104                 if (q->curband >= q->bands)
105                         q->curband = 0;
106 
107                 /* Check that target subqueue is available before
108                  * pulling an skb to avoid head-of-line blocking.
109                  */
110                 if (!netif_xmit_stopped(
111                     netdev_get_tx_queue(qdisc_dev(sch), q->curband))) {
112                         qdisc = q->queues[q->curband];
113                         skb = qdisc->dequeue(qdisc);
114                         if (skb) {
115                                 qdisc_bstats_update(sch, skb);
116                                 sch->q.qlen--;
117                                 return skb;
118                         }
119                 }
120         }
121         return NULL;
122 
123 }
124 
125 static struct sk_buff *multiq_peek(struct Qdisc *sch)
126 {
127         struct multiq_sched_data *q = qdisc_priv(sch);
128         unsigned int curband = q->curband;
129         struct Qdisc *qdisc;
130         struct sk_buff *skb;
131         int band;
132 
133         for (band = 0; band < q->bands; band++) {
134                 /* cycle through bands to ensure fairness */
135                 curband++;
136                 if (curband >= q->bands)
137                         curband = 0;
138 
139                 /* Check that target subqueue is available before
140                  * pulling an skb to avoid head-of-line blocking.
141                  */
142                 if (!netif_xmit_stopped(
143                     netdev_get_tx_queue(qdisc_dev(sch), curband))) {
144                         qdisc = q->queues[curband];
145                         skb = qdisc->ops->peek(qdisc);
146                         if (skb)
147                                 return skb;
148                 }
149         }
150         return NULL;
151 
152 }
153 
154 static unsigned int multiq_drop(struct Qdisc *sch)
155 {
156         struct multiq_sched_data *q = qdisc_priv(sch);
157         int band;
158         unsigned int len;
159         struct Qdisc *qdisc;
160 
161         for (band = q->bands - 1; band >= 0; band--) {
162                 qdisc = q->queues[band];
163                 if (qdisc->ops->drop) {
164                         len = qdisc->ops->drop(qdisc);
165                         if (len != 0) {
166                                 sch->q.qlen--;
167                                 return len;
168                         }
169                 }
170         }
171         return 0;
172 }
173 
174 
175 static void
176 multiq_reset(struct Qdisc *sch)
177 {
178         u16 band;
179         struct multiq_sched_data *q = qdisc_priv(sch);
180 
181         for (band = 0; band < q->bands; band++)
182                 qdisc_reset(q->queues[band]);
183         sch->q.qlen = 0;
184         q->curband = 0;
185 }
186 
187 static void
188 multiq_destroy(struct Qdisc *sch)
189 {
190         int band;
191         struct multiq_sched_data *q = qdisc_priv(sch);
192 
193         tcf_destroy_chain(&q->filter_list);
194         for (band = 0; band < q->bands; band++)
195                 qdisc_destroy(q->queues[band]);
196 
197         kfree(q->queues);
198 }
199 
200 static int multiq_tune(struct Qdisc *sch, struct nlattr *opt)
201 {
202         struct multiq_sched_data *q = qdisc_priv(sch);
203         struct tc_multiq_qopt *qopt;
204         int i;
205 
206         if (!netif_is_multiqueue(qdisc_dev(sch)))
207                 return -EOPNOTSUPP;
208         if (nla_len(opt) < sizeof(*qopt))
209                 return -EINVAL;
210 
211         qopt = nla_data(opt);
212 
213         qopt->bands = qdisc_dev(sch)->real_num_tx_queues;
214 
215         sch_tree_lock(sch);
216         q->bands = qopt->bands;
217         for (i = q->bands; i < q->max_bands; i++) {
218                 if (q->queues[i] != &noop_qdisc) {
219                         struct Qdisc *child = q->queues[i];
220                         q->queues[i] = &noop_qdisc;
221                         qdisc_tree_decrease_qlen(child, child->q.qlen);
222                         qdisc_destroy(child);
223                 }
224         }
225 
226         sch_tree_unlock(sch);
227 
228         for (i = 0; i < q->bands; i++) {
229                 if (q->queues[i] == &noop_qdisc) {
230                         struct Qdisc *child, *old;
231                         child = qdisc_create_dflt(sch->dev_queue,
232                                                   &pfifo_qdisc_ops,
233                                                   TC_H_MAKE(sch->handle,
234                                                             i + 1));
235                         if (child) {
236                                 sch_tree_lock(sch);
237                                 old = q->queues[i];
238                                 q->queues[i] = child;
239 
240                                 if (old != &noop_qdisc) {
241                                         qdisc_tree_decrease_qlen(old,
242                                                                  old->q.qlen);
243                                         qdisc_destroy(old);
244                                 }
245                                 sch_tree_unlock(sch);
246                         }
247                 }
248         }
249         return 0;
250 }
251 
252 static int multiq_init(struct Qdisc *sch, struct nlattr *opt)
253 {
254         struct multiq_sched_data *q = qdisc_priv(sch);
255         int i, err;
256 
257         q->queues = NULL;
258 
259         if (opt == NULL)
260                 return -EINVAL;
261 
262         q->max_bands = qdisc_dev(sch)->num_tx_queues;
263 
264         q->queues = kcalloc(q->max_bands, sizeof(struct Qdisc *), GFP_KERNEL);
265         if (!q->queues)
266                 return -ENOBUFS;
267         for (i = 0; i < q->max_bands; i++)
268                 q->queues[i] = &noop_qdisc;
269 
270         err = multiq_tune(sch, opt);
271 
272         if (err)
273                 kfree(q->queues);
274 
275         return err;
276 }
277 
278 static int multiq_dump(struct Qdisc *sch, struct sk_buff *skb)
279 {
280         struct multiq_sched_data *q = qdisc_priv(sch);
281         unsigned char *b = skb_tail_pointer(skb);
282         struct tc_multiq_qopt opt;
283 
284         opt.bands = q->bands;
285         opt.max_bands = q->max_bands;
286 
287         if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
288                 goto nla_put_failure;
289 
290         return skb->len;
291 
292 nla_put_failure:
293         nlmsg_trim(skb, b);
294         return -1;
295 }
296 
297 static int multiq_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
298                       struct Qdisc **old)
299 {
300         struct multiq_sched_data *q = qdisc_priv(sch);
301         unsigned long band = arg - 1;
302 
303         if (new == NULL)
304                 new = &noop_qdisc;
305 
306         sch_tree_lock(sch);
307         *old = q->queues[band];
308         q->queues[band] = new;
309         qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
310         qdisc_reset(*old);
311         sch_tree_unlock(sch);
312 
313         return 0;
314 }
315 
316 static struct Qdisc *
317 multiq_leaf(struct Qdisc *sch, unsigned long arg)
318 {
319         struct multiq_sched_data *q = qdisc_priv(sch);
320         unsigned long band = arg - 1;
321 
322         return q->queues[band];
323 }
324 
325 static unsigned long multiq_get(struct Qdisc *sch, u32 classid)
326 {
327         struct multiq_sched_data *q = qdisc_priv(sch);
328         unsigned long band = TC_H_MIN(classid);
329 
330         if (band - 1 >= q->bands)
331                 return 0;
332         return band;
333 }
334 
335 static unsigned long multiq_bind(struct Qdisc *sch, unsigned long parent,
336                                  u32 classid)
337 {
338         return multiq_get(sch, classid);
339 }
340 
341 
342 static void multiq_put(struct Qdisc *q, unsigned long cl)
343 {
344 }
345 
346 static int multiq_dump_class(struct Qdisc *sch, unsigned long cl,
347                              struct sk_buff *skb, struct tcmsg *tcm)
348 {
349         struct multiq_sched_data *q = qdisc_priv(sch);
350 
351         tcm->tcm_handle |= TC_H_MIN(cl);
352         tcm->tcm_info = q->queues[cl - 1]->handle;
353         return 0;
354 }
355 
356 static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl,
357                                  struct gnet_dump *d)
358 {
359         struct multiq_sched_data *q = qdisc_priv(sch);
360         struct Qdisc *cl_q;
361 
362         cl_q = q->queues[cl - 1];
363         cl_q->qstats.qlen = cl_q->q.qlen;
364         if (gnet_stats_copy_basic(d, &cl_q->bstats) < 0 ||
365             gnet_stats_copy_queue(d, &cl_q->qstats) < 0)
366                 return -1;
367 
368         return 0;
369 }
370 
371 static void multiq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
372 {
373         struct multiq_sched_data *q = qdisc_priv(sch);
374         int band;
375 
376         if (arg->stop)
377                 return;
378 
379         for (band = 0; band < q->bands; band++) {
380                 if (arg->count < arg->skip) {
381                         arg->count++;
382                         continue;
383                 }
384                 if (arg->fn(sch, band + 1, arg) < 0) {
385                         arg->stop = 1;
386                         break;
387                 }
388                 arg->count++;
389         }
390 }
391 
392 static struct tcf_proto **multiq_find_tcf(struct Qdisc *sch, unsigned long cl)
393 {
394         struct multiq_sched_data *q = qdisc_priv(sch);
395 
396         if (cl)
397                 return NULL;
398         return &q->filter_list;
399 }
400 
401 static const struct Qdisc_class_ops multiq_class_ops = {
402         .graft          =       multiq_graft,
403         .leaf           =       multiq_leaf,
404         .get            =       multiq_get,
405         .put            =       multiq_put,
406         .walk           =       multiq_walk,
407         .tcf_chain      =       multiq_find_tcf,
408         .bind_tcf       =       multiq_bind,
409         .unbind_tcf     =       multiq_put,
410         .dump           =       multiq_dump_class,
411         .dump_stats     =       multiq_dump_class_stats,
412 };
413 
414 static struct Qdisc_ops multiq_qdisc_ops __read_mostly = {
415         .next           =       NULL,
416         .cl_ops         =       &multiq_class_ops,
417         .id             =       "multiq",
418         .priv_size      =       sizeof(struct multiq_sched_data),
419         .enqueue        =       multiq_enqueue,
420         .dequeue        =       multiq_dequeue,
421         .peek           =       multiq_peek,
422         .drop           =       multiq_drop,
423         .init           =       multiq_init,
424         .reset          =       multiq_reset,
425         .destroy        =       multiq_destroy,
426         .change         =       multiq_tune,
427         .dump           =       multiq_dump,
428         .owner          =       THIS_MODULE,
429 };
430 
431 static int __init multiq_module_init(void)
432 {
433         return register_qdisc(&multiq_qdisc_ops);
434 }
435 
436 static void __exit multiq_module_exit(void)
437 {
438         unregister_qdisc(&multiq_qdisc_ops);
439 }
440 
441 module_init(multiq_module_init)
442 module_exit(multiq_module_exit)
443 
444 MODULE_LICENSE("GPL");
445 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp