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

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

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 24 
 25 struct prio_sched_data {
 26         int bands;
 27         struct tcf_proto __rcu *filter_list;
 28         u8  prio2band[TC_PRIO_MAX+1];
 29         struct Qdisc *queues[TCQ_PRIO_BANDS];
 30 };
 31 
 32 
 33 static struct Qdisc *
 34 prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr)
 35 {
 36         struct prio_sched_data *q = qdisc_priv(sch);
 37         u32 band = skb->priority;
 38         struct tcf_result res;
 39         struct tcf_proto *fl;
 40         int err;
 41 
 42         *qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
 43         if (TC_H_MAJ(skb->priority) != sch->handle) {
 44                 fl = rcu_dereference_bh(q->filter_list);
 45                 err = tc_classify(skb, fl, &res, false);
 46 #ifdef CONFIG_NET_CLS_ACT
 47                 switch (err) {
 48                 case TC_ACT_STOLEN:
 49                 case TC_ACT_QUEUED:
 50                         *qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
 51                 case TC_ACT_SHOT:
 52                         return NULL;
 53                 }
 54 #endif
 55                 if (!fl || err < 0) {
 56                         if (TC_H_MAJ(band))
 57                                 band = 0;
 58                         return q->queues[q->prio2band[band & TC_PRIO_MAX]];
 59                 }
 60                 band = res.classid;
 61         }
 62         band = TC_H_MIN(band) - 1;
 63         if (band >= q->bands)
 64                 return q->queues[q->prio2band[0]];
 65 
 66         return q->queues[band];
 67 }
 68 
 69 static int
 70 prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 71 {
 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                 kfree_skb(skb);
 82                 return ret;
 83         }
 84 #endif
 85 
 86         ret = qdisc_enqueue(skb, qdisc);
 87         if (ret == NET_XMIT_SUCCESS) {
 88                 qdisc_qstats_backlog_inc(sch, skb);
 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 
 97 static 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 
111 static 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 
130 static unsigned int prio_drop(struct Qdisc *sch)
131 {
132         struct prio_sched_data *q = qdisc_priv(sch);
133         int prio;
134         unsigned int len;
135         struct Qdisc *qdisc;
136 
137         for (prio = q->bands-1; prio >= 0; prio--) {
138                 qdisc = q->queues[prio];
139                 if (qdisc->ops->drop && (len = qdisc->ops->drop(qdisc)) != 0) {
140                         sch->qstats.backlog -= len;
141                         sch->q.qlen--;
142                         return len;
143                 }
144         }
145         return 0;
146 }
147 
148 
149 static void
150 prio_reset(struct Qdisc *sch)
151 {
152         int prio;
153         struct prio_sched_data *q = qdisc_priv(sch);
154 
155         for (prio = 0; prio < q->bands; prio++)
156                 qdisc_reset(q->queues[prio]);
157         sch->qstats.backlog = 0;
158         sch->q.qlen = 0;
159 }
160 
161 static void
162 prio_destroy(struct Qdisc *sch)
163 {
164         int prio;
165         struct prio_sched_data *q = qdisc_priv(sch);
166 
167         tcf_destroy_chain(&q->filter_list);
168         for (prio = 0; prio < q->bands; prio++)
169                 qdisc_destroy(q->queues[prio]);
170 }
171 
172 static int prio_tune(struct Qdisc *sch, struct nlattr *opt)
173 {
174         struct prio_sched_data *q = qdisc_priv(sch);
175         struct tc_prio_qopt *qopt;
176         int i;
177 
178         if (nla_len(opt) < sizeof(*qopt))
179                 return -EINVAL;
180         qopt = nla_data(opt);
181 
182         if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2)
183                 return -EINVAL;
184 
185         for (i = 0; i <= TC_PRIO_MAX; i++) {
186                 if (qopt->priomap[i] >= qopt->bands)
187                         return -EINVAL;
188         }
189 
190         sch_tree_lock(sch);
191         q->bands = qopt->bands;
192         memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1);
193 
194         for (i = q->bands; i < TCQ_PRIO_BANDS; i++) {
195                 struct Qdisc *child = q->queues[i];
196                 q->queues[i] = &noop_qdisc;
197                 if (child != &noop_qdisc) {
198                         qdisc_tree_reduce_backlog(child, child->q.qlen, child->qstats.backlog);
199                         qdisc_destroy(child);
200                 }
201         }
202         sch_tree_unlock(sch);
203 
204         for (i = 0; i < q->bands; i++) {
205                 if (q->queues[i] == &noop_qdisc) {
206                         struct Qdisc *child, *old;
207 
208                         child = qdisc_create_dflt(sch->dev_queue,
209                                                   &pfifo_qdisc_ops,
210                                                   TC_H_MAKE(sch->handle, i + 1));
211                         if (child) {
212                                 sch_tree_lock(sch);
213                                 old = q->queues[i];
214                                 q->queues[i] = child;
215 
216                                 if (old != &noop_qdisc) {
217                                         qdisc_tree_reduce_backlog(old,
218                                                                   old->q.qlen,
219                                                                   old->qstats.backlog);
220                                         qdisc_destroy(old);
221                                 }
222                                 sch_tree_unlock(sch);
223                         }
224                 }
225         }
226         return 0;
227 }
228 
229 static int prio_init(struct Qdisc *sch, struct nlattr *opt)
230 {
231         struct prio_sched_data *q = qdisc_priv(sch);
232         int i;
233 
234         for (i = 0; i < TCQ_PRIO_BANDS; i++)
235                 q->queues[i] = &noop_qdisc;
236 
237         if (opt == NULL) {
238                 return -EINVAL;
239         } else {
240                 int err;
241 
242                 if ((err = prio_tune(sch, opt)) != 0)
243                         return err;
244         }
245         return 0;
246 }
247 
248 static int prio_dump(struct Qdisc *sch, struct sk_buff *skb)
249 {
250         struct prio_sched_data *q = qdisc_priv(sch);
251         unsigned char *b = skb_tail_pointer(skb);
252         struct tc_prio_qopt opt;
253 
254         opt.bands = q->bands;
255         memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX + 1);
256 
257         if (nla_put(skb, TCA_OPTIONS, sizeof(opt), &opt))
258                 goto nla_put_failure;
259 
260         return skb->len;
261 
262 nla_put_failure:
263         nlmsg_trim(skb, b);
264         return -1;
265 }
266 
267 static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new,
268                       struct Qdisc **old)
269 {
270         struct prio_sched_data *q = qdisc_priv(sch);
271         unsigned long band = arg - 1;
272 
273         if (new == NULL)
274                 new = &noop_qdisc;
275 
276         *old = qdisc_replace(sch, new, &q->queues[band]);
277         return 0;
278 }
279 
280 static struct Qdisc *
281 prio_leaf(struct Qdisc *sch, unsigned long arg)
282 {
283         struct prio_sched_data *q = qdisc_priv(sch);
284         unsigned long band = arg - 1;
285 
286         return q->queues[band];
287 }
288 
289 static unsigned long prio_get(struct Qdisc *sch, u32 classid)
290 {
291         struct prio_sched_data *q = qdisc_priv(sch);
292         unsigned long band = TC_H_MIN(classid);
293 
294         if (band - 1 >= q->bands)
295                 return 0;
296         return band;
297 }
298 
299 static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
300 {
301         return prio_get(sch, classid);
302 }
303 
304 
305 static void prio_put(struct Qdisc *q, unsigned long cl)
306 {
307 }
308 
309 static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb,
310                            struct tcmsg *tcm)
311 {
312         struct prio_sched_data *q = qdisc_priv(sch);
313 
314         tcm->tcm_handle |= TC_H_MIN(cl);
315         tcm->tcm_info = q->queues[cl-1]->handle;
316         return 0;
317 }
318 
319 static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl,
320                                  struct gnet_dump *d)
321 {
322         struct prio_sched_data *q = qdisc_priv(sch);
323         struct Qdisc *cl_q;
324 
325         cl_q = q->queues[cl - 1];
326         if (gnet_stats_copy_basic(d, cl_q->cpu_bstats, &cl_q->bstats) < 0 ||
327             gnet_stats_copy_queue(d, NULL, &cl_q->qstats, cl_q->q.qlen) < 0)
328                 return -1;
329 
330         return 0;
331 }
332 
333 static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
334 {
335         struct prio_sched_data *q = qdisc_priv(sch);
336         int prio;
337 
338         if (arg->stop)
339                 return;
340 
341         for (prio = 0; prio < q->bands; prio++) {
342                 if (arg->count < arg->skip) {
343                         arg->count++;
344                         continue;
345                 }
346                 if (arg->fn(sch, prio + 1, arg) < 0) {
347                         arg->stop = 1;
348                         break;
349                 }
350                 arg->count++;
351         }
352 }
353 
354 static struct tcf_proto __rcu **prio_find_tcf(struct Qdisc *sch,
355                                               unsigned long cl)
356 {
357         struct prio_sched_data *q = qdisc_priv(sch);
358 
359         if (cl)
360                 return NULL;
361         return &q->filter_list;
362 }
363 
364 static const struct Qdisc_class_ops prio_class_ops = {
365         .graft          =       prio_graft,
366         .leaf           =       prio_leaf,
367         .get            =       prio_get,
368         .put            =       prio_put,
369         .walk           =       prio_walk,
370         .tcf_chain      =       prio_find_tcf,
371         .bind_tcf       =       prio_bind,
372         .unbind_tcf     =       prio_put,
373         .dump           =       prio_dump_class,
374         .dump_stats     =       prio_dump_class_stats,
375 };
376 
377 static struct Qdisc_ops prio_qdisc_ops __read_mostly = {
378         .next           =       NULL,
379         .cl_ops         =       &prio_class_ops,
380         .id             =       "prio",
381         .priv_size      =       sizeof(struct prio_sched_data),
382         .enqueue        =       prio_enqueue,
383         .dequeue        =       prio_dequeue,
384         .peek           =       prio_peek,
385         .drop           =       prio_drop,
386         .init           =       prio_init,
387         .reset          =       prio_reset,
388         .destroy        =       prio_destroy,
389         .change         =       prio_tune,
390         .dump           =       prio_dump,
391         .owner          =       THIS_MODULE,
392 };
393 
394 static int __init prio_module_init(void)
395 {
396         return register_qdisc(&prio_qdisc_ops);
397 }
398 
399 static void __exit prio_module_exit(void)
400 {
401         unregister_qdisc(&prio_qdisc_ops);
402 }
403 
404 module_init(prio_module_init)
405 module_exit(prio_module_exit)
406 
407 MODULE_LICENSE("GPL");
408 

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