1 /* net/sched/sch_dsmark.c - Differentiated Services field marker */
3 /* Written 1998-2000 by Werner Almesberger, EPFL ICA */
6 #include <linux/config.h>
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/types.h>
10 #include <linux/string.h>
11 #include <linux/errno.h>
12 #include <linux/skbuff.h>
13 #include <linux/netdevice.h> /* for pkt_sched */
14 #include <linux/rtnetlink.h>
15 #include <net/pkt_sched.h>
16 #include <net/dsfield.h>
17 #include <net/inet_ecn.h>
18 #include <asm/byteorder.h>
22 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
24 #define DPRINTK(format,args...)
28 #define D2PRINTK(format,args...) printk(KERN_DEBUG format,##args)
30 #define D2PRINTK(format,args...)
34 #define PRIV(sch) qdisc_priv(sch)
38 * classid class marking
39 * ------- ----- -------
43 * x:y y>0 y+1 use entry [y]
45 * x:indices-1 indices use entry [indices-1]
47 * x:y y+1 use entry [y & (indices-1)]
49 * 0xffff 0x10000 use entry [indices-1]
53 #define NO_DEFAULT_INDEX (1 << 16)
55 struct dsmark_qdisc_data
{
57 struct tcf_proto
*filter_list
;
58 __u8
*mask
; /* "owns" the array */
61 __u32 default_index
; /* index range is 0...0xffff */
65 static inline int dsmark_valid_indices(u16 indices
)
67 while (indices
!= 1) {
76 static inline int dsmark_valid_index(struct dsmark_qdisc_data
*p
, u16 index
)
78 return (index
<= p
->indices
&& index
> 0);
81 /* ------------------------- Class/flow operations ------------------------- */
84 static int dsmark_graft(struct Qdisc
*sch
,unsigned long arg
,
85 struct Qdisc
*new,struct Qdisc
**old
)
87 struct dsmark_qdisc_data
*p
= PRIV(sch
);
89 DPRINTK("dsmark_graft(sch %p,[qdisc %p],new %p,old %p)\n",sch
,p
,new,
93 new = qdisc_create_dflt(sch
->dev
, &pfifo_qdisc_ops
);
99 *old
= xchg(&p
->q
,new);
103 sch_tree_unlock(sch
); /* @@@ move up ? */
108 static struct Qdisc
*dsmark_leaf(struct Qdisc
*sch
, unsigned long arg
)
110 struct dsmark_qdisc_data
*p
= PRIV(sch
);
116 static unsigned long dsmark_get(struct Qdisc
*sch
,u32 classid
)
118 struct dsmark_qdisc_data
*p
__attribute__((unused
)) = PRIV(sch
);
120 DPRINTK("dsmark_get(sch %p,[qdisc %p],classid %x)\n",sch
,p
,classid
);
121 return TC_H_MIN(classid
)+1;
125 static unsigned long dsmark_bind_filter(struct Qdisc
*sch
,
126 unsigned long parent
, u32 classid
)
128 return dsmark_get(sch
,classid
);
132 static void dsmark_put(struct Qdisc
*sch
, unsigned long cl
)
137 static int dsmark_change(struct Qdisc
*sch
, u32 classid
, u32 parent
,
138 struct rtattr
**tca
, unsigned long *arg
)
140 struct dsmark_qdisc_data
*p
= PRIV(sch
);
141 struct rtattr
*opt
= tca
[TCA_OPTIONS
-1];
142 struct rtattr
*tb
[TCA_DSMARK_MAX
];
146 DPRINTK("dsmark_change(sch %p,[qdisc %p],classid %x,parent %x),"
147 "arg 0x%lx\n", sch
, p
, classid
, parent
, *arg
);
149 if (!dsmark_valid_index(p
, *arg
)) {
154 if (!opt
|| rtattr_parse_nested(tb
, TCA_DSMARK_MAX
, opt
))
157 if (tb
[TCA_DSMARK_MASK
-1])
158 mask
= RTA_GET_U8(tb
[TCA_DSMARK_MASK
-1]);
160 if (tb
[TCA_DSMARK_VALUE
-1])
161 p
->value
[*arg
-1] = RTA_GET_U8(tb
[TCA_DSMARK_VALUE
-1]);
163 if (tb
[TCA_DSMARK_MASK
-1])
164 p
->mask
[*arg
-1] = mask
;
172 static int dsmark_delete(struct Qdisc
*sch
,unsigned long arg
)
174 struct dsmark_qdisc_data
*p
= PRIV(sch
);
176 if (!arg
|| arg
> p
->indices
)
178 p
->mask
[arg
-1] = 0xff;
184 static void dsmark_walk(struct Qdisc
*sch
,struct qdisc_walker
*walker
)
186 struct dsmark_qdisc_data
*p
= PRIV(sch
);
189 DPRINTK("dsmark_walk(sch %p,[qdisc %p],walker %p)\n",sch
,p
,walker
);
192 for (i
= 0; i
< p
->indices
; i
++) {
193 if (p
->mask
[i
] == 0xff && !p
->value
[i
])
195 if (walker
->count
>= walker
->skip
) {
196 if (walker
->fn(sch
, i
+1, walker
) < 0) {
207 static struct tcf_proto
**dsmark_find_tcf(struct Qdisc
*sch
,unsigned long cl
)
209 struct dsmark_qdisc_data
*p
= PRIV(sch
);
211 return &p
->filter_list
;
215 /* --------------------------- Qdisc operations ---------------------------- */
218 static int dsmark_enqueue(struct sk_buff
*skb
,struct Qdisc
*sch
)
220 struct dsmark_qdisc_data
*p
= PRIV(sch
);
221 struct tcf_result res
;
223 int ret
= NET_XMIT_POLICED
;
225 D2PRINTK("dsmark_enqueue(skb %p,sch %p,[qdisc %p])\n",skb
,sch
,p
);
226 if (p
->set_tc_index
) {
227 /* FIXME: Safe with non-linear skbs? --RR */
228 switch (skb
->protocol
) {
229 case __constant_htons(ETH_P_IP
):
230 skb
->tc_index
= ipv4_get_dsfield(skb
->nh
.iph
)
233 case __constant_htons(ETH_P_IPV6
):
234 skb
->tc_index
= ipv6_get_dsfield(skb
->nh
.ipv6h
)
242 result
= TC_POLICE_OK
; /* be nice to gcc */
243 if (TC_H_MAJ(skb
->priority
) == sch
->handle
) {
244 skb
->tc_index
= TC_H_MIN(skb
->priority
);
246 result
= tc_classify(skb
,p
->filter_list
,&res
);
247 D2PRINTK("result %d class 0x%04x\n",result
,res
.classid
);
249 #ifdef CONFIG_NET_CLS_POLICE
254 case TC_POLICE_RECLASSIFY
:
255 /* FIXME: what to do here ??? */
259 skb
->tc_index
= TC_H_MIN(res
.classid
);
261 case TC_POLICE_UNSPEC
:
264 if (p
->default_index
!= NO_DEFAULT_INDEX
)
265 skb
->tc_index
= p
->default_index
;
270 #ifdef CONFIG_NET_CLS_POLICE
271 result
== TC_POLICE_SHOT
||
274 ((ret
= p
->q
->enqueue(skb
,p
->q
)) != 0)) {
278 sch
->bstats
.bytes
+= skb
->len
;
279 sch
->bstats
.packets
++;
285 static struct sk_buff
*dsmark_dequeue(struct Qdisc
*sch
)
287 struct dsmark_qdisc_data
*p
= PRIV(sch
);
291 D2PRINTK("dsmark_dequeue(sch %p,[qdisc %p])\n",sch
,p
);
292 skb
= p
->q
->ops
->dequeue(p
->q
);
296 index
= skb
->tc_index
& (p
->indices
-1);
297 D2PRINTK("index %d->%d\n",skb
->tc_index
,index
);
298 switch (skb
->protocol
) {
299 case __constant_htons(ETH_P_IP
):
300 ipv4_change_dsfield(skb
->nh
.iph
,
301 p
->mask
[index
],p
->value
[index
]);
303 case __constant_htons(ETH_P_IPV6
):
304 ipv6_change_dsfield(skb
->nh
.ipv6h
,
305 p
->mask
[index
],p
->value
[index
]);
309 * Only complain if a change was actually attempted.
310 * This way, we can send non-IP traffic through dsmark
311 * and don't need yet another qdisc as a bypass.
313 if (p
->mask
[index
] != 0xff || p
->value
[index
])
314 printk(KERN_WARNING
"dsmark_dequeue: "
315 "unsupported protocol %d\n",
316 htons(skb
->protocol
));
323 static int dsmark_requeue(struct sk_buff
*skb
,struct Qdisc
*sch
)
326 struct dsmark_qdisc_data
*p
= PRIV(sch
);
328 D2PRINTK("dsmark_requeue(skb %p,sch %p,[qdisc %p])\n",skb
,sch
,p
);
329 if ((ret
= p
->q
->ops
->requeue(skb
, p
->q
)) == 0) {
331 sch
->qstats
.requeues
++;
339 static unsigned int dsmark_drop(struct Qdisc
*sch
)
341 struct dsmark_qdisc_data
*p
= PRIV(sch
);
344 DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n",sch
,p
);
345 if (!p
->q
->ops
->drop
)
347 if (!(len
= p
->q
->ops
->drop(p
->q
)))
354 static int dsmark_init(struct Qdisc
*sch
, struct rtattr
*opt
)
356 struct dsmark_qdisc_data
*p
= PRIV(sch
);
357 struct rtattr
*tb
[TCA_DSMARK_MAX
];
359 u32 default_index
= NO_DEFAULT_INDEX
;
363 DPRINTK("dsmark_init(sch %p,[qdisc %p],opt %p)\n", sch
, p
, opt
);
365 if (!opt
|| rtattr_parse_nested(tb
, TCA_DSMARK_MAX
, opt
) < 0)
368 indices
= RTA_GET_U16(tb
[TCA_DSMARK_INDICES
-1]);
369 if (!indices
|| !dsmark_valid_indices(indices
))
372 if (tb
[TCA_DSMARK_DEFAULT_INDEX
-1])
373 default_index
= RTA_GET_U16(tb
[TCA_DSMARK_DEFAULT_INDEX
-1]);
375 mask
= kmalloc(indices
* 2, GFP_KERNEL
);
382 memset(p
->mask
, 0xff, indices
);
384 p
->value
= p
->mask
+ indices
;
385 memset(p
->value
, 0, indices
);
387 p
->indices
= indices
;
388 p
->default_index
= default_index
;
389 p
->set_tc_index
= RTA_GET_FLAG(tb
[TCA_DSMARK_SET_TC_INDEX
-1]);
391 p
->q
= qdisc_create_dflt(sch
->dev
, &pfifo_qdisc_ops
);
395 DPRINTK("dsmark_init: qdisc %p\n", p
->q
);
404 static void dsmark_reset(struct Qdisc
*sch
)
406 struct dsmark_qdisc_data
*p
= PRIV(sch
);
408 DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n",sch
,p
);
414 static void dsmark_destroy(struct Qdisc
*sch
)
416 struct dsmark_qdisc_data
*p
= PRIV(sch
);
417 struct tcf_proto
*tp
;
419 DPRINTK("dsmark_destroy(sch %p,[qdisc %p])\n",sch
,p
);
420 while (p
->filter_list
) {
422 p
->filter_list
= tp
->next
;
430 static int dsmark_dump_class(struct Qdisc
*sch
, unsigned long cl
,
431 struct sk_buff
*skb
, struct tcmsg
*tcm
)
433 struct dsmark_qdisc_data
*p
= PRIV(sch
);
434 struct rtattr
*opts
= NULL
;
436 DPRINTK("dsmark_dump_class(sch %p,[qdisc %p],class %ld\n", sch
, p
, cl
);
438 if (!dsmark_valid_index(p
, cl
))
441 tcm
->tcm_handle
= TC_H_MAKE(TC_H_MAJ(sch
->handle
), cl
-1);
443 opts
= RTA_NEST(skb
, TCA_OPTIONS
);
444 RTA_PUT_U8(skb
,TCA_DSMARK_MASK
, p
->mask
[cl
-1]);
445 RTA_PUT_U8(skb
,TCA_DSMARK_VALUE
, p
->value
[cl
-1]);
447 return RTA_NEST_END(skb
, opts
);
450 return RTA_NEST_CANCEL(skb
, opts
);
453 static int dsmark_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
455 struct dsmark_qdisc_data
*p
= PRIV(sch
);
456 struct rtattr
*opts
= NULL
;
458 opts
= RTA_NEST(skb
, TCA_OPTIONS
);
459 RTA_PUT_U16(skb
, TCA_DSMARK_INDICES
, p
->indices
);
461 if (p
->default_index
!= NO_DEFAULT_INDEX
)
462 RTA_PUT_U16(skb
, TCA_DSMARK_DEFAULT_INDEX
, p
->default_index
);
465 RTA_PUT_FLAG(skb
, TCA_DSMARK_SET_TC_INDEX
);
467 return RTA_NEST_END(skb
, opts
);
470 return RTA_NEST_CANCEL(skb
, opts
);
473 static struct Qdisc_class_ops dsmark_class_ops
= {
474 .graft
= dsmark_graft
,
478 .change
= dsmark_change
,
479 .delete = dsmark_delete
,
481 .tcf_chain
= dsmark_find_tcf
,
482 .bind_tcf
= dsmark_bind_filter
,
483 .unbind_tcf
= dsmark_put
,
484 .dump
= dsmark_dump_class
,
487 static struct Qdisc_ops dsmark_qdisc_ops
= {
489 .cl_ops
= &dsmark_class_ops
,
491 .priv_size
= sizeof(struct dsmark_qdisc_data
),
492 .enqueue
= dsmark_enqueue
,
493 .dequeue
= dsmark_dequeue
,
494 .requeue
= dsmark_requeue
,
497 .reset
= dsmark_reset
,
498 .destroy
= dsmark_destroy
,
501 .owner
= THIS_MODULE
,
504 static int __init
dsmark_module_init(void)
506 return register_qdisc(&dsmark_qdisc_ops
);
508 static void __exit
dsmark_module_exit(void)
510 unregister_qdisc(&dsmark_qdisc_ops
);
512 module_init(dsmark_module_init
)
513 module_exit(dsmark_module_exit
)
514 MODULE_LICENSE("GPL");