1 /* net/sched/sch_dsmark.c - Differentiated Services field marker */
3 /* Written 1998-2000 by Werner Almesberger, EPFL ICA */
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>
21 * classid class marking
22 * ------- ----- -------
26 * x:y y>0 y+1 use entry [y]
28 * x:indices-1 indices use entry [indices-1]
30 * x:y y+1 use entry [y & (indices-1)]
32 * 0xffff 0x10000 use entry [indices-1]
36 #define NO_DEFAULT_INDEX (1 << 16)
43 struct dsmark_qdisc_data
{
45 struct tcf_proto __rcu
*filter_list
;
46 struct mask_value
*mv
;
49 u32 default_index
; /* index range is 0...0xffff */
50 #define DSMARK_EMBEDDED_SZ 16
51 struct mask_value embedded
[DSMARK_EMBEDDED_SZ
];
54 static inline int dsmark_valid_index(struct dsmark_qdisc_data
*p
, u16 index
)
56 return index
<= p
->indices
&& index
> 0;
59 /* ------------------------- Class/flow operations ------------------------- */
61 static int dsmark_graft(struct Qdisc
*sch
, unsigned long arg
,
62 struct Qdisc
*new, struct Qdisc
**old
)
64 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
66 pr_debug("%s(sch %p,[qdisc %p],new %p,old %p)\n",
67 __func__
, sch
, p
, new, old
);
70 new = qdisc_create_dflt(sch
->dev_queue
, &pfifo_qdisc_ops
,
76 *old
= qdisc_replace(sch
, new, &p
->q
);
80 static struct Qdisc
*dsmark_leaf(struct Qdisc
*sch
, unsigned long arg
)
82 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
86 static unsigned long dsmark_get(struct Qdisc
*sch
, u32 classid
)
88 pr_debug("%s(sch %p,[qdisc %p],classid %x)\n",
89 __func__
, sch
, qdisc_priv(sch
), classid
);
91 return TC_H_MIN(classid
) + 1;
94 static unsigned long dsmark_bind_filter(struct Qdisc
*sch
,
95 unsigned long parent
, u32 classid
)
97 return dsmark_get(sch
, classid
);
100 static void dsmark_put(struct Qdisc
*sch
, unsigned long cl
)
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
},
112 static int dsmark_change(struct Qdisc
*sch
, u32 classid
, u32 parent
,
113 struct nlattr
**tca
, unsigned long *arg
)
115 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
116 struct nlattr
*opt
= tca
[TCA_OPTIONS
];
117 struct nlattr
*tb
[TCA_DSMARK_MAX
+ 1];
120 pr_debug("%s(sch %p,[qdisc %p],classid %x,parent %x), arg 0x%lx\n",
121 __func__
, sch
, p
, classid
, parent
, *arg
);
123 if (!dsmark_valid_index(p
, *arg
)) {
131 err
= nla_parse_nested(tb
, TCA_DSMARK_MAX
, opt
, dsmark_policy
);
135 if (tb
[TCA_DSMARK_VALUE
])
136 p
->mv
[*arg
- 1].value
= nla_get_u8(tb
[TCA_DSMARK_VALUE
]);
138 if (tb
[TCA_DSMARK_MASK
])
139 p
->mv
[*arg
- 1].mask
= nla_get_u8(tb
[TCA_DSMARK_MASK
]);
147 static int dsmark_delete(struct Qdisc
*sch
, unsigned long arg
)
149 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
151 if (!dsmark_valid_index(p
, arg
))
154 p
->mv
[arg
- 1].mask
= 0xff;
155 p
->mv
[arg
- 1].value
= 0;
160 static void dsmark_walk(struct Qdisc
*sch
, struct qdisc_walker
*walker
)
162 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
165 pr_debug("%s(sch %p,[qdisc %p],walker %p)\n",
166 __func__
, sch
, p
, walker
);
171 for (i
= 0; i
< p
->indices
; i
++) {
172 if (p
->mv
[i
].mask
== 0xff && !p
->mv
[i
].value
)
174 if (walker
->count
>= walker
->skip
) {
175 if (walker
->fn(sch
, i
+ 1, walker
) < 0) {
185 static inline struct tcf_proto __rcu
**dsmark_find_tcf(struct Qdisc
*sch
,
188 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
189 return &p
->filter_list
;
192 /* --------------------------- Qdisc operations ---------------------------- */
194 static int dsmark_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
196 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
199 pr_debug("%s(skb %p,sch %p,[qdisc %p])\n", __func__
, skb
, sch
, p
);
201 if (p
->set_tc_index
) {
202 int wlen
= skb_network_offset(skb
);
204 switch (tc_skb_protocol(skb
)) {
205 case htons(ETH_P_IP
):
206 wlen
+= sizeof(struct iphdr
);
207 if (!pskb_may_pull(skb
, wlen
) ||
208 skb_try_make_writable(skb
, wlen
))
211 skb
->tc_index
= ipv4_get_dsfield(ip_hdr(skb
))
215 case htons(ETH_P_IPV6
):
216 wlen
+= sizeof(struct ipv6hdr
);
217 if (!pskb_may_pull(skb
, wlen
) ||
218 skb_try_make_writable(skb
, wlen
))
221 skb
->tc_index
= ipv6_get_dsfield(ipv6_hdr(skb
))
230 if (TC_H_MAJ(skb
->priority
) == sch
->handle
)
231 skb
->tc_index
= TC_H_MIN(skb
->priority
);
233 struct tcf_result res
;
234 struct tcf_proto
*fl
= rcu_dereference_bh(p
->filter_list
);
235 int result
= tc_classify(skb
, fl
, &res
, false);
237 pr_debug("result %d class 0x%04x\n", result
, res
.classid
);
240 #ifdef CONFIG_NET_CLS_ACT
244 return NET_XMIT_SUCCESS
| __NET_XMIT_STOLEN
;
250 skb
->tc_index
= TC_H_MIN(res
.classid
);
254 if (p
->default_index
!= NO_DEFAULT_INDEX
)
255 skb
->tc_index
= p
->default_index
;
260 err
= qdisc_enqueue(skb
, p
->q
);
261 if (err
!= NET_XMIT_SUCCESS
) {
262 if (net_xmit_drop_count(err
))
263 qdisc_qstats_drop(sch
);
267 qdisc_qstats_backlog_inc(sch
, skb
);
270 return NET_XMIT_SUCCESS
;
273 qdisc_drop(skb
, sch
);
274 return NET_XMIT_SUCCESS
| __NET_XMIT_BYPASS
;
277 static struct sk_buff
*dsmark_dequeue(struct Qdisc
*sch
)
279 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
283 pr_debug("%s(sch %p,[qdisc %p])\n", __func__
, sch
, p
);
285 skb
= p
->q
->ops
->dequeue(p
->q
);
289 qdisc_bstats_update(sch
, skb
);
290 qdisc_qstats_backlog_dec(sch
, skb
);
293 index
= skb
->tc_index
& (p
->indices
- 1);
294 pr_debug("index %d->%d\n", skb
->tc_index
, index
);
296 switch (tc_skb_protocol(skb
)) {
297 case htons(ETH_P_IP
):
298 ipv4_change_dsfield(ip_hdr(skb
), p
->mv
[index
].mask
,
301 case htons(ETH_P_IPV6
):
302 ipv6_change_dsfield(ipv6_hdr(skb
), p
->mv
[index
].mask
,
307 * Only complain if a change was actually attempted.
308 * This way, we can send non-IP traffic through dsmark
309 * and don't need yet another qdisc as a bypass.
311 if (p
->mv
[index
].mask
!= 0xff || p
->mv
[index
].value
)
312 pr_warn("%s: unsupported protocol %d\n",
313 __func__
, ntohs(tc_skb_protocol(skb
)));
320 static struct sk_buff
*dsmark_peek(struct Qdisc
*sch
)
322 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
324 pr_debug("%s(sch %p,[qdisc %p])\n", __func__
, sch
, p
);
326 return p
->q
->ops
->peek(p
->q
);
329 static unsigned int dsmark_drop(struct Qdisc
*sch
)
331 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
334 pr_debug("%s(sch %p,[qdisc %p])\n", __func__
, sch
, p
);
336 if (p
->q
->ops
->drop
== NULL
)
339 len
= p
->q
->ops
->drop(p
->q
);
346 static int dsmark_init(struct Qdisc
*sch
, struct nlattr
*opt
)
348 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
349 struct nlattr
*tb
[TCA_DSMARK_MAX
+ 1];
351 u32 default_index
= NO_DEFAULT_INDEX
;
355 pr_debug("%s(sch %p,[qdisc %p],opt %p)\n", __func__
, sch
, p
, opt
);
360 err
= nla_parse_nested(tb
, TCA_DSMARK_MAX
, opt
, dsmark_policy
);
365 indices
= nla_get_u16(tb
[TCA_DSMARK_INDICES
]);
367 if (hweight32(indices
) != 1)
370 if (tb
[TCA_DSMARK_DEFAULT_INDEX
])
371 default_index
= nla_get_u16(tb
[TCA_DSMARK_DEFAULT_INDEX
]);
373 if (indices
<= DSMARK_EMBEDDED_SZ
)
376 p
->mv
= kmalloc_array(indices
, sizeof(*p
->mv
), GFP_KERNEL
);
381 for (i
= 0; i
< indices
; i
++) {
382 p
->mv
[i
].mask
= 0xff;
385 p
->indices
= indices
;
386 p
->default_index
= default_index
;
387 p
->set_tc_index
= nla_get_flag(tb
[TCA_DSMARK_SET_TC_INDEX
]);
389 p
->q
= qdisc_create_dflt(sch
->dev_queue
, &pfifo_qdisc_ops
, sch
->handle
);
393 pr_debug("%s: qdisc %p\n", __func__
, p
->q
);
400 static void dsmark_reset(struct Qdisc
*sch
)
402 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
404 pr_debug("%s(sch %p,[qdisc %p])\n", __func__
, sch
, p
);
406 sch
->qstats
.backlog
= 0;
410 static void dsmark_destroy(struct Qdisc
*sch
)
412 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
414 pr_debug("%s(sch %p,[qdisc %p])\n", __func__
, sch
, p
);
416 tcf_destroy_chain(&p
->filter_list
);
418 if (p
->mv
!= p
->embedded
)
422 static int dsmark_dump_class(struct Qdisc
*sch
, unsigned long cl
,
423 struct sk_buff
*skb
, struct tcmsg
*tcm
)
425 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
426 struct nlattr
*opts
= NULL
;
428 pr_debug("%s(sch %p,[qdisc %p],class %ld\n", __func__
, sch
, p
, cl
);
430 if (!dsmark_valid_index(p
, cl
))
433 tcm
->tcm_handle
= TC_H_MAKE(TC_H_MAJ(sch
->handle
), cl
- 1);
434 tcm
->tcm_info
= p
->q
->handle
;
436 opts
= nla_nest_start(skb
, TCA_OPTIONS
);
438 goto nla_put_failure
;
439 if (nla_put_u8(skb
, TCA_DSMARK_MASK
, p
->mv
[cl
- 1].mask
) ||
440 nla_put_u8(skb
, TCA_DSMARK_VALUE
, p
->mv
[cl
- 1].value
))
441 goto nla_put_failure
;
443 return nla_nest_end(skb
, opts
);
446 nla_nest_cancel(skb
, opts
);
450 static int dsmark_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
452 struct dsmark_qdisc_data
*p
= qdisc_priv(sch
);
453 struct nlattr
*opts
= NULL
;
455 opts
= nla_nest_start(skb
, TCA_OPTIONS
);
457 goto nla_put_failure
;
458 if (nla_put_u16(skb
, TCA_DSMARK_INDICES
, p
->indices
))
459 goto nla_put_failure
;
461 if (p
->default_index
!= NO_DEFAULT_INDEX
&&
462 nla_put_u16(skb
, TCA_DSMARK_DEFAULT_INDEX
, p
->default_index
))
463 goto nla_put_failure
;
465 if (p
->set_tc_index
&&
466 nla_put_flag(skb
, TCA_DSMARK_SET_TC_INDEX
))
467 goto nla_put_failure
;
469 return nla_nest_end(skb
, opts
);
472 nla_nest_cancel(skb
, opts
);
476 static const struct Qdisc_class_ops dsmark_class_ops
= {
477 .graft
= dsmark_graft
,
481 .change
= dsmark_change
,
482 .delete = dsmark_delete
,
484 .tcf_chain
= dsmark_find_tcf
,
485 .bind_tcf
= dsmark_bind_filter
,
486 .unbind_tcf
= dsmark_put
,
487 .dump
= dsmark_dump_class
,
490 static struct Qdisc_ops dsmark_qdisc_ops __read_mostly
= {
492 .cl_ops
= &dsmark_class_ops
,
494 .priv_size
= sizeof(struct dsmark_qdisc_data
),
495 .enqueue
= dsmark_enqueue
,
496 .dequeue
= dsmark_dequeue
,
500 .reset
= dsmark_reset
,
501 .destroy
= dsmark_destroy
,
504 .owner
= THIS_MODULE
,
507 static int __init
dsmark_module_init(void)
509 return register_qdisc(&dsmark_qdisc_ops
);
512 static void __exit
dsmark_module_exit(void)
514 unregister_qdisc(&dsmark_qdisc_ops
);
517 module_init(dsmark_module_init
)
518 module_exit(dsmark_module_exit
)
520 MODULE_LICENSE("GPL");