2 * net/sched/cls_tcindex.c Packet classifier for skb->tc_index
4 * Written 1998,1999 by Werner Almesberger, EPFL ICA
7 #include <linux/module.h>
8 #include <linux/types.h>
9 #include <linux/kernel.h>
10 #include <linux/skbuff.h>
11 #include <linux/errno.h>
12 #include <linux/slab.h>
13 #include <net/act_api.h>
14 #include <net/netlink.h>
15 #include <net/pkt_cls.h>
16 #include <net/sch_generic.h>
19 * Passing parameters to the root seems to be done more awkwardly than really
20 * necessary. At least, u32 doesn't seem to use such dirty hacks. To be
24 #define PERFECT_HASH_THRESHOLD 64 /* use perfect hash if not bigger */
25 #define DEFAULT_HASH_SIZE 64 /* optimized for diffserv */
28 struct tcindex_filter_result
{
30 struct tcf_result res
;
31 struct rcu_work rwork
;
34 struct tcindex_filter
{
36 struct tcindex_filter_result result
;
37 struct tcindex_filter __rcu
*next
;
38 struct rcu_work rwork
;
43 struct tcindex_filter_result
*perfect
; /* perfect hash; NULL if none */
44 struct tcindex_filter __rcu
**h
; /* imperfect hash; */
46 u16 mask
; /* AND key with mask */
47 u32 shift
; /* shift ANDed key to the right */
48 u32 hash
; /* hash table size; 0 if undefined */
49 u32 alloc_hash
; /* allocated size */
50 u32 fall_through
; /* 0: only classify if explicit match */
51 struct rcu_work rwork
;
54 static inline int tcindex_filter_is_set(struct tcindex_filter_result
*r
)
56 return tcf_exts_has_actions(&r
->exts
) || r
->res
.classid
;
59 static struct tcindex_filter_result
*tcindex_lookup(struct tcindex_data
*p
,
63 struct tcindex_filter_result
*f
= p
->perfect
+ key
;
65 return tcindex_filter_is_set(f
) ? f
: NULL
;
67 struct tcindex_filter __rcu
**fp
;
68 struct tcindex_filter
*f
;
70 fp
= &p
->h
[key
% p
->hash
];
71 for (f
= rcu_dereference_bh_rtnl(*fp
);
73 fp
= &f
->next
, f
= rcu_dereference_bh_rtnl(*fp
))
82 static int tcindex_classify(struct sk_buff
*skb
, const struct tcf_proto
*tp
,
83 struct tcf_result
*res
)
85 struct tcindex_data
*p
= rcu_dereference_bh(tp
->root
);
86 struct tcindex_filter_result
*f
;
87 int key
= (skb
->tc_index
& p
->mask
) >> p
->shift
;
89 pr_debug("tcindex_classify(skb %p,tp %p,res %p),p %p\n",
92 f
= tcindex_lookup(p
, key
);
94 struct Qdisc
*q
= tcf_block_q(tp
->chain
->block
);
98 res
->classid
= TC_H_MAKE(TC_H_MAJ(q
->handle
), key
);
100 pr_debug("alg 0x%x\n", res
->classid
);
104 pr_debug("map 0x%x\n", res
->classid
);
106 return tcf_exts_exec(skb
, &f
->exts
, res
);
110 static void *tcindex_get(struct tcf_proto
*tp
, u32 handle
)
112 struct tcindex_data
*p
= rtnl_dereference(tp
->root
);
113 struct tcindex_filter_result
*r
;
115 pr_debug("tcindex_get(tp %p,handle 0x%08x)\n", tp
, handle
);
116 if (p
->perfect
&& handle
>= p
->alloc_hash
)
118 r
= tcindex_lookup(p
, handle
);
119 return r
&& tcindex_filter_is_set(r
) ? r
: NULL
;
122 static int tcindex_init(struct tcf_proto
*tp
)
124 struct tcindex_data
*p
;
126 pr_debug("tcindex_init(tp %p)\n", tp
);
127 p
= kzalloc(sizeof(struct tcindex_data
), GFP_KERNEL
);
132 p
->hash
= DEFAULT_HASH_SIZE
;
135 rcu_assign_pointer(tp
->root
, p
);
139 static void __tcindex_destroy_rexts(struct tcindex_filter_result
*r
)
141 tcf_exts_destroy(&r
->exts
);
142 tcf_exts_put_net(&r
->exts
);
145 static void tcindex_destroy_rexts_work(struct work_struct
*work
)
147 struct tcindex_filter_result
*r
;
149 r
= container_of(to_rcu_work(work
),
150 struct tcindex_filter_result
,
153 __tcindex_destroy_rexts(r
);
157 static void __tcindex_destroy_fexts(struct tcindex_filter
*f
)
159 tcf_exts_destroy(&f
->result
.exts
);
160 tcf_exts_put_net(&f
->result
.exts
);
164 static void tcindex_destroy_fexts_work(struct work_struct
*work
)
166 struct tcindex_filter
*f
= container_of(to_rcu_work(work
),
167 struct tcindex_filter
,
171 __tcindex_destroy_fexts(f
);
175 static int tcindex_delete(struct tcf_proto
*tp
, void *arg
, bool *last
)
177 struct tcindex_data
*p
= rtnl_dereference(tp
->root
);
178 struct tcindex_filter_result
*r
= arg
;
179 struct tcindex_filter __rcu
**walk
;
180 struct tcindex_filter
*f
= NULL
;
182 pr_debug("tcindex_delete(tp %p,arg %p),p %p\n", tp
, arg
, p
);
189 for (i
= 0; i
< p
->hash
; i
++) {
191 for (f
= rtnl_dereference(*walk
); f
;
192 walk
= &f
->next
, f
= rtnl_dereference(*walk
)) {
200 rcu_assign_pointer(*walk
, rtnl_dereference(f
->next
));
202 tcf_unbind_filter(tp
, &r
->res
);
203 /* all classifiers are required to call tcf_exts_destroy() after rcu
204 * grace period, since converted-to-rcu actions are relying on that
205 * in cleanup() callback
208 if (tcf_exts_get_net(&f
->result
.exts
))
209 tcf_queue_work(&f
->rwork
, tcindex_destroy_fexts_work
);
211 __tcindex_destroy_fexts(f
);
213 if (tcf_exts_get_net(&r
->exts
))
214 tcf_queue_work(&r
->rwork
, tcindex_destroy_rexts_work
);
216 __tcindex_destroy_rexts(r
);
223 static void tcindex_destroy_work(struct work_struct
*work
)
225 struct tcindex_data
*p
= container_of(to_rcu_work(work
),
235 valid_perfect_hash(struct tcindex_data
*p
)
237 return p
->hash
> (p
->mask
>> p
->shift
);
240 static const struct nla_policy tcindex_policy
[TCA_TCINDEX_MAX
+ 1] = {
241 [TCA_TCINDEX_HASH
] = { .type
= NLA_U32
},
242 [TCA_TCINDEX_MASK
] = { .type
= NLA_U16
},
243 [TCA_TCINDEX_SHIFT
] = { .type
= NLA_U32
},
244 [TCA_TCINDEX_FALL_THROUGH
] = { .type
= NLA_U32
},
245 [TCA_TCINDEX_CLASSID
] = { .type
= NLA_U32
},
248 static int tcindex_filter_result_init(struct tcindex_filter_result
*r
,
251 memset(r
, 0, sizeof(*r
));
252 return tcf_exts_init(&r
->exts
, net
, TCA_TCINDEX_ACT
,
256 static void tcindex_partial_destroy_work(struct work_struct
*work
)
258 struct tcindex_data
*p
= container_of(to_rcu_work(work
),
266 static void tcindex_free_perfect_hash(struct tcindex_data
*cp
)
270 for (i
= 0; i
< cp
->hash
; i
++)
271 tcf_exts_destroy(&cp
->perfect
[i
].exts
);
275 static int tcindex_alloc_perfect_hash(struct net
*net
, struct tcindex_data
*cp
)
279 cp
->perfect
= kcalloc(cp
->hash
, sizeof(struct tcindex_filter_result
),
284 for (i
= 0; i
< cp
->hash
; i
++) {
285 err
= tcf_exts_init(&cp
->perfect
[i
].exts
, net
,
286 TCA_TCINDEX_ACT
, TCA_TCINDEX_POLICE
);
294 tcindex_free_perfect_hash(cp
);
299 tcindex_set_parms(struct net
*net
, struct tcf_proto
*tp
, unsigned long base
,
300 u32 handle
, struct tcindex_data
*p
,
301 struct tcindex_filter_result
*r
, struct nlattr
**tb
,
302 struct nlattr
*est
, bool ovr
)
304 struct tcindex_filter_result new_filter_result
, *old_r
= r
;
305 struct tcindex_data
*cp
= NULL
, *oldp
;
306 struct tcindex_filter
*f
= NULL
; /* make gcc behave */
307 struct tcf_result cr
= {};
311 err
= tcf_exts_init(&e
, net
, TCA_TCINDEX_ACT
, TCA_TCINDEX_POLICE
);
314 err
= tcf_exts_validate(net
, tp
, tb
, est
, &e
, ovr
);
319 /* tcindex_data attributes must look atomic to classifier/lookup so
320 * allocate new tcindex data and RCU assign it onto root. Keeping
321 * perfect hash and hash pointers from old data.
323 cp
= kzalloc(sizeof(*cp
), GFP_KERNEL
);
328 cp
->shift
= p
->shift
;
330 cp
->alloc_hash
= p
->alloc_hash
;
331 cp
->fall_through
= p
->fall_through
;
334 if (tb
[TCA_TCINDEX_HASH
])
335 cp
->hash
= nla_get_u32(tb
[TCA_TCINDEX_HASH
]);
337 if (tb
[TCA_TCINDEX_MASK
])
338 cp
->mask
= nla_get_u16(tb
[TCA_TCINDEX_MASK
]);
340 if (tb
[TCA_TCINDEX_SHIFT
])
341 cp
->shift
= nla_get_u32(tb
[TCA_TCINDEX_SHIFT
]);
344 /* Hash not specified, use perfect hash if the upper limit
345 * of the hashing index is below the threshold.
347 if ((cp
->mask
>> cp
->shift
) < PERFECT_HASH_THRESHOLD
)
348 cp
->hash
= (cp
->mask
>> cp
->shift
) + 1;
350 cp
->hash
= DEFAULT_HASH_SIZE
;
356 if (tcindex_alloc_perfect_hash(net
, cp
) < 0)
358 for (i
= 0; i
< min(cp
->hash
, p
->hash
); i
++)
359 cp
->perfect
[i
].res
= p
->perfect
[i
].res
;
364 err
= tcindex_filter_result_init(&new_filter_result
, net
);
372 /* Hash already allocated, make sure that we still meet the
373 * requirements for the allocated hash.
376 if (!valid_perfect_hash(cp
) ||
377 cp
->hash
> cp
->alloc_hash
)
379 } else if (cp
->h
&& cp
->hash
!= cp
->alloc_hash
) {
384 if (tb
[TCA_TCINDEX_FALL_THROUGH
])
385 cp
->fall_through
= nla_get_u32(tb
[TCA_TCINDEX_FALL_THROUGH
]);
387 if (!cp
->perfect
&& !cp
->h
)
388 cp
->alloc_hash
= cp
->hash
;
390 /* Note: this could be as restrictive as if (handle & ~(mask >> shift))
391 * but then, we'd fail handles that may become valid after some future
392 * mask change. While this is extremely unlikely to ever matter,
393 * the check below is safer (and also more backwards-compatible).
395 if (cp
->perfect
|| valid_perfect_hash(cp
))
396 if (handle
>= cp
->alloc_hash
)
401 if (!cp
->perfect
&& !cp
->h
) {
402 if (valid_perfect_hash(cp
)) {
403 if (tcindex_alloc_perfect_hash(net
, cp
) < 0)
407 struct tcindex_filter __rcu
**hash
;
409 hash
= kcalloc(cp
->hash
,
410 sizeof(struct tcindex_filter
*),
422 r
= cp
->perfect
+ handle
;
424 r
= tcindex_lookup(cp
, handle
) ? : &new_filter_result
;
426 if (r
== &new_filter_result
) {
427 f
= kzalloc(sizeof(*f
), GFP_KERNEL
);
432 err
= tcindex_filter_result_init(&f
->result
, net
);
439 if (tb
[TCA_TCINDEX_CLASSID
]) {
440 cr
.classid
= nla_get_u32(tb
[TCA_TCINDEX_CLASSID
]);
441 tcf_bind_filter(tp
, &cr
, base
);
444 if (old_r
&& old_r
!= r
) {
445 err
= tcindex_filter_result_init(old_r
, net
);
454 tcf_exts_change(&r
->exts
, &e
);
456 rcu_assign_pointer(tp
->root
, cp
);
458 if (r
== &new_filter_result
) {
459 struct tcindex_filter
*nfp
;
460 struct tcindex_filter __rcu
**fp
;
462 f
->result
.res
= r
->res
;
463 tcf_exts_change(&f
->result
.exts
, &r
->exts
);
465 fp
= cp
->h
+ (handle
% cp
->hash
);
466 for (nfp
= rtnl_dereference(*fp
);
468 fp
= &nfp
->next
, nfp
= rtnl_dereference(*fp
))
471 rcu_assign_pointer(*fp
, f
);
473 tcf_exts_destroy(&new_filter_result
.exts
);
477 tcf_queue_work(&oldp
->rwork
, tcindex_partial_destroy_work
);
482 tcindex_free_perfect_hash(cp
);
483 else if (balloc
== 2)
485 tcf_exts_destroy(&new_filter_result
.exts
);
488 tcf_exts_destroy(&e
);
493 tcindex_change(struct net
*net
, struct sk_buff
*in_skb
,
494 struct tcf_proto
*tp
, unsigned long base
, u32 handle
,
495 struct nlattr
**tca
, void **arg
, bool ovr
)
497 struct nlattr
*opt
= tca
[TCA_OPTIONS
];
498 struct nlattr
*tb
[TCA_TCINDEX_MAX
+ 1];
499 struct tcindex_data
*p
= rtnl_dereference(tp
->root
);
500 struct tcindex_filter_result
*r
= *arg
;
503 pr_debug("tcindex_change(tp %p,handle 0x%08x,tca %p,arg %p),opt %p,"
504 "p %p,r %p,*arg %p\n",
505 tp
, handle
, tca
, arg
, opt
, p
, r
, arg
? *arg
: NULL
);
510 err
= nla_parse_nested(tb
, TCA_TCINDEX_MAX
, opt
, tcindex_policy
, NULL
);
514 return tcindex_set_parms(net
, tp
, base
, handle
, p
, r
, tb
,
518 static void tcindex_walk(struct tcf_proto
*tp
, struct tcf_walker
*walker
)
520 struct tcindex_data
*p
= rtnl_dereference(tp
->root
);
521 struct tcindex_filter
*f
, *next
;
524 pr_debug("tcindex_walk(tp %p,walker %p),p %p\n", tp
, walker
, p
);
526 for (i
= 0; i
< p
->hash
; i
++) {
527 if (!p
->perfect
[i
].res
.class)
529 if (walker
->count
>= walker
->skip
) {
530 if (walker
->fn(tp
, p
->perfect
+ i
, walker
) < 0) {
540 for (i
= 0; i
< p
->hash
; i
++) {
541 for (f
= rtnl_dereference(p
->h
[i
]); f
; f
= next
) {
542 next
= rtnl_dereference(f
->next
);
543 if (walker
->count
>= walker
->skip
) {
544 if (walker
->fn(tp
, &f
->result
, walker
) < 0) {
554 static void tcindex_destroy(struct tcf_proto
*tp
)
556 struct tcindex_data
*p
= rtnl_dereference(tp
->root
);
559 pr_debug("tcindex_destroy(tp %p),p %p\n", tp
, p
);
562 for (i
= 0; i
< p
->hash
; i
++) {
563 struct tcindex_filter_result
*r
= p
->perfect
+ i
;
565 tcf_unbind_filter(tp
, &r
->res
);
566 if (tcf_exts_get_net(&r
->exts
))
567 tcf_queue_work(&r
->rwork
,
568 tcindex_destroy_rexts_work
);
570 __tcindex_destroy_rexts(r
);
574 for (i
= 0; p
->h
&& i
< p
->hash
; i
++) {
575 struct tcindex_filter
*f
, *next
;
578 for (f
= rtnl_dereference(p
->h
[i
]); f
; f
= next
) {
579 next
= rtnl_dereference(f
->next
);
580 tcindex_delete(tp
, &f
->result
, &last
);
584 tcf_queue_work(&p
->rwork
, tcindex_destroy_work
);
588 static int tcindex_dump(struct net
*net
, struct tcf_proto
*tp
, void *fh
,
589 struct sk_buff
*skb
, struct tcmsg
*t
)
591 struct tcindex_data
*p
= rtnl_dereference(tp
->root
);
592 struct tcindex_filter_result
*r
= fh
;
595 pr_debug("tcindex_dump(tp %p,fh %p,skb %p,t %p),p %p,r %p\n",
596 tp
, fh
, skb
, t
, p
, r
);
597 pr_debug("p->perfect %p p->h %p\n", p
->perfect
, p
->h
);
599 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
601 goto nla_put_failure
;
604 t
->tcm_handle
= ~0; /* whatever ... */
605 if (nla_put_u32(skb
, TCA_TCINDEX_HASH
, p
->hash
) ||
606 nla_put_u16(skb
, TCA_TCINDEX_MASK
, p
->mask
) ||
607 nla_put_u32(skb
, TCA_TCINDEX_SHIFT
, p
->shift
) ||
608 nla_put_u32(skb
, TCA_TCINDEX_FALL_THROUGH
, p
->fall_through
))
609 goto nla_put_failure
;
610 nla_nest_end(skb
, nest
);
613 t
->tcm_handle
= r
- p
->perfect
;
615 struct tcindex_filter
*f
;
616 struct tcindex_filter __rcu
**fp
;
620 for (i
= 0; !t
->tcm_handle
&& i
< p
->hash
; i
++) {
622 for (f
= rtnl_dereference(*fp
);
624 fp
= &f
->next
, f
= rtnl_dereference(*fp
)) {
626 t
->tcm_handle
= f
->key
;
630 pr_debug("handle = %d\n", t
->tcm_handle
);
632 nla_put_u32(skb
, TCA_TCINDEX_CLASSID
, r
->res
.classid
))
633 goto nla_put_failure
;
635 if (tcf_exts_dump(skb
, &r
->exts
) < 0)
636 goto nla_put_failure
;
637 nla_nest_end(skb
, nest
);
639 if (tcf_exts_dump_stats(skb
, &r
->exts
) < 0)
640 goto nla_put_failure
;
646 nla_nest_cancel(skb
, nest
);
650 static void tcindex_bind_class(void *fh
, u32 classid
, unsigned long cl
,
651 void *q
, unsigned long base
)
653 struct tcindex_filter_result
*r
= fh
;
655 if (r
&& r
->res
.classid
== classid
) {
657 __tcf_bind_filter(q
, &r
->res
, base
);
659 __tcf_unbind_filter(q
, &r
->res
);
663 static struct tcf_proto_ops cls_tcindex_ops __read_mostly
= {
665 .classify
= tcindex_classify
,
666 .init
= tcindex_init
,
667 .destroy
= tcindex_destroy
,
669 .change
= tcindex_change
,
670 .delete = tcindex_delete
,
671 .walk
= tcindex_walk
,
672 .dump
= tcindex_dump
,
673 .bind_class
= tcindex_bind_class
,
674 .owner
= THIS_MODULE
,
677 static int __init
init_tcindex(void)
679 return register_tcf_proto_ops(&cls_tcindex_ops
);
682 static void __exit
exit_tcindex(void)
684 unregister_tcf_proto_ops(&cls_tcindex_ops
);
687 module_init(init_tcindex
)
688 module_exit(exit_tcindex
)
689 MODULE_LICENSE("GPL");