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 <asm/byteorder.h>
21 #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
23 #define DPRINTK(format,args...)
27 #define D2PRINTK(format,args...) printk(KERN_DEBUG format,##args)
29 #define D2PRINTK(format,args...)
33 #define PRIV(sch) qdisc_priv(sch)
37 * classid class marking
38 * ------- ----- -------
42 * x:y y>0 y+1 use entry [y]
44 * x:indices-1 indices use entry [indices-1]
46 * x:y y+1 use entry [y & (indices-1)]
48 * 0xffff 0x10000 use entry [indices-1]
52 #define NO_DEFAULT_INDEX (1 << 16)
54 struct dsmark_qdisc_data
{
56 struct tcf_proto
*filter_list
;
57 __u8
*mask
; /* "owns" the array */
60 __u32 default_index
; /* index range is 0...0xffff */
65 /* ------------------------- Class/flow operations ------------------------- */
68 static int dsmark_graft(struct Qdisc
*sch
,unsigned long arg
,
69 struct Qdisc
*new,struct Qdisc
**old
)
71 struct dsmark_qdisc_data
*p
= PRIV(sch
);
73 DPRINTK("dsmark_graft(sch %p,[qdisc %p],new %p,old %p)\n",sch
,p
,new,
78 *old
= xchg(&p
->q
,new);
82 sch_tree_unlock(sch
); /* @@@ move up ? */
87 static struct Qdisc
*dsmark_leaf(struct Qdisc
*sch
, unsigned long arg
)
89 struct dsmark_qdisc_data
*p
= PRIV(sch
);
95 static unsigned long dsmark_get(struct Qdisc
*sch
,u32 classid
)
97 struct dsmark_qdisc_data
*p
__attribute__((unused
)) = PRIV(sch
);
99 DPRINTK("dsmark_get(sch %p,[qdisc %p],classid %x)\n",sch
,p
,classid
);
100 return TC_H_MIN(classid
)+1;
104 static unsigned long dsmark_bind_filter(struct Qdisc
*sch
,
105 unsigned long parent
, u32 classid
)
107 return dsmark_get(sch
,classid
);
111 static void dsmark_put(struct Qdisc
*sch
, unsigned long cl
)
116 static int dsmark_change(struct Qdisc
*sch
, u32 classid
, u32 parent
,
117 struct rtattr
**tca
, unsigned long *arg
)
119 struct dsmark_qdisc_data
*p
= PRIV(sch
);
120 struct rtattr
*opt
= tca
[TCA_OPTIONS
-1];
121 struct rtattr
*tb
[TCA_DSMARK_MAX
];
123 DPRINTK("dsmark_change(sch %p,[qdisc %p],classid %x,parent %x),"
124 "arg 0x%lx\n",sch
,p
,classid
,parent
,*arg
);
125 if (*arg
> p
->indices
)
127 if (!opt
|| rtattr_parse(tb
, TCA_DSMARK_MAX
, RTA_DATA(opt
),
130 if (tb
[TCA_DSMARK_MASK
-1]) {
131 if (!RTA_PAYLOAD(tb
[TCA_DSMARK_MASK
-1]))
133 p
->mask
[*arg
-1] = *(__u8
*) RTA_DATA(tb
[TCA_DSMARK_MASK
-1]);
135 if (tb
[TCA_DSMARK_VALUE
-1]) {
136 if (!RTA_PAYLOAD(tb
[TCA_DSMARK_VALUE
-1]))
138 p
->value
[*arg
-1] = *(__u8
*) RTA_DATA(tb
[TCA_DSMARK_VALUE
-1]);
144 static int dsmark_delete(struct Qdisc
*sch
,unsigned long arg
)
146 struct dsmark_qdisc_data
*p
= PRIV(sch
);
148 if (!arg
|| arg
> p
->indices
)
150 p
->mask
[arg
-1] = 0xff;
156 static void dsmark_walk(struct Qdisc
*sch
,struct qdisc_walker
*walker
)
158 struct dsmark_qdisc_data
*p
= PRIV(sch
);
161 DPRINTK("dsmark_walk(sch %p,[qdisc %p],walker %p)\n",sch
,p
,walker
);
164 for (i
= 0; i
< p
->indices
; i
++) {
165 if (p
->mask
[i
] == 0xff && !p
->value
[i
])
167 if (walker
->count
>= walker
->skip
) {
168 if (walker
->fn(sch
, i
+1, walker
) < 0) {
178 static struct tcf_proto
**dsmark_find_tcf(struct Qdisc
*sch
,unsigned long cl
)
180 struct dsmark_qdisc_data
*p
= PRIV(sch
);
182 return &p
->filter_list
;
186 /* --------------------------- Qdisc operations ---------------------------- */
189 static int dsmark_enqueue(struct sk_buff
*skb
,struct Qdisc
*sch
)
191 struct dsmark_qdisc_data
*p
= PRIV(sch
);
192 struct tcf_result res
;
194 int ret
= NET_XMIT_POLICED
;
196 D2PRINTK("dsmark_enqueue(skb %p,sch %p,[qdisc %p])\n",skb
,sch
,p
);
197 if (p
->set_tc_index
) {
198 /* FIXME: Safe with non-linear skbs? --RR */
199 switch (skb
->protocol
) {
200 case __constant_htons(ETH_P_IP
):
201 skb
->tc_index
= ipv4_get_dsfield(skb
->nh
.iph
);
203 case __constant_htons(ETH_P_IPV6
):
204 skb
->tc_index
= ipv6_get_dsfield(skb
->nh
.ipv6h
);
211 result
= TC_POLICE_OK
; /* be nice to gcc */
212 if (TC_H_MAJ(skb
->priority
) == sch
->handle
) {
213 skb
->tc_index
= TC_H_MIN(skb
->priority
);
215 result
= tc_classify(skb
,p
->filter_list
,&res
);
216 D2PRINTK("result %d class 0x%04x\n",result
,res
.classid
);
218 #ifdef CONFIG_NET_CLS_POLICE
223 case TC_POLICE_RECLASSIFY
:
224 /* FIXME: what to do here ??? */
228 skb
->tc_index
= TC_H_MIN(res
.classid
);
230 case TC_POLICE_UNSPEC
:
233 if (p
->default_index
!= NO_DEFAULT_INDEX
)
234 skb
->tc_index
= p
->default_index
;
239 #ifdef CONFIG_NET_CLS_POLICE
240 result
== TC_POLICE_SHOT
||
243 ((ret
= p
->q
->enqueue(skb
,p
->q
)) != 0)) {
247 sch
->stats
.bytes
+= skb
->len
;
248 sch
->stats
.packets
++;
254 static struct sk_buff
*dsmark_dequeue(struct Qdisc
*sch
)
256 struct dsmark_qdisc_data
*p
= PRIV(sch
);
260 D2PRINTK("dsmark_dequeue(sch %p,[qdisc %p])\n",sch
,p
);
261 skb
= p
->q
->ops
->dequeue(p
->q
);
265 index
= skb
->tc_index
& (p
->indices
-1);
266 D2PRINTK("index %d->%d\n",skb
->tc_index
,index
);
267 switch (skb
->protocol
) {
268 case __constant_htons(ETH_P_IP
):
269 ipv4_change_dsfield(skb
->nh
.iph
,
270 p
->mask
[index
],p
->value
[index
]);
272 case __constant_htons(ETH_P_IPV6
):
273 ipv6_change_dsfield(skb
->nh
.ipv6h
,
274 p
->mask
[index
],p
->value
[index
]);
278 * Only complain if a change was actually attempted.
279 * This way, we can send non-IP traffic through dsmark
280 * and don't need yet another qdisc as a bypass.
282 if (p
->mask
[index
] != 0xff || p
->value
[index
])
283 printk(KERN_WARNING
"dsmark_dequeue: "
284 "unsupported protocol %d\n",
285 htons(skb
->protocol
));
292 static int dsmark_requeue(struct sk_buff
*skb
,struct Qdisc
*sch
)
295 struct dsmark_qdisc_data
*p
= PRIV(sch
);
297 D2PRINTK("dsmark_requeue(skb %p,sch %p,[qdisc %p])\n",skb
,sch
,p
);
298 if ((ret
= p
->q
->ops
->requeue(skb
, p
->q
)) == 0) {
307 static unsigned int dsmark_drop(struct Qdisc
*sch
)
309 struct dsmark_qdisc_data
*p
= PRIV(sch
);
312 DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n",sch
,p
);
313 if (!p
->q
->ops
->drop
)
315 if (!(len
= p
->q
->ops
->drop(p
->q
)))
322 int dsmark_init(struct Qdisc
*sch
,struct rtattr
*opt
)
324 struct dsmark_qdisc_data
*p
= PRIV(sch
);
325 struct rtattr
*tb
[TCA_DSMARK_MAX
];
328 DPRINTK("dsmark_init(sch %p,[qdisc %p],opt %p)\n",sch
,p
,opt
);
330 rtattr_parse(tb
,TCA_DSMARK_MAX
,RTA_DATA(opt
),RTA_PAYLOAD(opt
)) < 0 ||
331 !tb
[TCA_DSMARK_INDICES
-1] ||
332 RTA_PAYLOAD(tb
[TCA_DSMARK_INDICES
-1]) < sizeof(__u16
))
334 p
->indices
= *(__u16
*) RTA_DATA(tb
[TCA_DSMARK_INDICES
-1]);
337 for (tmp
= p
->indices
; tmp
!= 1; tmp
>>= 1) {
341 p
->default_index
= NO_DEFAULT_INDEX
;
342 if (tb
[TCA_DSMARK_DEFAULT_INDEX
-1]) {
343 if (RTA_PAYLOAD(tb
[TCA_DSMARK_DEFAULT_INDEX
-1]) < sizeof(__u16
))
346 *(__u16
*) RTA_DATA(tb
[TCA_DSMARK_DEFAULT_INDEX
-1]);
348 p
->set_tc_index
= !!tb
[TCA_DSMARK_SET_TC_INDEX
-1];
349 p
->mask
= kmalloc(p
->indices
*2,GFP_KERNEL
);
352 p
->value
= p
->mask
+p
->indices
;
353 memset(p
->mask
,0xff,p
->indices
);
354 memset(p
->value
,0,p
->indices
);
355 if (!(p
->q
= qdisc_create_dflt(sch
->dev
, &pfifo_qdisc_ops
)))
357 DPRINTK("dsmark_init: qdisc %p\n",&p
->q
);
362 static void dsmark_reset(struct Qdisc
*sch
)
364 struct dsmark_qdisc_data
*p
= PRIV(sch
);
366 DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n",sch
,p
);
372 static void dsmark_destroy(struct Qdisc
*sch
)
374 struct dsmark_qdisc_data
*p
= PRIV(sch
);
375 struct tcf_proto
*tp
;
377 DPRINTK("dsmark_destroy(sch %p,[qdisc %p])\n",sch
,p
);
378 while (p
->filter_list
) {
380 p
->filter_list
= tp
->next
;
388 static int dsmark_dump_class(struct Qdisc
*sch
, unsigned long cl
,
389 struct sk_buff
*skb
, struct tcmsg
*tcm
)
391 struct dsmark_qdisc_data
*p
= PRIV(sch
);
392 unsigned char *b
= skb
->tail
;
395 DPRINTK("dsmark_dump_class(sch %p,[qdisc %p],class %ld\n",sch
,p
,cl
);
396 if (!cl
|| cl
> p
->indices
)
398 tcm
->tcm_handle
= TC_H_MAKE(TC_H_MAJ(sch
->handle
),cl
-1);
399 rta
= (struct rtattr
*) b
;
400 RTA_PUT(skb
,TCA_OPTIONS
,0,NULL
);
401 RTA_PUT(skb
,TCA_DSMARK_MASK
,1,&p
->mask
[cl
-1]);
402 RTA_PUT(skb
,TCA_DSMARK_VALUE
,1,&p
->value
[cl
-1]);
403 rta
->rta_len
= skb
->tail
-b
;
407 skb_trim(skb
,b
-skb
->data
);
411 static int dsmark_dump(struct Qdisc
*sch
, struct sk_buff
*skb
)
413 struct dsmark_qdisc_data
*p
= PRIV(sch
);
414 unsigned char *b
= skb
->tail
;
417 rta
= (struct rtattr
*) b
;
418 RTA_PUT(skb
,TCA_OPTIONS
,0,NULL
);
419 RTA_PUT(skb
,TCA_DSMARK_INDICES
,sizeof(__u16
),&p
->indices
);
420 if (p
->default_index
!= NO_DEFAULT_INDEX
) {
421 __u16 tmp
= p
->default_index
;
423 RTA_PUT(skb
,TCA_DSMARK_DEFAULT_INDEX
, sizeof(__u16
), &tmp
);
426 RTA_PUT(skb
, TCA_DSMARK_SET_TC_INDEX
, 0, NULL
);
427 rta
->rta_len
= skb
->tail
-b
;
431 skb_trim(skb
,b
-skb
->data
);
435 static struct Qdisc_class_ops dsmark_class_ops
= {
436 .graft
= dsmark_graft
,
440 .change
= dsmark_change
,
441 .delete = dsmark_delete
,
443 .tcf_chain
= dsmark_find_tcf
,
444 .bind_tcf
= dsmark_bind_filter
,
445 .unbind_tcf
= dsmark_put
,
446 .dump
= dsmark_dump_class
,
449 static struct Qdisc_ops dsmark_qdisc_ops
= {
451 .cl_ops
= &dsmark_class_ops
,
453 .priv_size
= sizeof(struct dsmark_qdisc_data
),
454 .enqueue
= dsmark_enqueue
,
455 .dequeue
= dsmark_dequeue
,
456 .requeue
= dsmark_requeue
,
459 .reset
= dsmark_reset
,
460 .destroy
= dsmark_destroy
,
463 .owner
= THIS_MODULE
,
466 static int __init
dsmark_module_init(void)
468 return register_qdisc(&dsmark_qdisc_ops
);
470 static void __exit
dsmark_module_exit(void)
472 unregister_qdisc(&dsmark_qdisc_ops
);
474 module_init(dsmark_module_init
)
475 module_exit(dsmark_module_exit
)
476 MODULE_LICENSE("GPL");