2 * net/sched/cls_rsvp.h Template file for RSVPv[46] classifiers.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
13 Comparing to general packet classification problem,
14 RSVP needs only sevaral relatively simple rules:
16 * (dst, protocol) are always specified,
17 so that we are able to hash them.
18 * src may be exact, or may be wildcard, so that
19 we can keep a hash table plus one wildcard entry.
20 * source port (or flow label) is important only if src is given.
24 We use a two level hash table: The top level is keyed by
25 destination address and protocol ID, every bucket contains a list
26 of "rsvp sessions", identified by destination address, protocol and
27 DPI(="Destination Port ID"): triple (key, mask, offset).
29 Every bucket has a smaller hash table keyed by source address
30 (cf. RSVP flowspec) and one wildcard entry for wildcard reservations.
31 Every bucket is again a list of "RSVP flows", selected by
32 source address and SPI(="Source Port ID" here rather than
33 "security parameter index"): triple (key, mask, offset).
36 NOTE 1. All the packets with IPv6 extension headers (but AH and ESP)
37 and all fragmented packets go to the best-effort traffic class.
40 NOTE 2. Two "port id"'s seems to be redundant, rfc2207 requires
41 only one "Generalized Port Identifier". So that for classic
42 ah, esp (and udp,tcp) both *pi should coincide or one of them
45 At first sight, this redundancy is just a waste of CPU
46 resources. But DPI and SPI add the possibility to assign different
47 priorities to GPIs. Look also at note 4 about tunnels below.
50 NOTE 3. One complication is the case of tunneled packets.
51 We implement it as following: if the first lookup
52 matches a special session with "tunnelhdr" value not zero,
53 flowid doesn't contain the true flow ID, but the tunnel ID (1...255).
54 In this case, we pull tunnelhdr bytes and restart lookup
55 with tunnel ID added to the list of keys. Simple and stupid 8)8)
56 It's enough for PIMREG and IPIP.
59 NOTE 4. Two GPIs make it possible to parse even GRE packets.
60 F.e. DPI can select ETH_P_IP (and necessary flags to make
61 tunnelhdr correct) in GRE protocol field and SPI matches
62 GRE key. Is it not nice? 8)8)
65 Well, as result, despite its simplicity, we get a pretty
66 powerful classification engine. */
73 struct rsvp_session __rcu
*ht
[256];
78 struct rsvp_session __rcu
*next
;
79 __be32 dst
[RSVP_DST_LEN
];
80 struct tc_rsvp_gpi dpi
;
83 /* 16 (src,sport) hash slots, and one wildcard source slot */
84 struct rsvp_filter __rcu
*ht
[16 + 1];
90 struct rsvp_filter __rcu
*next
;
91 __be32 src
[RSVP_DST_LEN
];
92 struct tc_rsvp_gpi spi
;
95 struct tcf_result res
;
99 struct rsvp_session
*sess
;
103 static inline unsigned int hash_dst(__be32
*dst
, u8 protocol
, u8 tunnelid
)
105 unsigned int h
= (__force __u32
)dst
[RSVP_DST_LEN
- 1];
109 return (h
^ protocol
^ tunnelid
) & 0xFF;
112 static inline unsigned int hash_src(__be32
*src
)
114 unsigned int h
= (__force __u32
)src
[RSVP_DST_LEN
-1];
122 #define RSVP_APPLY_RESULT() \
124 int r = tcf_exts_exec(skb, &f->exts, res); \
131 static int rsvp_classify(struct sk_buff
*skb
, const struct tcf_proto
*tp
,
132 struct tcf_result
*res
)
134 struct rsvp_head
*head
= rcu_dereference_bh(tp
->root
);
135 struct rsvp_session
*s
;
136 struct rsvp_filter
*f
;
142 #if RSVP_DST_LEN == 4
143 struct ipv6hdr
*nhptr
;
145 if (!pskb_network_may_pull(skb
, sizeof(*nhptr
)))
147 nhptr
= ipv6_hdr(skb
);
151 if (!pskb_network_may_pull(skb
, sizeof(*nhptr
)))
158 #if RSVP_DST_LEN == 4
159 src
= &nhptr
->saddr
.s6_addr32
[0];
160 dst
= &nhptr
->daddr
.s6_addr32
[0];
161 protocol
= nhptr
->nexthdr
;
162 xprt
= ((u8
*)nhptr
) + sizeof(struct ipv6hdr
);
166 protocol
= nhptr
->protocol
;
167 xprt
= ((u8
*)nhptr
) + (nhptr
->ihl
<<2);
168 if (ip_is_fragment(nhptr
))
172 h1
= hash_dst(dst
, protocol
, tunnelid
);
175 for (s
= rcu_dereference_bh(head
->ht
[h1
]); s
;
176 s
= rcu_dereference_bh(s
->next
)) {
177 if (dst
[RSVP_DST_LEN
-1] == s
->dst
[RSVP_DST_LEN
- 1] &&
178 protocol
== s
->protocol
&&
180 (*(u32
*)(xprt
+ s
->dpi
.offset
) ^ s
->dpi
.key
)) &&
181 #if RSVP_DST_LEN == 4
182 dst
[0] == s
->dst
[0] &&
183 dst
[1] == s
->dst
[1] &&
184 dst
[2] == s
->dst
[2] &&
186 tunnelid
== s
->tunnelid
) {
188 for (f
= rcu_dereference_bh(s
->ht
[h2
]); f
;
189 f
= rcu_dereference_bh(f
->next
)) {
190 if (src
[RSVP_DST_LEN
-1] == f
->src
[RSVP_DST_LEN
- 1] &&
191 !(f
->spi
.mask
& (*(u32
*)(xprt
+ f
->spi
.offset
) ^ f
->spi
.key
))
192 #if RSVP_DST_LEN == 4
194 src
[0] == f
->src
[0] &&
195 src
[1] == f
->src
[1] &&
203 if (f
->tunnelhdr
== 0)
206 tunnelid
= f
->res
.classid
;
207 nhptr
= (void *)(xprt
+ f
->tunnelhdr
- sizeof(*nhptr
));
212 /* And wildcard bucket... */
213 for (f
= rcu_dereference_bh(s
->ht
[16]); f
;
214 f
= rcu_dereference_bh(f
->next
)) {
225 static unsigned long rsvp_get(struct tcf_proto
*tp
, u32 handle
)
227 struct rsvp_head
*head
= rtnl_dereference(tp
->root
);
228 struct rsvp_session
*s
;
229 struct rsvp_filter
*f
;
230 unsigned int h1
= handle
& 0xFF;
231 unsigned int h2
= (handle
>> 8) & 0xFF;
236 for (s
= rtnl_dereference(head
->ht
[h1
]); s
;
237 s
= rtnl_dereference(s
->next
)) {
238 for (f
= rtnl_dereference(s
->ht
[h2
]); f
;
239 f
= rtnl_dereference(f
->next
)) {
240 if (f
->handle
== handle
)
241 return (unsigned long)f
;
247 static void rsvp_put(struct tcf_proto
*tp
, unsigned long f
)
251 static int rsvp_init(struct tcf_proto
*tp
)
253 struct rsvp_head
*data
;
255 data
= kzalloc(sizeof(struct rsvp_head
), GFP_KERNEL
);
257 rcu_assign_pointer(tp
->root
, data
);
264 rsvp_delete_filter(struct tcf_proto
*tp
, struct rsvp_filter
*f
)
266 tcf_unbind_filter(tp
, &f
->res
);
267 tcf_exts_destroy(&f
->exts
);
271 static void rsvp_destroy(struct tcf_proto
*tp
)
273 struct rsvp_head
*data
= rtnl_dereference(tp
->root
);
279 RCU_INIT_POINTER(tp
->root
, NULL
);
281 for (h1
= 0; h1
< 256; h1
++) {
282 struct rsvp_session
*s
;
284 while ((s
= rtnl_dereference(data
->ht
[h1
])) != NULL
) {
285 RCU_INIT_POINTER(data
->ht
[h1
], s
->next
);
287 for (h2
= 0; h2
<= 16; h2
++) {
288 struct rsvp_filter
*f
;
290 while ((f
= rtnl_dereference(s
->ht
[h2
])) != NULL
) {
291 rcu_assign_pointer(s
->ht
[h2
], f
->next
);
292 rsvp_delete_filter(tp
, f
);
298 kfree_rcu(data
, rcu
);
301 static int rsvp_delete(struct tcf_proto
*tp
, unsigned long arg
)
303 struct rsvp_head
*head
= rtnl_dereference(tp
->root
);
304 struct rsvp_filter
*nfp
, *f
= (struct rsvp_filter
*)arg
;
305 struct rsvp_filter __rcu
**fp
;
306 unsigned int h
= f
->handle
;
307 struct rsvp_session __rcu
**sp
;
308 struct rsvp_session
*nsp
, *s
= f
->sess
;
311 fp
= &s
->ht
[(h
>> 8) & 0xFF];
312 for (nfp
= rtnl_dereference(*fp
); nfp
;
313 fp
= &nfp
->next
, nfp
= rtnl_dereference(*fp
)) {
315 RCU_INIT_POINTER(*fp
, f
->next
);
316 rsvp_delete_filter(tp
, f
);
320 for (i
= 0; i
<= 16; i
++)
324 /* OK, session has no flows */
325 sp
= &head
->ht
[h
& 0xFF];
326 for (nsp
= rtnl_dereference(*sp
); nsp
;
327 sp
= &nsp
->next
, nsp
= rtnl_dereference(*sp
)) {
329 RCU_INIT_POINTER(*sp
, s
->next
);
341 static unsigned int gen_handle(struct tcf_proto
*tp
, unsigned salt
)
343 struct rsvp_head
*data
= rtnl_dereference(tp
->root
);
349 if ((data
->hgenerator
+= 0x10000) == 0)
350 data
->hgenerator
= 0x10000;
351 h
= data
->hgenerator
|salt
;
352 if (rsvp_get(tp
, h
) == 0)
358 static int tunnel_bts(struct rsvp_head
*data
)
360 int n
= data
->tgenerator
>> 5;
361 u32 b
= 1 << (data
->tgenerator
& 0x1F);
363 if (data
->tmap
[n
] & b
)
369 static void tunnel_recycle(struct rsvp_head
*data
)
371 struct rsvp_session __rcu
**sht
= data
->ht
;
375 memset(tmap
, 0, sizeof(tmap
));
377 for (h1
= 0; h1
< 256; h1
++) {
378 struct rsvp_session
*s
;
379 for (s
= rtnl_dereference(sht
[h1
]); s
;
380 s
= rtnl_dereference(s
->next
)) {
381 for (h2
= 0; h2
<= 16; h2
++) {
382 struct rsvp_filter
*f
;
384 for (f
= rtnl_dereference(s
->ht
[h2
]); f
;
385 f
= rtnl_dereference(f
->next
)) {
386 if (f
->tunnelhdr
== 0)
388 data
->tgenerator
= f
->res
.classid
;
395 memcpy(data
->tmap
, tmap
, sizeof(tmap
));
398 static u32
gen_tunnel(struct rsvp_head
*data
)
402 for (k
= 0; k
< 2; k
++) {
403 for (i
= 255; i
> 0; i
--) {
404 if (++data
->tgenerator
== 0)
405 data
->tgenerator
= 1;
406 if (tunnel_bts(data
))
407 return data
->tgenerator
;
409 tunnel_recycle(data
);
414 static const struct nla_policy rsvp_policy
[TCA_RSVP_MAX
+ 1] = {
415 [TCA_RSVP_CLASSID
] = { .type
= NLA_U32
},
416 [TCA_RSVP_DST
] = { .type
= NLA_BINARY
,
417 .len
= RSVP_DST_LEN
* sizeof(u32
) },
418 [TCA_RSVP_SRC
] = { .type
= NLA_BINARY
,
419 .len
= RSVP_DST_LEN
* sizeof(u32
) },
420 [TCA_RSVP_PINFO
] = { .len
= sizeof(struct tc_rsvp_pinfo
) },
423 static int rsvp_change(struct net
*net
, struct sk_buff
*in_skb
,
424 struct tcf_proto
*tp
, unsigned long base
,
427 unsigned long *arg
, bool ovr
)
429 struct rsvp_head
*data
= rtnl_dereference(tp
->root
);
430 struct rsvp_filter
*f
, *nfp
;
431 struct rsvp_filter __rcu
**fp
;
432 struct rsvp_session
*nsp
, *s
;
433 struct rsvp_session __rcu
**sp
;
434 struct tc_rsvp_pinfo
*pinfo
= NULL
;
435 struct nlattr
*opt
= tca
[TCA_OPTIONS
];
436 struct nlattr
*tb
[TCA_RSVP_MAX
+ 1];
443 return handle
? -EINVAL
: 0;
445 err
= nla_parse_nested(tb
, TCA_RSVP_MAX
, opt
, rsvp_policy
);
449 tcf_exts_init(&e
, TCA_RSVP_ACT
, TCA_RSVP_POLICE
);
450 err
= tcf_exts_validate(net
, tp
, tb
, tca
[TCA_RATE
], &e
, ovr
);
454 f
= (struct rsvp_filter
*)*arg
;
456 /* Node exists: adjust only classid */
458 if (f
->handle
!= handle
&& handle
)
460 if (tb
[TCA_RSVP_CLASSID
]) {
461 f
->res
.classid
= nla_get_u32(tb
[TCA_RSVP_CLASSID
]);
462 tcf_bind_filter(tp
, &f
->res
, base
);
465 tcf_exts_change(tp
, &f
->exts
, &e
);
469 /* Now more serious part... */
473 if (tb
[TCA_RSVP_DST
] == NULL
)
477 f
= kzalloc(sizeof(struct rsvp_filter
), GFP_KERNEL
);
481 tcf_exts_init(&f
->exts
, TCA_RSVP_ACT
, TCA_RSVP_POLICE
);
483 if (tb
[TCA_RSVP_SRC
]) {
484 memcpy(f
->src
, nla_data(tb
[TCA_RSVP_SRC
]), sizeof(f
->src
));
485 h2
= hash_src(f
->src
);
487 if (tb
[TCA_RSVP_PINFO
]) {
488 pinfo
= nla_data(tb
[TCA_RSVP_PINFO
]);
490 f
->tunnelhdr
= pinfo
->tunnelhdr
;
492 if (tb
[TCA_RSVP_CLASSID
])
493 f
->res
.classid
= nla_get_u32(tb
[TCA_RSVP_CLASSID
]);
495 dst
= nla_data(tb
[TCA_RSVP_DST
]);
496 h1
= hash_dst(dst
, pinfo
? pinfo
->protocol
: 0, pinfo
? pinfo
->tunnelid
: 0);
499 if ((f
->handle
= gen_handle(tp
, h1
| (h2
<<8))) == 0)
504 if (f
->res
.classid
> 255)
508 if (f
->res
.classid
== 0 &&
509 (f
->res
.classid
= gen_tunnel(data
)) == 0)
513 for (sp
= &data
->ht
[h1
];
514 (s
= rtnl_dereference(*sp
)) != NULL
;
516 if (dst
[RSVP_DST_LEN
-1] == s
->dst
[RSVP_DST_LEN
-1] &&
517 pinfo
&& pinfo
->protocol
== s
->protocol
&&
518 memcmp(&pinfo
->dpi
, &s
->dpi
, sizeof(s
->dpi
)) == 0 &&
519 #if RSVP_DST_LEN == 4
520 dst
[0] == s
->dst
[0] &&
521 dst
[1] == s
->dst
[1] &&
522 dst
[2] == s
->dst
[2] &&
524 pinfo
->tunnelid
== s
->tunnelid
) {
527 /* OK, we found appropriate session */
532 if (f
->tunnelhdr
== 0)
533 tcf_bind_filter(tp
, &f
->res
, base
);
535 tcf_exts_change(tp
, &f
->exts
, &e
);
538 for (nfp
= rtnl_dereference(*fp
); nfp
;
539 fp
= &nfp
->next
, nfp
= rtnl_dereference(*fp
)) {
540 __u32 mask
= nfp
->spi
.mask
& f
->spi
.mask
;
542 if (mask
!= f
->spi
.mask
)
545 RCU_INIT_POINTER(f
->next
, nfp
);
546 rcu_assign_pointer(*fp
, f
);
548 *arg
= (unsigned long)f
;
553 /* No session found. Create new one. */
556 s
= kzalloc(sizeof(struct rsvp_session
), GFP_KERNEL
);
559 memcpy(s
->dst
, dst
, sizeof(s
->dst
));
563 s
->protocol
= pinfo
->protocol
;
564 s
->tunnelid
= pinfo
->tunnelid
;
567 for (nsp
= rtnl_dereference(*sp
); nsp
;
568 sp
= &nsp
->next
, nsp
= rtnl_dereference(*sp
)) {
569 if ((nsp
->dpi
.mask
& s
->dpi
.mask
) != s
->dpi
.mask
)
572 RCU_INIT_POINTER(s
->next
, nsp
);
573 rcu_assign_pointer(*sp
, s
);
580 tcf_exts_destroy(&e
);
584 static void rsvp_walk(struct tcf_proto
*tp
, struct tcf_walker
*arg
)
586 struct rsvp_head
*head
= rtnl_dereference(tp
->root
);
592 for (h
= 0; h
< 256; h
++) {
593 struct rsvp_session
*s
;
595 for (s
= rtnl_dereference(head
->ht
[h
]); s
;
596 s
= rtnl_dereference(s
->next
)) {
597 for (h1
= 0; h1
<= 16; h1
++) {
598 struct rsvp_filter
*f
;
600 for (f
= rtnl_dereference(s
->ht
[h1
]); f
;
601 f
= rtnl_dereference(f
->next
)) {
602 if (arg
->count
< arg
->skip
) {
606 if (arg
->fn(tp
, (unsigned long)f
, arg
) < 0) {
617 static int rsvp_dump(struct net
*net
, struct tcf_proto
*tp
, unsigned long fh
,
618 struct sk_buff
*skb
, struct tcmsg
*t
)
620 struct rsvp_filter
*f
= (struct rsvp_filter
*)fh
;
621 struct rsvp_session
*s
;
622 unsigned char *b
= skb_tail_pointer(skb
);
624 struct tc_rsvp_pinfo pinfo
;
630 t
->tcm_handle
= f
->handle
;
632 nest
= nla_nest_start(skb
, TCA_OPTIONS
);
634 goto nla_put_failure
;
636 if (nla_put(skb
, TCA_RSVP_DST
, sizeof(s
->dst
), &s
->dst
))
637 goto nla_put_failure
;
640 pinfo
.protocol
= s
->protocol
;
641 pinfo
.tunnelid
= s
->tunnelid
;
642 pinfo
.tunnelhdr
= f
->tunnelhdr
;
644 if (nla_put(skb
, TCA_RSVP_PINFO
, sizeof(pinfo
), &pinfo
))
645 goto nla_put_failure
;
646 if (f
->res
.classid
&&
647 nla_put_u32(skb
, TCA_RSVP_CLASSID
, f
->res
.classid
))
648 goto nla_put_failure
;
649 if (((f
->handle
>> 8) & 0xFF) != 16 &&
650 nla_put(skb
, TCA_RSVP_SRC
, sizeof(f
->src
), f
->src
))
651 goto nla_put_failure
;
653 if (tcf_exts_dump(skb
, &f
->exts
) < 0)
654 goto nla_put_failure
;
656 nla_nest_end(skb
, nest
);
658 if (tcf_exts_dump_stats(skb
, &f
->exts
) < 0)
659 goto nla_put_failure
;
667 static struct tcf_proto_ops RSVP_OPS __read_mostly
= {
669 .classify
= rsvp_classify
,
671 .destroy
= rsvp_destroy
,
674 .change
= rsvp_change
,
675 .delete = rsvp_delete
,
678 .owner
= THIS_MODULE
,
681 static int __init
init_rsvp(void)
683 return register_tcf_proto_ops(&RSVP_OPS
);
686 static void __exit
exit_rsvp(void)
688 unregister_tcf_proto_ops(&RSVP_OPS
);
691 module_init(init_rsvp
)
692 module_exit(exit_rsvp
)