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

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

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ 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.72 ] ~ [ 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, see <http://www.gnu.org/licenses/>.
 15  *
 16  * Author: Alexander Duyck <alexander.h.duyck@intel.com>
 17  */
 18 
 19 #include <linux/module.h>
 20 #include <linux/slab.h>
 21 #include <linux/types.h>
 22 #include <linux/kernel.h>
 23 #include <linux/string.h>
 24 #include <linux/errno.h>
 25 #include <linux/skbuff.h>
 26 #include <net/netlink.h>
 27 #include <net/pkt_sched.h>
 28 
 29 
 30 struct multiq_sched_data {
 31         u16 bands;
 32         u16 max_bands;
 33         u16 curband;
 34         struct tcf_proto __rcu *filter_list;
 35         struct Qdisc **queues;
 36 };
 37 
 38 
 39 static struct Qdisc *
 40 multiq_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
 41 {
 42         struct multiq_sched_data *q = qdisc_priv(sch);
 43         u32 band;
 44         struct tcf_result res;
 45         struct tcf_proto *fl = rcu_dereference_bh(q->filter_list);
 46         int err;
 47 
 48         *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 49         err = tc_classify(skb, fl, &res, false);
 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                struct sk_buff **to_free)
 70 {
 71         struct Qdisc *qdisc;
 72         int ret;
 73 
 74         qdisc = multiq_classify(skb, sch, &ret);
 75 #ifdef CONFIG_NET_CLS_ACT
 76         if (qdisc == NULL) {
 77 
 78                 if (ret & __NET_XMIT_BYPASS)
 79                         qdisc_qstats_drop(sch);
 80                 __qdisc_drop(skb, to_free);
 81                 return ret;
 82         }
 83 #endif
 84 
 85         ret = qdisc_enqueue(skb, qdisc, to_free);
 86         if (ret == NET_XMIT_SUCCESS) {
 87                 sch->q.qlen++;
 88                 return NET_XMIT_SUCCESS;
 89         }
 90         if (net_xmit_drop_count(ret))
 91                 qdisc_qstats_drop(sch);
 92         return ret;
 93 }
 94 
 95 static struct sk_buff *multiq_dequeue(struct Qdisc *sch)
 96 {
 97         struct multiq_sched_data *q = qdisc_priv(sch);
 98         struct Qdisc *qdisc;
 99         struct sk_buff *skb;
100         int band;
101 
102         for (band = 0; band < q->bands; band++) {
103                 /* cycle through bands to ensure fairness */
104                 q->curband++;
105                 if (q->curband >= q->bands)
106                         q->curband = 0;
107 
108                 /* Check that target subqueue is available before
109                  * pulling an skb to avoid head-of-line blocking.
110                  */
111                 if (!netif_xmit_stopped(
112                     netdev_get_tx_queue(qdisc_dev(sch), q->curband))) {
113                         qdisc = q->queues[q->curband];
114                         skb = qdisc->dequeue(qdisc);
115                         if (skb) {
116                                 qdisc_bstats_update(sch, skb);
117                                 sch->q.qlen--;
118                                 return skb;
119                         }
120                 }
121         }
122         return NULL;
123 
124 }
125 
126 static struct sk_buff *multiq_peek(struct Qdisc *sch)
127 {
128         struct multiq_sched_data *q = qdisc_priv(sch);
129         unsigned int curband = q->curband;
130         struct Qdisc *qdisc;
131         struct sk_buff *skb;
132         int band;
133 
134         for (band = 0; band < q->bands; band++) {
135                 /* cycle through bands to ensure fairness */
136                 curband++;
137                 if (curband >= q->bands)
138                         curband = 0;
139 
140                 /* Check that target subqueue is available before
141                  * pulling an skb to avoid head-of-line blocking.
142                  */
143                 if (!netif_xmit_stopped(
144                     netdev_get_tx_queue(qdisc_dev(sch), curband))) {
145                         qdisc = q->queues[curband];
146                         skb = qdisc->ops->peek(qdisc);
147                         if (skb)
148                                 return skb;
149                 }
150         }
151         return NULL;
152 
153 }
154 
155 static void
156 multiq_reset(struct Qdisc *sch)
157 {
158         u16 band;
159         struct multiq_sched_data *q = qdisc_priv(sch);
160 
161         for (band = 0; band < q->bands; band++)
162                 qdisc_reset(q->queues[band]);
163         sch->q.qlen = 0;
164         q->curband = 0;
165 }
166 
167 static void
168 multiq_destroy(struct Qdisc *sch)
169 {
170         int band;
171         struct multiq_sched_data *q = qdisc_priv(sch);
172 
173         tcf_destroy_chain(&q->filter_list);
174         for (band = 0; band < q->bands; band++)
175                 qdisc_destroy(q->queues[band]);
176 
177         kfree(q->queues);
178 }
179 
180 static int multiq_tune(struct Qdisc *sch, struct nlattr *opt)
181 {
182         struct multiq_sched_data *q = qdisc_priv(sch);
183         struct tc_multiq_qopt *qopt;
184         int i;
185 
186         if (!netif_is_multiqueue(qdisc_dev(sch)))
187                 return -EOPNOTSUPP;
188         if (nla_len(opt) < sizeof(*qopt))
189                 return -EINVAL;
190 
191         qopt = nla_data(opt);
192 
193         qopt->bands = qdisc_dev(sch)->real_num_tx_queues;
194 
195         sch_tree_lock(sch);
196         q->bands = qopt->bands;
197         for (i = q->bands; i < q->max_bands; i++) {
198                 if (q->queues[i] != &noop_qdisc) {
199                         struct Qdisc *child = q->queues[i];
200                         q->queues[i] = &noop_qdisc;
201                         qdisc_tree_reduce_backlog(child, child->q.qlen,
202                                                   child->qstats.backlog);
203                         qdisc_destroy(child);
204                 }
205         }
206 
207         sch_tree_unlock(sch);
208 
209         for (i = 0; i < q->bands; i++) {
210                 if (q->queues[i] == &noop_qdisc) {
211                         struct Qdisc *child, *old;
212                         child = qdisc_create_dflt(sch->dev_queue,
213                                                   &pfifo_qdisc_ops,
214                                                   TC_H_MAKE(sch->handle,
215                                                             i + 1));
216                         if (child) {
217                                 sch_tree_lock(sch);
218                                 old = q->queues[i];
219                                 q->queues[i] = child;
220 
221                                 if (old != &noop_qdisc) {
222                                         qdisc_tree_reduce_backlog(old,
223                                                                   old->q.qlen,
224                                                                   old->qstats.backlog);
225                                         qdisc_destroy(old);
226                                 }
227                                 sch_tree_unlock(sch);
228                         }
229                 }
230         }
231         return 0;
232 }
233 
234 static int multiq_init(struct Qdisc *sch, struct nlattr *opt)
235 {
236         struct multiq_sched_data *q = qdisc_priv(sch);
237         int i, err;
238 
239         q->queues = NULL;
240 
241         if (opt == NULL)
242                 return -EINVAL;
243 
244         q->max_bands = qdisc_dev(sch)->num_tx_queues;
245 
246         q->queues = kcalloc(q->max_bands, sizeof(struct Qdisc *), GFP_KERNEL);
247         if (!q->queues)
248                 return -ENOBUFS;
249         for (i = 0; i < q->max_bands; i++)
250                 q->queues[i] = &noop_qdisc;
251 
252         err = multiq_tune(sch, opt);
253 
254         if (err)
255                 kfree(q->queues);
256 
257         return err;
258 }
259 
260 static int multiq_dump(struct Qdisc *sch, struct sk_buff *skb)
261 {
262         struct multiq_sched_data *q = qdisc_priv(sch);
263         unsigned char *b = skb_tail_pointer(skb);
264         struct tc_multiq_qopt opt;
265 
266         opt.bands = q->bands;
267         opt.max_bands = q->max_bands;
268 
269         if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
270                 goto nla_put_failure;
271 
272         return skb->len;
273 
274 nla_put_failure:
275         nlmsg_trim(skb, b);
276         return -1;
277 }
278 
279 static int multiq_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
280                       struct Qdisc **old)
281 {
282         struct multiq_sched_data *q = qdisc_priv(sch);
283         unsigned long band = arg - 1;
284 
285         if (new == NULL)
286                 new = &noop_qdisc;
287 
288         *old = qdisc_replace(sch, new, &q->queues[band]);
289         return 0;
290 }
291 
292 static struct Qdisc *
293 multiq_leaf(struct Qdisc *sch, unsigned long arg)
294 {
295         struct multiq_sched_data *q = qdisc_priv(sch);
296         unsigned long band = arg - 1;
297 
298         return q->queues[band];
299 }
300 
301 static unsigned long multiq_get(struct Qdisc *sch, u32 classid)
302 {
303         struct multiq_sched_data *q = qdisc_priv(sch);
304         unsigned long band = TC_H_MIN(classid);
305 
306         if (band - 1 >= q->bands)
307                 return 0;
308         return band;
309 }
310 
311 static unsigned long multiq_bind(struct Qdisc *sch, unsigned long parent,
312                                  u32 classid)
313 {
314         return multiq_get(sch, classid);
315 }
316 
317 
318 static void multiq_put(struct Qdisc *q, unsigned long cl)
319 {
320 }
321 
322 static int multiq_dump_class(struct Qdisc *sch, unsigned long cl,
323                              struct sk_buff *skb, struct tcmsg *tcm)
324 {
325         struct multiq_sched_data *q = qdisc_priv(sch);
326 
327         tcm->tcm_handle |= TC_H_MIN(cl);
328         tcm->tcm_info = q->queues[cl - 1]->handle;
329         return 0;
330 }
331 
332 static int multiq_dump_class_stats(struct Qdisc *sch, unsigned long cl,
333                                  struct gnet_dump *d)
334 {
335         struct multiq_sched_data *q = qdisc_priv(sch);
336         struct Qdisc *cl_q;
337 
338         cl_q = q->queues[cl - 1];
339         if (gnet_stats_copy_basic(qdisc_root_sleeping_running(sch),
340                                   d, NULL, &cl_q->bstats) < 0 ||
341             gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0)
342                 return -1;
343 
344         return 0;
345 }
346 
347 static void multiq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
348 {
349         struct multiq_sched_data *q = qdisc_priv(sch);
350         int band;
351 
352         if (arg->stop)
353                 return;
354 
355         for (band = 0; band < q->bands; band++) {
356                 if (arg->count < arg->skip) {
357                         arg->count++;
358                         continue;
359                 }
360                 if (arg->fn(sch, band + 1, arg) < 0) {
361                         arg->stop = 1;
362                         break;
363                 }
364                 arg->count++;
365         }
366 }
367 
368 static struct tcf_proto __rcu **multiq_find_tcf(struct Qdisc *sch,
369                                                 unsigned long cl)
370 {
371         struct multiq_sched_data *q = qdisc_priv(sch);
372 
373         if (cl)
374                 return NULL;
375         return &q->filter_list;
376 }
377 
378 static const struct Qdisc_class_ops multiq_class_ops = {
379         .graft          =       multiq_graft,
380         .leaf           =       multiq_leaf,
381         .get            =       multiq_get,
382         .put            =       multiq_put,
383         .walk           =       multiq_walk,
384         .tcf_chain      =       multiq_find_tcf,
385         .bind_tcf       =       multiq_bind,
386         .unbind_tcf     =       multiq_put,
387         .dump           =       multiq_dump_class,
388         .dump_stats     =       multiq_dump_class_stats,
389 };
390 
391 static struct Qdisc_ops multiq_qdisc_ops __read_mostly = {
392         .next           =       NULL,
393         .cl_ops         =       &multiq_class_ops,
394         .id             =       "multiq",
395         .priv_size      =       sizeof(struct multiq_sched_data),
396         .enqueue        =       multiq_enqueue,
397         .dequeue        =       multiq_dequeue,
398         .peek           =       multiq_peek,
399         .init           =       multiq_init,
400         .reset          =       multiq_reset,
401         .destroy        =       multiq_destroy,
402         .change         =       multiq_tune,
403         .dump           =       multiq_dump,
404         .owner          =       THIS_MODULE,
405 };
406 
407 static int __init multiq_module_init(void)
408 {
409         return register_qdisc(&multiq_qdisc_ops);
410 }
411 
412 static void __exit multiq_module_exit(void)
413 {
414         unregister_qdisc(&multiq_qdisc_ops);
415 }
416 
417 module_init(multiq_module_init)
418 module_exit(multiq_module_exit)
419 
420 MODULE_LICENSE("GPL");
421 

~ [ 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