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

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

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

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