blob: edd8ade3fbc1f4358b4275940e6f62b3d814b3dd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sched/cls_rsvp.h Template file for RSVPv[46] classifiers.
3 *
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.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 */
11
12/*
13 Comparing to general packet classification problem,
14 RSVP needs only sevaral relatively simple rules:
15
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.
21
22 IMPLEMENTATION.
23
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).
28
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).
34
35
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.
38
39
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
43 should be wildcard.
44
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.
48
49
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.
57
58
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)
63
64
65 Well, as result, despite its simplicity, we get a pretty
66 powerful classification engine. */
67
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Eric Dumazetcc7ec452011-01-19 19:26:56 +000069struct rsvp_head {
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 u32 tmap[256/32];
71 u32 hgenerator;
72 u8 tgenerator;
John Fastabendb929d862014-09-12 20:09:49 -070073 struct rsvp_session __rcu *ht[256];
74 struct rcu_head rcu;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075};
76
Eric Dumazetcc7ec452011-01-19 19:26:56 +000077struct rsvp_session {
John Fastabendb929d862014-09-12 20:09:49 -070078 struct rsvp_session __rcu *next;
79 __be32 dst[RSVP_DST_LEN];
80 struct tc_rsvp_gpi dpi;
81 u8 protocol;
82 u8 tunnelid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 /* 16 (src,sport) hash slots, and one wildcard source slot */
John Fastabendb929d862014-09-12 20:09:49 -070084 struct rsvp_filter __rcu *ht[16 + 1];
85 struct rcu_head rcu;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086};
87
88
Eric Dumazetcc7ec452011-01-19 19:26:56 +000089struct rsvp_filter {
John Fastabendb929d862014-09-12 20:09:49 -070090 struct rsvp_filter __rcu *next;
91 __be32 src[RSVP_DST_LEN];
92 struct tc_rsvp_gpi spi;
93 u8 tunnelhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
John Fastabendb929d862014-09-12 20:09:49 -070095 struct tcf_result res;
96 struct tcf_exts exts;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
John Fastabendb929d862014-09-12 20:09:49 -070098 u32 handle;
99 struct rsvp_session *sess;
100 struct rcu_head rcu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101};
102
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000103static inline unsigned int hash_dst(__be32 *dst, u8 protocol, u8 tunnelid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000105 unsigned int h = (__force __u32)dst[RSVP_DST_LEN - 1];
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 h ^= h>>16;
108 h ^= h>>8;
109 return (h ^ protocol ^ tunnelid) & 0xFF;
110}
111
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000112static inline unsigned int hash_src(__be32 *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000114 unsigned int h = (__force __u32)src[RSVP_DST_LEN-1];
115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 h ^= h>>16;
117 h ^= h>>8;
118 h ^= h>>4;
119 return h & 0xF;
120}
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122#define RSVP_APPLY_RESULT() \
123{ \
124 int r = tcf_exts_exec(skb, &f->exts, res); \
125 if (r < 0) \
126 continue; \
127 else if (r > 0) \
128 return r; \
129}
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900130
Eric Dumazetdc7f9f62011-07-05 23:25:42 +0000131static int rsvp_classify(struct sk_buff *skb, const struct tcf_proto *tp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 struct tcf_result *res)
133{
John Fastabendb929d862014-09-12 20:09:49 -0700134 struct rsvp_head *head = rcu_dereference_bh(tp->root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 struct rsvp_session *s;
136 struct rsvp_filter *f;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000137 unsigned int h1, h2;
Al Viro66c6f522006-11-20 18:07:51 -0800138 __be32 *dst, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 u8 protocol;
140 u8 tunnelid = 0;
141 u8 *xprt;
142#if RSVP_DST_LEN == 4
Changli Gao12dc96d2010-08-04 04:55:40 +0000143 struct ipv6hdr *nhptr;
144
145 if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
146 return -1;
147 nhptr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148#else
Changli Gao12dc96d2010-08-04 04:55:40 +0000149 struct iphdr *nhptr;
150
151 if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
152 return -1;
153 nhptr = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154#endif
155
156restart:
157
158#if RSVP_DST_LEN == 4
159 src = &nhptr->saddr.s6_addr32[0];
160 dst = &nhptr->daddr.s6_addr32[0];
161 protocol = nhptr->nexthdr;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000162 xprt = ((u8 *)nhptr) + sizeof(struct ipv6hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163#else
164 src = &nhptr->saddr;
165 dst = &nhptr->daddr;
166 protocol = nhptr->protocol;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000167 xprt = ((u8 *)nhptr) + (nhptr->ihl<<2);
Paul Gortmaker56f8a752011-06-21 20:33:34 -0700168 if (ip_is_fragment(nhptr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 return -1;
170#endif
171
172 h1 = hash_dst(dst, protocol, tunnelid);
173 h2 = hash_src(src);
174
John Fastabendb929d862014-09-12 20:09:49 -0700175 for (s = rcu_dereference_bh(head->ht[h1]); s;
176 s = rcu_dereference_bh(s->next)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000177 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN - 1] &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 protocol == s->protocol &&
Joe Perchesf64f9e72009-11-29 16:55:45 -0800179 !(s->dpi.mask &
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000180 (*(u32 *)(xprt + s->dpi.offset) ^ s->dpi.key)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181#if RSVP_DST_LEN == 4
Joe Perchesf64f9e72009-11-29 16:55:45 -0800182 dst[0] == s->dst[0] &&
183 dst[1] == s->dst[1] &&
184 dst[2] == s->dst[2] &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185#endif
Joe Perchesf64f9e72009-11-29 16:55:45 -0800186 tunnelid == s->tunnelid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
John Fastabendb929d862014-09-12 20:09:49 -0700188 for (f = rcu_dereference_bh(s->ht[h2]); f;
189 f = rcu_dereference_bh(f->next)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000190 if (src[RSVP_DST_LEN-1] == f->src[RSVP_DST_LEN - 1] &&
191 !(f->spi.mask & (*(u32 *)(xprt + f->spi.offset) ^ f->spi.key))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192#if RSVP_DST_LEN == 4
Joe Perchesf64f9e72009-11-29 16:55:45 -0800193 &&
194 src[0] == f->src[0] &&
195 src[1] == f->src[1] &&
196 src[2] == f->src[2]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197#endif
198 ) {
199 *res = f->res;
200 RSVP_APPLY_RESULT();
201
202matched:
203 if (f->tunnelhdr == 0)
204 return 0;
205
206 tunnelid = f->res.classid;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000207 nhptr = (void *)(xprt + f->tunnelhdr - sizeof(*nhptr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 goto restart;
209 }
210 }
211
212 /* And wildcard bucket... */
John Fastabendb929d862014-09-12 20:09:49 -0700213 for (f = rcu_dereference_bh(s->ht[16]); f;
214 f = rcu_dereference_bh(f->next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 *res = f->res;
216 RSVP_APPLY_RESULT();
217 goto matched;
218 }
219 return -1;
220 }
221 }
222 return -1;
223}
224
John Fastabend53dfd502014-09-26 10:02:50 -0700225static void rsvp_replace(struct tcf_proto *tp, struct rsvp_filter *n, u32 h)
226{
227 struct rsvp_head *head = rtnl_dereference(tp->root);
228 struct rsvp_session *s;
229 struct rsvp_filter __rcu **ins;
230 struct rsvp_filter *pins;
231 unsigned int h1 = h & 0xFF;
232 unsigned int h2 = (h >> 8) & 0xFF;
233
234 for (s = rtnl_dereference(head->ht[h1]); s;
235 s = rtnl_dereference(s->next)) {
236 for (ins = &s->ht[h2], pins = rtnl_dereference(*ins); ;
237 ins = &pins->next, pins = rtnl_dereference(*ins)) {
238 if (pins->handle == h) {
239 RCU_INIT_POINTER(n->next, pins->next);
240 rcu_assign_pointer(*ins, n);
241 return;
242 }
243 }
244 }
245
246 /* Something went wrong if we are trying to replace a non-existant
247 * node. Mind as well halt instead of silently failing.
248 */
249 BUG_ON(1);
250}
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252static unsigned long rsvp_get(struct tcf_proto *tp, u32 handle)
253{
John Fastabendb929d862014-09-12 20:09:49 -0700254 struct rsvp_head *head = rtnl_dereference(tp->root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 struct rsvp_session *s;
256 struct rsvp_filter *f;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000257 unsigned int h1 = handle & 0xFF;
258 unsigned int h2 = (handle >> 8) & 0xFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
260 if (h2 > 16)
261 return 0;
262
John Fastabendb929d862014-09-12 20:09:49 -0700263 for (s = rtnl_dereference(head->ht[h1]); s;
264 s = rtnl_dereference(s->next)) {
265 for (f = rtnl_dereference(s->ht[h2]); f;
266 f = rtnl_dereference(f->next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 if (f->handle == handle)
268 return (unsigned long)f;
269 }
270 }
271 return 0;
272}
273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274static int rsvp_init(struct tcf_proto *tp)
275{
276 struct rsvp_head *data;
277
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700278 data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 if (data) {
John Fastabendb929d862014-09-12 20:09:49 -0700280 rcu_assign_pointer(tp->root, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return 0;
282 }
283 return -ENOBUFS;
284}
285
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000286static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)
288{
289 tcf_unbind_filter(tp, &f->res);
WANG Cong18d02642014-09-25 10:26:37 -0700290 tcf_exts_destroy(&f->exts);
John Fastabendb929d862014-09-12 20:09:49 -0700291 kfree_rcu(f, rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292}
293
294static void rsvp_destroy(struct tcf_proto *tp)
295{
John Fastabendb929d862014-09-12 20:09:49 -0700296 struct rsvp_head *data = rtnl_dereference(tp->root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 int h1, h2;
298
299 if (data == NULL)
300 return;
301
John Fastabendb929d862014-09-12 20:09:49 -0700302 RCU_INIT_POINTER(tp->root, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000304 for (h1 = 0; h1 < 256; h1++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 struct rsvp_session *s;
306
John Fastabendb929d862014-09-12 20:09:49 -0700307 while ((s = rtnl_dereference(data->ht[h1])) != NULL) {
308 RCU_INIT_POINTER(data->ht[h1], s->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000310 for (h2 = 0; h2 <= 16; h2++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 struct rsvp_filter *f;
312
John Fastabendb929d862014-09-12 20:09:49 -0700313 while ((f = rtnl_dereference(s->ht[h2])) != NULL) {
314 rcu_assign_pointer(s->ht[h2], f->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 rsvp_delete_filter(tp, f);
316 }
317 }
John Fastabendb929d862014-09-12 20:09:49 -0700318 kfree_rcu(s, rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 }
320 }
John Fastabendb929d862014-09-12 20:09:49 -0700321 kfree_rcu(data, rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322}
323
324static int rsvp_delete(struct tcf_proto *tp, unsigned long arg)
325{
John Fastabendb929d862014-09-12 20:09:49 -0700326 struct rsvp_head *head = rtnl_dereference(tp->root);
327 struct rsvp_filter *nfp, *f = (struct rsvp_filter *)arg;
328 struct rsvp_filter __rcu **fp;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000329 unsigned int h = f->handle;
John Fastabendb929d862014-09-12 20:09:49 -0700330 struct rsvp_session __rcu **sp;
331 struct rsvp_session *nsp, *s = f->sess;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 int i;
333
John Fastabendb929d862014-09-12 20:09:49 -0700334 fp = &s->ht[(h >> 8) & 0xFF];
335 for (nfp = rtnl_dereference(*fp); nfp;
336 fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
337 if (nfp == f) {
338 RCU_INIT_POINTER(*fp, f->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 rsvp_delete_filter(tp, f);
340
341 /* Strip tree */
342
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000343 for (i = 0; i <= 16; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 if (s->ht[i])
345 return 0;
346
347 /* OK, session has no flows */
John Fastabendb929d862014-09-12 20:09:49 -0700348 sp = &head->ht[h & 0xFF];
349 for (nsp = rtnl_dereference(*sp); nsp;
350 sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
351 if (nsp == s) {
352 RCU_INIT_POINTER(*sp, s->next);
353 kfree_rcu(s, rcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return 0;
355 }
356 }
357
358 return 0;
359 }
360 }
361 return 0;
362}
363
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000364static unsigned int gen_handle(struct tcf_proto *tp, unsigned salt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
John Fastabendb929d862014-09-12 20:09:49 -0700366 struct rsvp_head *data = rtnl_dereference(tp->root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 int i = 0xFFFF;
368
369 while (i-- > 0) {
370 u32 h;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if ((data->hgenerator += 0x10000) == 0)
373 data->hgenerator = 0x10000;
374 h = data->hgenerator|salt;
375 if (rsvp_get(tp, h) == 0)
376 return h;
377 }
378 return 0;
379}
380
381static int tunnel_bts(struct rsvp_head *data)
382{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000383 int n = data->tgenerator >> 5;
384 u32 b = 1 << (data->tgenerator & 0x1F);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900385
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000386 if (data->tmap[n] & b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 return 0;
388 data->tmap[n] |= b;
389 return 1;
390}
391
392static void tunnel_recycle(struct rsvp_head *data)
393{
John Fastabendb929d862014-09-12 20:09:49 -0700394 struct rsvp_session __rcu **sht = data->ht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 u32 tmap[256/32];
396 int h1, h2;
397
398 memset(tmap, 0, sizeof(tmap));
399
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000400 for (h1 = 0; h1 < 256; h1++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 struct rsvp_session *s;
John Fastabendb929d862014-09-12 20:09:49 -0700402 for (s = rtnl_dereference(sht[h1]); s;
403 s = rtnl_dereference(s->next)) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000404 for (h2 = 0; h2 <= 16; h2++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 struct rsvp_filter *f;
406
John Fastabendb929d862014-09-12 20:09:49 -0700407 for (f = rtnl_dereference(s->ht[h2]); f;
408 f = rtnl_dereference(f->next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 if (f->tunnelhdr == 0)
410 continue;
411 data->tgenerator = f->res.classid;
412 tunnel_bts(data);
413 }
414 }
415 }
416 }
417
418 memcpy(data->tmap, tmap, sizeof(tmap));
419}
420
421static u32 gen_tunnel(struct rsvp_head *data)
422{
423 int i, k;
424
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000425 for (k = 0; k < 2; k++) {
426 for (i = 255; i > 0; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (++data->tgenerator == 0)
428 data->tgenerator = 1;
429 if (tunnel_bts(data))
430 return data->tgenerator;
431 }
432 tunnel_recycle(data);
433 }
434 return 0;
435}
436
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800437static const struct nla_policy rsvp_policy[TCA_RSVP_MAX + 1] = {
438 [TCA_RSVP_CLASSID] = { .type = NLA_U32 },
439 [TCA_RSVP_DST] = { .type = NLA_BINARY,
440 .len = RSVP_DST_LEN * sizeof(u32) },
441 [TCA_RSVP_SRC] = { .type = NLA_BINARY,
442 .len = RSVP_DST_LEN * sizeof(u32) },
443 [TCA_RSVP_PINFO] = { .len = sizeof(struct tc_rsvp_pinfo) },
444};
445
Benjamin LaHaisec1b52732013-01-14 05:15:39 +0000446static int rsvp_change(struct net *net, struct sk_buff *in_skb,
Eric W. Biedermanaf4c6642012-05-25 13:42:45 -0600447 struct tcf_proto *tp, unsigned long base,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 u32 handle,
Patrick McHardyadd93b62008-01-22 22:11:33 -0800449 struct nlattr **tca,
Cong Wang2f7ef2f2014-04-25 13:54:06 -0700450 unsigned long *arg, bool ovr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
John Fastabendb929d862014-09-12 20:09:49 -0700452 struct rsvp_head *data = rtnl_dereference(tp->root);
453 struct rsvp_filter *f, *nfp;
454 struct rsvp_filter __rcu **fp;
455 struct rsvp_session *nsp, *s;
456 struct rsvp_session __rcu **sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 struct tc_rsvp_pinfo *pinfo = NULL;
Igor Maravić27e95a82011-08-30 03:12:55 +0000458 struct nlattr *opt = tca[TCA_OPTIONS];
Patrick McHardyadd93b62008-01-22 22:11:33 -0800459 struct nlattr *tb[TCA_RSVP_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 struct tcf_exts e;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000461 unsigned int h1, h2;
Al Viro66c6f522006-11-20 18:07:51 -0800462 __be32 *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 int err;
464
465 if (opt == NULL)
466 return handle ? -EINVAL : 0;
467
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800468 err = nla_parse_nested(tb, TCA_RSVP_MAX, opt, rsvp_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800469 if (err < 0)
470 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
WANG Cong5da57f42013-12-15 20:15:07 -0800472 tcf_exts_init(&e, TCA_RSVP_ACT, TCA_RSVP_POLICE);
Cong Wang2f7ef2f2014-04-25 13:54:06 -0700473 err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, ovr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (err < 0)
475 return err;
476
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000477 f = (struct rsvp_filter *)*arg;
478 if (f) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 /* Node exists: adjust only classid */
John Fastabend53dfd502014-09-26 10:02:50 -0700480 struct rsvp_filter *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 if (f->handle != handle && handle)
483 goto errout2;
John Fastabend53dfd502014-09-26 10:02:50 -0700484
485 n = kmemdup(f, sizeof(*f), GFP_KERNEL);
486 if (!n) {
487 err = -ENOMEM;
488 goto errout2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 }
490
John Fastabend53dfd502014-09-26 10:02:50 -0700491 tcf_exts_init(&n->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
492
493 if (tb[TCA_RSVP_CLASSID]) {
494 n->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
495 tcf_bind_filter(tp, &n->res, base);
496 }
497
498 tcf_exts_change(tp, &n->exts, &e);
499 rsvp_replace(tp, n, handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 return 0;
501 }
502
503 /* Now more serious part... */
504 err = -EINVAL;
505 if (handle)
506 goto errout2;
Igor Maravić27e95a82011-08-30 03:12:55 +0000507 if (tb[TCA_RSVP_DST] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 goto errout2;
509
510 err = -ENOBUFS;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700511 f = kzalloc(sizeof(struct rsvp_filter), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 if (f == NULL)
513 goto errout2;
514
WANG Cong5da57f42013-12-15 20:15:07 -0800515 tcf_exts_init(&f->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 h2 = 16;
Igor Maravić27e95a82011-08-30 03:12:55 +0000517 if (tb[TCA_RSVP_SRC]) {
518 memcpy(f->src, nla_data(tb[TCA_RSVP_SRC]), sizeof(f->src));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 h2 = hash_src(f->src);
520 }
Igor Maravić27e95a82011-08-30 03:12:55 +0000521 if (tb[TCA_RSVP_PINFO]) {
522 pinfo = nla_data(tb[TCA_RSVP_PINFO]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 f->spi = pinfo->spi;
524 f->tunnelhdr = pinfo->tunnelhdr;
525 }
Igor Maravić27e95a82011-08-30 03:12:55 +0000526 if (tb[TCA_RSVP_CLASSID])
527 f->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Igor Maravić27e95a82011-08-30 03:12:55 +0000529 dst = nla_data(tb[TCA_RSVP_DST]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 h1 = hash_dst(dst, pinfo ? pinfo->protocol : 0, pinfo ? pinfo->tunnelid : 0);
531
532 err = -ENOMEM;
533 if ((f->handle = gen_handle(tp, h1 | (h2<<8))) == 0)
534 goto errout;
535
536 if (f->tunnelhdr) {
537 err = -EINVAL;
538 if (f->res.classid > 255)
539 goto errout;
540
541 err = -ENOMEM;
542 if (f->res.classid == 0 &&
543 (f->res.classid = gen_tunnel(data)) == 0)
544 goto errout;
545 }
546
John Fastabendb929d862014-09-12 20:09:49 -0700547 for (sp = &data->ht[h1];
548 (s = rtnl_dereference(*sp)) != NULL;
549 sp = &s->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] &&
551 pinfo && pinfo->protocol == s->protocol &&
Joe Perchesf64f9e72009-11-29 16:55:45 -0800552 memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553#if RSVP_DST_LEN == 4
Joe Perchesf64f9e72009-11-29 16:55:45 -0800554 dst[0] == s->dst[0] &&
555 dst[1] == s->dst[1] &&
556 dst[2] == s->dst[2] &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557#endif
Joe Perchesf64f9e72009-11-29 16:55:45 -0800558 pinfo->tunnelid == s->tunnelid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560insert:
561 /* OK, we found appropriate session */
562
563 fp = &s->ht[h2];
564
565 f->sess = s;
566 if (f->tunnelhdr == 0)
567 tcf_bind_filter(tp, &f->res, base);
568
569 tcf_exts_change(tp, &f->exts, &e);
570
John Fastabendb929d862014-09-12 20:09:49 -0700571 fp = &s->ht[h2];
572 for (nfp = rtnl_dereference(*fp); nfp;
573 fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
574 __u32 mask = nfp->spi.mask & f->spi.mask;
575
576 if (mask != f->spi.mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 break;
John Fastabendb929d862014-09-12 20:09:49 -0700578 }
579 RCU_INIT_POINTER(f->next, nfp);
580 rcu_assign_pointer(*fp, f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 *arg = (unsigned long)f;
583 return 0;
584 }
585 }
586
587 /* No session found. Create new one. */
588
589 err = -ENOBUFS;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700590 s = kzalloc(sizeof(struct rsvp_session), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 if (s == NULL)
592 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 memcpy(s->dst, dst, sizeof(s->dst));
594
595 if (pinfo) {
596 s->dpi = pinfo->dpi;
597 s->protocol = pinfo->protocol;
598 s->tunnelid = pinfo->tunnelid;
599 }
John Fastabendb929d862014-09-12 20:09:49 -0700600 sp = &data->ht[h1];
601 for (nsp = rtnl_dereference(*sp); nsp;
602 sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
603 if ((nsp->dpi.mask & s->dpi.mask) != s->dpi.mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 break;
605 }
John Fastabendb929d862014-09-12 20:09:49 -0700606 RCU_INIT_POINTER(s->next, nsp);
607 rcu_assign_pointer(*sp, s);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 goto insert;
610
611errout:
Jesper Juhla51482b2005-11-08 09:41:34 -0800612 kfree(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613errout2:
WANG Cong18d02642014-09-25 10:26:37 -0700614 tcf_exts_destroy(&e);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 return err;
616}
617
618static void rsvp_walk(struct tcf_proto *tp, struct tcf_walker *arg)
619{
John Fastabendb929d862014-09-12 20:09:49 -0700620 struct rsvp_head *head = rtnl_dereference(tp->root);
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000621 unsigned int h, h1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623 if (arg->stop)
624 return;
625
626 for (h = 0; h < 256; h++) {
627 struct rsvp_session *s;
628
John Fastabendb929d862014-09-12 20:09:49 -0700629 for (s = rtnl_dereference(head->ht[h]); s;
630 s = rtnl_dereference(s->next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 for (h1 = 0; h1 <= 16; h1++) {
632 struct rsvp_filter *f;
633
John Fastabendb929d862014-09-12 20:09:49 -0700634 for (f = rtnl_dereference(s->ht[h1]); f;
635 f = rtnl_dereference(f->next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 if (arg->count < arg->skip) {
637 arg->count++;
638 continue;
639 }
640 if (arg->fn(tp, (unsigned long)f, arg) < 0) {
641 arg->stop = 1;
642 return;
643 }
644 arg->count++;
645 }
646 }
647 }
648 }
649}
650
WANG Cong832d1d52014-01-09 16:14:01 -0800651static int rsvp_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 struct sk_buff *skb, struct tcmsg *t)
653{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000654 struct rsvp_filter *f = (struct rsvp_filter *)fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 struct rsvp_session *s;
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800656 struct nlattr *nest;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 struct tc_rsvp_pinfo pinfo;
658
659 if (f == NULL)
660 return skb->len;
661 s = f->sess;
662
663 t->tcm_handle = f->handle;
664
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800665 nest = nla_nest_start(skb, TCA_OPTIONS);
666 if (nest == NULL)
667 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
David S. Miller1b34ec42012-03-29 05:11:39 -0400669 if (nla_put(skb, TCA_RSVP_DST, sizeof(s->dst), &s->dst))
670 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 pinfo.dpi = s->dpi;
672 pinfo.spi = f->spi;
673 pinfo.protocol = s->protocol;
674 pinfo.tunnelid = s->tunnelid;
675 pinfo.tunnelhdr = f->tunnelhdr;
Patrick McHardy8a470772005-06-28 12:56:45 -0700676 pinfo.pad = 0;
David S. Miller1b34ec42012-03-29 05:11:39 -0400677 if (nla_put(skb, TCA_RSVP_PINFO, sizeof(pinfo), &pinfo))
678 goto nla_put_failure;
679 if (f->res.classid &&
680 nla_put_u32(skb, TCA_RSVP_CLASSID, f->res.classid))
681 goto nla_put_failure;
682 if (((f->handle >> 8) & 0xFF) != 16 &&
683 nla_put(skb, TCA_RSVP_SRC, sizeof(f->src), f->src))
684 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
WANG Cong5da57f42013-12-15 20:15:07 -0800686 if (tcf_exts_dump(skb, &f->exts) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800687 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800689 nla_nest_end(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
WANG Cong5da57f42013-12-15 20:15:07 -0800691 if (tcf_exts_dump_stats(skb, &f->exts) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800692 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 return skb->len;
694
Patrick McHardyadd93b62008-01-22 22:11:33 -0800695nla_put_failure:
Jiri Pirko6ea3b442014-12-09 22:23:29 +0100696 nla_nest_cancel(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 return -1;
698}
699
Igor Maravić27e95a82011-08-30 03:12:55 +0000700static struct tcf_proto_ops RSVP_OPS __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 .kind = RSVP_ID,
702 .classify = rsvp_classify,
703 .init = rsvp_init,
704 .destroy = rsvp_destroy,
705 .get = rsvp_get,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 .change = rsvp_change,
707 .delete = rsvp_delete,
708 .walk = rsvp_walk,
709 .dump = rsvp_dump,
710 .owner = THIS_MODULE,
711};
712
713static int __init init_rsvp(void)
714{
715 return register_tcf_proto_ops(&RSVP_OPS);
716}
717
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900718static void __exit exit_rsvp(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719{
720 unregister_tcf_proto_ops(&RSVP_OPS);
721}
722
723module_init(init_rsvp)
724module_exit(exit_rsvp)