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

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

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ 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.82 ] ~ [ 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 /* net/sched/sch_dsmark.c - Differentiated Services field marker */
  2 
  3 /* Written 1998-2000 by Werner Almesberger, EPFL ICA */
  4 
  5 
  6 #include <linux/module.h>
  7 #include <linux/init.h>
  8 #include <linux/slab.h>
  9 #include <linux/types.h>
 10 #include <linux/string.h>
 11 #include <linux/errno.h>
 12 #include <linux/skbuff.h>
 13 #include <linux/rtnetlink.h>
 14 #include <linux/bitops.h>
 15 #include <net/pkt_sched.h>
 16 #include <net/dsfield.h>
 17 #include <net/inet_ecn.h>
 18 #include <asm/byteorder.h>
 19 
 20 /*
 21  * classid      class           marking
 22  * -------      -----           -------
 23  *   n/a          0             n/a
 24  *   x:0          1             use entry [0]
 25  *   ...         ...            ...
 26  *   x:y y>0     y+1            use entry [y]
 27  *   ...         ...            ...
 28  * x:indices-1  indices         use entry [indices-1]
 29  *   ...         ...            ...
 30  *   x:y         y+1            use entry [y & (indices-1)]
 31  *   ...         ...            ...
 32  * 0xffff       0x10000         use entry [indices-1]
 33  */
 34 
 35 
 36 #define NO_DEFAULT_INDEX        (1 << 16)
 37 
 38 struct mask_value {
 39         u8                      mask;
 40         u8                      value;
 41 };
 42 
 43 struct dsmark_qdisc_data {
 44         struct Qdisc            *q;
 45         struct tcf_proto __rcu  *filter_list;
 46         struct mask_value       *mv;
 47         u16                     indices;
 48         u8                      set_tc_index;
 49         u32                     default_index;  /* index range is 0...0xffff */
 50 #define DSMARK_EMBEDDED_SZ      16
 51         struct mask_value       embedded[DSMARK_EMBEDDED_SZ];
 52 };
 53 
 54 static inline int dsmark_valid_index(struct dsmark_qdisc_data *p, u16 index)
 55 {
 56         return index <= p->indices && index > 0;
 57 }
 58 
 59 /* ------------------------- Class/flow operations ------------------------- */
 60 
 61 static int dsmark_graft(struct Qdisc *sch, unsigned long arg,
 62                         struct Qdisc *new, struct Qdisc **old)
 63 {
 64         struct dsmark_qdisc_data *p = qdisc_priv(sch);
 65 
 66         pr_debug("%s(sch %p,[qdisc %p],new %p,old %p)\n",
 67                  __func__, sch, p, new, old);
 68 
 69         if (new == NULL) {
 70                 new = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,
 71                                         sch->handle);
 72                 if (new == NULL)
 73                         new = &noop_qdisc;
 74         }
 75 
 76         *old = qdisc_replace(sch, new, &p->q);
 77         return 0;
 78 }
 79 
 80 static struct Qdisc *dsmark_leaf(struct Qdisc *sch, unsigned long arg)
 81 {
 82         struct dsmark_qdisc_data *p = qdisc_priv(sch);
 83         return p->q;
 84 }
 85 
 86 static unsigned long dsmark_get(struct Qdisc *sch, u32 classid)
 87 {
 88         pr_debug("%s(sch %p,[qdisc %p],classid %x)\n",
 89                  __func__, sch, qdisc_priv(sch), classid);
 90 
 91         return TC_H_MIN(classid) + 1;
 92 }
 93 
 94 static unsigned long dsmark_bind_filter(struct Qdisc *sch,
 95                                         unsigned long parent, u32 classid)
 96 {
 97         return dsmark_get(sch, classid);
 98 }
 99 
100 static void dsmark_put(struct Qdisc *sch, unsigned long cl)
101 {
102 }
103 
104 static const struct nla_policy dsmark_policy[TCA_DSMARK_MAX + 1] = {
105         [TCA_DSMARK_INDICES]            = { .type = NLA_U16 },
106         [TCA_DSMARK_DEFAULT_INDEX]      = { .type = NLA_U16 },
107         [TCA_DSMARK_SET_TC_INDEX]       = { .type = NLA_FLAG },
108         [TCA_DSMARK_MASK]               = { .type = NLA_U8 },
109         [TCA_DSMARK_VALUE]              = { .type = NLA_U8 },
110 };
111 
112 static int dsmark_change(struct Qdisc *sch, u32 classid, u32 parent,
113                          struct nlattr **tca, unsigned long *arg)
114 {
115         struct dsmark_qdisc_data *p = qdisc_priv(sch);
116         struct nlattr *opt = tca[TCA_OPTIONS];
117         struct nlattr *tb[TCA_DSMARK_MAX + 1];
118         int err = -EINVAL;
119 
120         pr_debug("%s(sch %p,[qdisc %p],classid %x,parent %x), arg 0x%lx\n",
121                  __func__, sch, p, classid, parent, *arg);
122 
123         if (!dsmark_valid_index(p, *arg)) {
124                 err = -ENOENT;
125                 goto errout;
126         }
127 
128         if (!opt)
129                 goto errout;
130 
131         err = nla_parse_nested(tb, TCA_DSMARK_MAX, opt, dsmark_policy);
132         if (err < 0)
133                 goto errout;
134 
135         if (tb[TCA_DSMARK_VALUE])
136                 p->mv[*arg - 1].value = nla_get_u8(tb[TCA_DSMARK_VALUE]);
137 
138         if (tb[TCA_DSMARK_MASK])
139                 p->mv[*arg - 1].mask = nla_get_u8(tb[TCA_DSMARK_MASK]);
140 
141         err = 0;
142 
143 errout:
144         return err;
145 }
146 
147 static int dsmark_delete(struct Qdisc *sch, unsigned long arg)
148 {
149         struct dsmark_qdisc_data *p = qdisc_priv(sch);
150 
151         if (!dsmark_valid_index(p, arg))
152                 return -EINVAL;
153 
154         p->mv[arg - 1].mask = 0xff;
155         p->mv[arg - 1].value = 0;
156 
157         return 0;
158 }
159 
160 static void dsmark_walk(struct Qdisc *sch, struct qdisc_walker *walker)
161 {
162         struct dsmark_qdisc_data *p = qdisc_priv(sch);
163         int i;
164 
165         pr_debug("%s(sch %p,[qdisc %p],walker %p)\n",
166                  __func__, sch, p, walker);
167 
168         if (walker->stop)
169                 return;
170 
171         for (i = 0; i < p->indices; i++) {
172                 if (p->mv[i].mask == 0xff && !p->mv[i].value)
173                         goto ignore;
174                 if (walker->count >= walker->skip) {
175                         if (walker->fn(sch, i + 1, walker) < 0) {
176                                 walker->stop = 1;
177                                 break;
178                         }
179                 }
180 ignore:
181                 walker->count++;
182         }
183 }
184 
185 static inline struct tcf_proto __rcu **dsmark_find_tcf(struct Qdisc *sch,
186                                                        unsigned long cl)
187 {
188         struct dsmark_qdisc_data *p = qdisc_priv(sch);
189         return &p->filter_list;
190 }
191 
192 /* --------------------------- Qdisc operations ---------------------------- */
193 
194 static int dsmark_enqueue(struct sk_buff *skb, struct Qdisc *sch)
195 {
196         struct dsmark_qdisc_data *p = qdisc_priv(sch);
197         int err;
198 
199         pr_debug("%s(skb %p,sch %p,[qdisc %p])\n", __func__, skb, sch, p);
200 
201         if (p->set_tc_index) {
202                 switch (tc_skb_protocol(skb)) {
203                 case htons(ETH_P_IP):
204                         if (skb_cow_head(skb, sizeof(struct iphdr)))
205                                 goto drop;
206 
207                         skb->tc_index = ipv4_get_dsfield(ip_hdr(skb))
208                                 & ~INET_ECN_MASK;
209                         break;
210 
211                 case htons(ETH_P_IPV6):
212                         if (skb_cow_head(skb, sizeof(struct ipv6hdr)))
213                                 goto drop;
214 
215                         skb->tc_index = ipv6_get_dsfield(ipv6_hdr(skb))
216                                 & ~INET_ECN_MASK;
217                         break;
218                 default:
219                         skb->tc_index = 0;
220                         break;
221                 }
222         }
223 
224         if (TC_H_MAJ(skb->priority) == sch->handle)
225                 skb->tc_index = TC_H_MIN(skb->priority);
226         else {
227                 struct tcf_result res;
228                 struct tcf_proto *fl = rcu_dereference_bh(p->filter_list);
229                 int result = tc_classify(skb, fl, &res, false);
230 
231                 pr_debug("result %d class 0x%04x\n", result, res.classid);
232 
233                 switch (result) {
234 #ifdef CONFIG_NET_CLS_ACT
235                 case TC_ACT_QUEUED:
236                 case TC_ACT_STOLEN:
237                         kfree_skb(skb);
238                         return NET_XMIT_SUCCESS | __NET_XMIT_STOLEN;
239 
240                 case TC_ACT_SHOT:
241                         goto drop;
242 #endif
243                 case TC_ACT_OK:
244                         skb->tc_index = TC_H_MIN(res.classid);
245                         break;
246 
247                 default:
248                         if (p->default_index != NO_DEFAULT_INDEX)
249                                 skb->tc_index = p->default_index;
250                         break;
251                 }
252         }
253 
254         err = qdisc_enqueue(skb, p->q);
255         if (err != NET_XMIT_SUCCESS) {
256                 if (net_xmit_drop_count(err))
257                         qdisc_qstats_drop(sch);
258                 return err;
259         }
260 
261         qdisc_qstats_backlog_inc(sch, skb);
262         sch->q.qlen++;
263 
264         return NET_XMIT_SUCCESS;
265 
266 drop:
267         qdisc_drop(skb, sch);
268         return NET_XMIT_SUCCESS | __NET_XMIT_BYPASS;
269 }
270 
271 static struct sk_buff *dsmark_dequeue(struct Qdisc *sch)
272 {
273         struct dsmark_qdisc_data *p = qdisc_priv(sch);
274         struct sk_buff *skb;
275         u32 index;
276 
277         pr_debug("%s(sch %p,[qdisc %p])\n", __func__, sch, p);
278 
279         skb = qdisc_dequeue_peeked(p->q);
280         if (skb == NULL)
281                 return NULL;
282 
283         qdisc_bstats_update(sch, skb);
284         qdisc_qstats_backlog_dec(sch, skb);
285         sch->q.qlen--;
286 
287         index = skb->tc_index & (p->indices - 1);
288         pr_debug("index %d->%d\n", skb->tc_index, index);
289 
290         switch (tc_skb_protocol(skb)) {
291         case htons(ETH_P_IP):
292                 ipv4_change_dsfield(ip_hdr(skb), p->mv[index].mask,
293                                     p->mv[index].value);
294                         break;
295         case htons(ETH_P_IPV6):
296                 ipv6_change_dsfield(ipv6_hdr(skb), p->mv[index].mask,
297                                     p->mv[index].value);
298                         break;
299         default:
300                 /*
301                  * Only complain if a change was actually attempted.
302                  * This way, we can send non-IP traffic through dsmark
303                  * and don't need yet another qdisc as a bypass.
304                  */
305                 if (p->mv[index].mask != 0xff || p->mv[index].value)
306                         pr_warn("%s: unsupported protocol %d\n",
307                                 __func__, ntohs(tc_skb_protocol(skb)));
308                 break;
309         }
310 
311         return skb;
312 }
313 
314 static struct sk_buff *dsmark_peek(struct Qdisc *sch)
315 {
316         struct dsmark_qdisc_data *p = qdisc_priv(sch);
317 
318         pr_debug("%s(sch %p,[qdisc %p])\n", __func__, sch, p);
319 
320         return p->q->ops->peek(p->q);
321 }
322 
323 static unsigned int dsmark_drop(struct Qdisc *sch)
324 {
325         struct dsmark_qdisc_data *p = qdisc_priv(sch);
326         unsigned int len;
327 
328         pr_debug("%s(sch %p,[qdisc %p])\n", __func__, sch, p);
329 
330         if (p->q->ops->drop == NULL)
331                 return 0;
332 
333         len = p->q->ops->drop(p->q);
334         if (len)
335                 sch->q.qlen--;
336 
337         return len;
338 }
339 
340 static int dsmark_init(struct Qdisc *sch, struct nlattr *opt)
341 {
342         struct dsmark_qdisc_data *p = qdisc_priv(sch);
343         struct nlattr *tb[TCA_DSMARK_MAX + 1];
344         int err = -EINVAL;
345         u32 default_index = NO_DEFAULT_INDEX;
346         u16 indices;
347         int i;
348 
349         pr_debug("%s(sch %p,[qdisc %p],opt %p)\n", __func__, sch, p, opt);
350 
351         if (!opt)
352                 goto errout;
353 
354         err = nla_parse_nested(tb, TCA_DSMARK_MAX, opt, dsmark_policy);
355         if (err < 0)
356                 goto errout;
357 
358         err = -EINVAL;
359         indices = nla_get_u16(tb[TCA_DSMARK_INDICES]);
360 
361         if (hweight32(indices) != 1)
362                 goto errout;
363 
364         if (tb[TCA_DSMARK_DEFAULT_INDEX])
365                 default_index = nla_get_u16(tb[TCA_DSMARK_DEFAULT_INDEX]);
366 
367         if (indices <= DSMARK_EMBEDDED_SZ)
368                 p->mv = p->embedded;
369         else
370                 p->mv = kmalloc_array(indices, sizeof(*p->mv), GFP_KERNEL);
371         if (!p->mv) {
372                 err = -ENOMEM;
373                 goto errout;
374         }
375         for (i = 0; i < indices; i++) {
376                 p->mv[i].mask = 0xff;
377                 p->mv[i].value = 0;
378         }
379         p->indices = indices;
380         p->default_index = default_index;
381         p->set_tc_index = nla_get_flag(tb[TCA_DSMARK_SET_TC_INDEX]);
382 
383         p->q = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops, sch->handle);
384         if (p->q == NULL)
385                 p->q = &noop_qdisc;
386 
387         pr_debug("%s: qdisc %p\n", __func__, p->q);
388 
389         err = 0;
390 errout:
391         return err;
392 }
393 
394 static void dsmark_reset(struct Qdisc *sch)
395 {
396         struct dsmark_qdisc_data *p = qdisc_priv(sch);
397 
398         pr_debug("%s(sch %p,[qdisc %p])\n", __func__, sch, p);
399         qdisc_reset(p->q);
400         sch->qstats.backlog = 0;
401         sch->q.qlen = 0;
402 }
403 
404 static void dsmark_destroy(struct Qdisc *sch)
405 {
406         struct dsmark_qdisc_data *p = qdisc_priv(sch);
407 
408         pr_debug("%s(sch %p,[qdisc %p])\n", __func__, sch, p);
409 
410         tcf_destroy_chain(&p->filter_list);
411         qdisc_destroy(p->q);
412         if (p->mv != p->embedded)
413                 kfree(p->mv);
414 }
415 
416 static int dsmark_dump_class(struct Qdisc *sch, unsigned long cl,
417                              struct sk_buff *skb, struct tcmsg *tcm)
418 {
419         struct dsmark_qdisc_data *p = qdisc_priv(sch);
420         struct nlattr *opts = NULL;
421 
422         pr_debug("%s(sch %p,[qdisc %p],class %ld\n", __func__, sch, p, cl);
423 
424         if (!dsmark_valid_index(p, cl))
425                 return -EINVAL;
426 
427         tcm->tcm_handle = TC_H_MAKE(TC_H_MAJ(sch->handle), cl - 1);
428         tcm->tcm_info = p->q->handle;
429 
430         opts = nla_nest_start(skb, TCA_OPTIONS);
431         if (opts == NULL)
432                 goto nla_put_failure;
433         if (nla_put_u8(skb, TCA_DSMARK_MASK, p->mv[cl - 1].mask) ||
434             nla_put_u8(skb, TCA_DSMARK_VALUE, p->mv[cl - 1].value))
435                 goto nla_put_failure;
436 
437         return nla_nest_end(skb, opts);
438 
439 nla_put_failure:
440         nla_nest_cancel(skb, opts);
441         return -EMSGSIZE;
442 }
443 
444 static int dsmark_dump(struct Qdisc *sch, struct sk_buff *skb)
445 {
446         struct dsmark_qdisc_data *p = qdisc_priv(sch);
447         struct nlattr *opts = NULL;
448 
449         opts = nla_nest_start(skb, TCA_OPTIONS);
450         if (opts == NULL)
451                 goto nla_put_failure;
452         if (nla_put_u16(skb, TCA_DSMARK_INDICES, p->indices))
453                 goto nla_put_failure;
454 
455         if (p->default_index != NO_DEFAULT_INDEX &&
456             nla_put_u16(skb, TCA_DSMARK_DEFAULT_INDEX, p->default_index))
457                 goto nla_put_failure;
458 
459         if (p->set_tc_index &&
460             nla_put_flag(skb, TCA_DSMARK_SET_TC_INDEX))
461                 goto nla_put_failure;
462 
463         return nla_nest_end(skb, opts);
464 
465 nla_put_failure:
466         nla_nest_cancel(skb, opts);
467         return -EMSGSIZE;
468 }
469 
470 static const struct Qdisc_class_ops dsmark_class_ops = {
471         .graft          =       dsmark_graft,
472         .leaf           =       dsmark_leaf,
473         .get            =       dsmark_get,
474         .put            =       dsmark_put,
475         .change         =       dsmark_change,
476         .delete         =       dsmark_delete,
477         .walk           =       dsmark_walk,
478         .tcf_chain      =       dsmark_find_tcf,
479         .bind_tcf       =       dsmark_bind_filter,
480         .unbind_tcf     =       dsmark_put,
481         .dump           =       dsmark_dump_class,
482 };
483 
484 static struct Qdisc_ops dsmark_qdisc_ops __read_mostly = {
485         .next           =       NULL,
486         .cl_ops         =       &dsmark_class_ops,
487         .id             =       "dsmark",
488         .priv_size      =       sizeof(struct dsmark_qdisc_data),
489         .enqueue        =       dsmark_enqueue,
490         .dequeue        =       dsmark_dequeue,
491         .peek           =       dsmark_peek,
492         .drop           =       dsmark_drop,
493         .init           =       dsmark_init,
494         .reset          =       dsmark_reset,
495         .destroy        =       dsmark_destroy,
496         .change         =       NULL,
497         .dump           =       dsmark_dump,
498         .owner          =       THIS_MODULE,
499 };
500 
501 static int __init dsmark_module_init(void)
502 {
503         return register_qdisc(&dsmark_qdisc_ops);
504 }
505 
506 static void __exit dsmark_module_exit(void)
507 {
508         unregister_qdisc(&dsmark_qdisc_ops);
509 }
510 
511 module_init(dsmark_module_init)
512 module_exit(dsmark_module_exit)
513 
514 MODULE_LICENSE("GPL");
515 

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