blob: b01427924f8112dd0b923287976f285fd7674fbf [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;
73 struct rsvp_session *ht[256];
74};
75
Eric Dumazetcc7ec452011-01-19 19:26:56 +000076struct rsvp_session {
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 struct rsvp_session *next;
Al Viro66c6f522006-11-20 18:07:51 -080078 __be32 dst[RSVP_DST_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 struct tc_rsvp_gpi dpi;
80 u8 protocol;
81 u8 tunnelid;
82 /* 16 (src,sport) hash slots, and one wildcard source slot */
Eric Dumazetcc7ec452011-01-19 19:26:56 +000083 struct rsvp_filter *ht[16 + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -070084};
85
86
Eric Dumazetcc7ec452011-01-19 19:26:56 +000087struct rsvp_filter {
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 struct rsvp_filter *next;
Al Viro66c6f522006-11-20 18:07:51 -080089 __be32 src[RSVP_DST_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 struct tc_rsvp_gpi spi;
91 u8 tunnelhdr;
92
93 struct tcf_result res;
94 struct tcf_exts exts;
95
96 u32 handle;
97 struct rsvp_session *sess;
98};
99
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000100static inline unsigned int hash_dst(__be32 *dst, u8 protocol, u8 tunnelid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000102 unsigned int h = (__force __u32)dst[RSVP_DST_LEN - 1];
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 h ^= h>>16;
105 h ^= h>>8;
106 return (h ^ protocol ^ tunnelid) & 0xFF;
107}
108
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000109static inline unsigned int hash_src(__be32 *src)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000111 unsigned int h = (__force __u32)src[RSVP_DST_LEN-1];
112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 h ^= h>>16;
114 h ^= h>>8;
115 h ^= h>>4;
116 return h & 0xF;
117}
118
119static struct tcf_ext_map rsvp_ext_map = {
120 .police = TCA_RSVP_POLICE,
121 .action = TCA_RSVP_ACT
122};
123
124#define RSVP_APPLY_RESULT() \
125{ \
126 int r = tcf_exts_exec(skb, &f->exts, res); \
127 if (r < 0) \
128 continue; \
129 else if (r > 0) \
130 return r; \
131}
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900132
Eric Dumazetdc7f9f62011-07-05 23:25:42 +0000133static int rsvp_classify(struct sk_buff *skb, const struct tcf_proto *tp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 struct tcf_result *res)
135{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000136 struct rsvp_session **sht = ((struct rsvp_head *)tp->root)->ht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct rsvp_session *s;
138 struct rsvp_filter *f;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000139 unsigned int h1, h2;
Al Viro66c6f522006-11-20 18:07:51 -0800140 __be32 *dst, *src;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 u8 protocol;
142 u8 tunnelid = 0;
143 u8 *xprt;
144#if RSVP_DST_LEN == 4
Changli Gao12dc96d2010-08-04 04:55:40 +0000145 struct ipv6hdr *nhptr;
146
147 if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
148 return -1;
149 nhptr = ipv6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150#else
Changli Gao12dc96d2010-08-04 04:55:40 +0000151 struct iphdr *nhptr;
152
153 if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
154 return -1;
155 nhptr = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156#endif
157
158restart:
159
160#if RSVP_DST_LEN == 4
161 src = &nhptr->saddr.s6_addr32[0];
162 dst = &nhptr->daddr.s6_addr32[0];
163 protocol = nhptr->nexthdr;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000164 xprt = ((u8 *)nhptr) + sizeof(struct ipv6hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165#else
166 src = &nhptr->saddr;
167 dst = &nhptr->daddr;
168 protocol = nhptr->protocol;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000169 xprt = ((u8 *)nhptr) + (nhptr->ihl<<2);
Paul Gortmaker56f8a752011-06-21 20:33:34 -0700170 if (ip_is_fragment(nhptr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return -1;
172#endif
173
174 h1 = hash_dst(dst, protocol, tunnelid);
175 h2 = hash_src(src);
176
177 for (s = sht[h1]; s; s = s->next) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000178 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN - 1] &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 protocol == s->protocol &&
Joe Perchesf64f9e72009-11-29 16:55:45 -0800180 !(s->dpi.mask &
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000181 (*(u32 *)(xprt + s->dpi.offset) ^ s->dpi.key)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182#if RSVP_DST_LEN == 4
Joe Perchesf64f9e72009-11-29 16:55:45 -0800183 dst[0] == s->dst[0] &&
184 dst[1] == s->dst[1] &&
185 dst[2] == s->dst[2] &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186#endif
Joe Perchesf64f9e72009-11-29 16:55:45 -0800187 tunnelid == s->tunnelid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 for (f = s->ht[h2]; f; f = 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... */
213 for (f = s->ht[16]; f; f = f->next) {
214 *res = f->res;
215 RSVP_APPLY_RESULT();
216 goto matched;
217 }
218 return -1;
219 }
220 }
221 return -1;
222}
223
224static unsigned long rsvp_get(struct tcf_proto *tp, u32 handle)
225{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000226 struct rsvp_session **sht = ((struct rsvp_head *)tp->root)->ht;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 struct rsvp_session *s;
228 struct rsvp_filter *f;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000229 unsigned int h1 = handle & 0xFF;
230 unsigned int h2 = (handle >> 8) & 0xFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
232 if (h2 > 16)
233 return 0;
234
235 for (s = sht[h1]; s; s = s->next) {
236 for (f = s->ht[h2]; f; f = f->next) {
237 if (f->handle == handle)
238 return (unsigned long)f;
239 }
240 }
241 return 0;
242}
243
244static void rsvp_put(struct tcf_proto *tp, unsigned long f)
245{
246}
247
248static int rsvp_init(struct tcf_proto *tp)
249{
250 struct rsvp_head *data;
251
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700252 data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 if (data) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 tp->root = data;
255 return 0;
256 }
257 return -ENOBUFS;
258}
259
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000260static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)
262{
263 tcf_unbind_filter(tp, &f->res);
264 tcf_exts_destroy(tp, &f->exts);
265 kfree(f);
266}
267
268static void rsvp_destroy(struct tcf_proto *tp)
269{
270 struct rsvp_head *data = xchg(&tp->root, NULL);
271 struct rsvp_session **sht;
272 int h1, h2;
273
274 if (data == NULL)
275 return;
276
277 sht = data->ht;
278
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000279 for (h1 = 0; h1 < 256; h1++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 struct rsvp_session *s;
281
282 while ((s = sht[h1]) != NULL) {
283 sht[h1] = s->next;
284
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000285 for (h2 = 0; h2 <= 16; h2++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 struct rsvp_filter *f;
287
288 while ((f = s->ht[h2]) != NULL) {
289 s->ht[h2] = f->next;
290 rsvp_delete_filter(tp, f);
291 }
292 }
293 kfree(s);
294 }
295 }
296 kfree(data);
297}
298
299static int rsvp_delete(struct tcf_proto *tp, unsigned long arg)
300{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000301 struct rsvp_filter **fp, *f = (struct rsvp_filter *)arg;
302 unsigned int h = f->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 struct rsvp_session **sp;
304 struct rsvp_session *s = f->sess;
305 int i;
306
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000307 for (fp = &s->ht[(h >> 8) & 0xFF]; *fp; fp = &(*fp)->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 if (*fp == f) {
309 tcf_tree_lock(tp);
310 *fp = f->next;
311 tcf_tree_unlock(tp);
312 rsvp_delete_filter(tp, f);
313
314 /* Strip tree */
315
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000316 for (i = 0; i <= 16; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 if (s->ht[i])
318 return 0;
319
320 /* OK, session has no flows */
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000321 for (sp = &((struct rsvp_head *)tp->root)->ht[h & 0xFF];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 *sp; sp = &(*sp)->next) {
323 if (*sp == s) {
324 tcf_tree_lock(tp);
325 *sp = s->next;
326 tcf_tree_unlock(tp);
327
328 kfree(s);
329 return 0;
330 }
331 }
332
333 return 0;
334 }
335 }
336 return 0;
337}
338
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000339static unsigned int gen_handle(struct tcf_proto *tp, unsigned salt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 struct rsvp_head *data = tp->root;
342 int i = 0xFFFF;
343
344 while (i-- > 0) {
345 u32 h;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 if ((data->hgenerator += 0x10000) == 0)
348 data->hgenerator = 0x10000;
349 h = data->hgenerator|salt;
350 if (rsvp_get(tp, h) == 0)
351 return h;
352 }
353 return 0;
354}
355
356static int tunnel_bts(struct rsvp_head *data)
357{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000358 int n = data->tgenerator >> 5;
359 u32 b = 1 << (data->tgenerator & 0x1F);
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900360
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000361 if (data->tmap[n] & b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return 0;
363 data->tmap[n] |= b;
364 return 1;
365}
366
367static void tunnel_recycle(struct rsvp_head *data)
368{
369 struct rsvp_session **sht = data->ht;
370 u32 tmap[256/32];
371 int h1, h2;
372
373 memset(tmap, 0, sizeof(tmap));
374
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000375 for (h1 = 0; h1 < 256; h1++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 struct rsvp_session *s;
377 for (s = sht[h1]; s; s = s->next) {
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000378 for (h2 = 0; h2 <= 16; h2++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 struct rsvp_filter *f;
380
381 for (f = s->ht[h2]; f; f = f->next) {
382 if (f->tunnelhdr == 0)
383 continue;
384 data->tgenerator = f->res.classid;
385 tunnel_bts(data);
386 }
387 }
388 }
389 }
390
391 memcpy(data->tmap, tmap, sizeof(tmap));
392}
393
394static u32 gen_tunnel(struct rsvp_head *data)
395{
396 int i, k;
397
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000398 for (k = 0; k < 2; k++) {
399 for (i = 255; i > 0; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 if (++data->tgenerator == 0)
401 data->tgenerator = 1;
402 if (tunnel_bts(data))
403 return data->tgenerator;
404 }
405 tunnel_recycle(data);
406 }
407 return 0;
408}
409
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800410static const struct nla_policy rsvp_policy[TCA_RSVP_MAX + 1] = {
411 [TCA_RSVP_CLASSID] = { .type = NLA_U32 },
412 [TCA_RSVP_DST] = { .type = NLA_BINARY,
413 .len = RSVP_DST_LEN * sizeof(u32) },
414 [TCA_RSVP_SRC] = { .type = NLA_BINARY,
415 .len = RSVP_DST_LEN * sizeof(u32) },
416 [TCA_RSVP_PINFO] = { .len = sizeof(struct tc_rsvp_pinfo) },
417};
418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419static int rsvp_change(struct tcf_proto *tp, unsigned long base,
420 u32 handle,
Patrick McHardyadd93b62008-01-22 22:11:33 -0800421 struct nlattr **tca,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 unsigned long *arg)
423{
424 struct rsvp_head *data = tp->root;
425 struct rsvp_filter *f, **fp;
426 struct rsvp_session *s, **sp;
427 struct tc_rsvp_pinfo *pinfo = NULL;
Igor Maravić27e95a82011-08-30 03:12:55 +0000428 struct nlattr *opt = tca[TCA_OPTIONS];
Patrick McHardyadd93b62008-01-22 22:11:33 -0800429 struct nlattr *tb[TCA_RSVP_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 struct tcf_exts e;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000431 unsigned int h1, h2;
Al Viro66c6f522006-11-20 18:07:51 -0800432 __be32 *dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 int err;
434
435 if (opt == NULL)
436 return handle ? -EINVAL : 0;
437
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800438 err = nla_parse_nested(tb, TCA_RSVP_MAX, opt, rsvp_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800439 if (err < 0)
440 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Igor Maravić27e95a82011-08-30 03:12:55 +0000442 err = tcf_exts_validate(tp, tb, tca[TCA_RATE], &e, &rsvp_ext_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 if (err < 0)
444 return err;
445
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000446 f = (struct rsvp_filter *)*arg;
447 if (f) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 /* Node exists: adjust only classid */
449
450 if (f->handle != handle && handle)
451 goto errout2;
Igor Maravić27e95a82011-08-30 03:12:55 +0000452 if (tb[TCA_RSVP_CLASSID]) {
453 f->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 tcf_bind_filter(tp, &f->res, base);
455 }
456
457 tcf_exts_change(tp, &f->exts, &e);
458 return 0;
459 }
460
461 /* Now more serious part... */
462 err = -EINVAL;
463 if (handle)
464 goto errout2;
Igor Maravić27e95a82011-08-30 03:12:55 +0000465 if (tb[TCA_RSVP_DST] == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 goto errout2;
467
468 err = -ENOBUFS;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700469 f = kzalloc(sizeof(struct rsvp_filter), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 if (f == NULL)
471 goto errout2;
472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 h2 = 16;
Igor Maravić27e95a82011-08-30 03:12:55 +0000474 if (tb[TCA_RSVP_SRC]) {
475 memcpy(f->src, nla_data(tb[TCA_RSVP_SRC]), sizeof(f->src));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 h2 = hash_src(f->src);
477 }
Igor Maravić27e95a82011-08-30 03:12:55 +0000478 if (tb[TCA_RSVP_PINFO]) {
479 pinfo = nla_data(tb[TCA_RSVP_PINFO]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 f->spi = pinfo->spi;
481 f->tunnelhdr = pinfo->tunnelhdr;
482 }
Igor Maravić27e95a82011-08-30 03:12:55 +0000483 if (tb[TCA_RSVP_CLASSID])
484 f->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Igor Maravić27e95a82011-08-30 03:12:55 +0000486 dst = nla_data(tb[TCA_RSVP_DST]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 h1 = hash_dst(dst, pinfo ? pinfo->protocol : 0, pinfo ? pinfo->tunnelid : 0);
488
489 err = -ENOMEM;
490 if ((f->handle = gen_handle(tp, h1 | (h2<<8))) == 0)
491 goto errout;
492
493 if (f->tunnelhdr) {
494 err = -EINVAL;
495 if (f->res.classid > 255)
496 goto errout;
497
498 err = -ENOMEM;
499 if (f->res.classid == 0 &&
500 (f->res.classid = gen_tunnel(data)) == 0)
501 goto errout;
502 }
503
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000504 for (sp = &data->ht[h1]; (s = *sp) != NULL; sp = &s->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] &&
506 pinfo && pinfo->protocol == s->protocol &&
Joe Perchesf64f9e72009-11-29 16:55:45 -0800507 memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508#if RSVP_DST_LEN == 4
Joe Perchesf64f9e72009-11-29 16:55:45 -0800509 dst[0] == s->dst[0] &&
510 dst[1] == s->dst[1] &&
511 dst[2] == s->dst[2] &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512#endif
Joe Perchesf64f9e72009-11-29 16:55:45 -0800513 pinfo->tunnelid == s->tunnelid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515insert:
516 /* OK, we found appropriate session */
517
518 fp = &s->ht[h2];
519
520 f->sess = s;
521 if (f->tunnelhdr == 0)
522 tcf_bind_filter(tp, &f->res, base);
523
524 tcf_exts_change(tp, &f->exts, &e);
525
526 for (fp = &s->ht[h2]; *fp; fp = &(*fp)->next)
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000527 if (((*fp)->spi.mask & f->spi.mask) != f->spi.mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 break;
529 f->next = *fp;
530 wmb();
531 *fp = f;
532
533 *arg = (unsigned long)f;
534 return 0;
535 }
536 }
537
538 /* No session found. Create new one. */
539
540 err = -ENOBUFS;
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700541 s = kzalloc(sizeof(struct rsvp_session), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 if (s == NULL)
543 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 memcpy(s->dst, dst, sizeof(s->dst));
545
546 if (pinfo) {
547 s->dpi = pinfo->dpi;
548 s->protocol = pinfo->protocol;
549 s->tunnelid = pinfo->tunnelid;
550 }
551 for (sp = &data->ht[h1]; *sp; sp = &(*sp)->next) {
552 if (((*sp)->dpi.mask&s->dpi.mask) != s->dpi.mask)
553 break;
554 }
555 s->next = *sp;
556 wmb();
557 *sp = s;
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900558
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 goto insert;
560
561errout:
Jesper Juhla51482b2005-11-08 09:41:34 -0800562 kfree(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563errout2:
564 tcf_exts_destroy(tp, &e);
565 return err;
566}
567
568static void rsvp_walk(struct tcf_proto *tp, struct tcf_walker *arg)
569{
570 struct rsvp_head *head = tp->root;
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000571 unsigned int h, h1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 if (arg->stop)
574 return;
575
576 for (h = 0; h < 256; h++) {
577 struct rsvp_session *s;
578
579 for (s = head->ht[h]; s; s = s->next) {
580 for (h1 = 0; h1 <= 16; h1++) {
581 struct rsvp_filter *f;
582
583 for (f = s->ht[h1]; f; f = f->next) {
584 if (arg->count < arg->skip) {
585 arg->count++;
586 continue;
587 }
588 if (arg->fn(tp, (unsigned long)f, arg) < 0) {
589 arg->stop = 1;
590 return;
591 }
592 arg->count++;
593 }
594 }
595 }
596 }
597}
598
599static int rsvp_dump(struct tcf_proto *tp, unsigned long fh,
600 struct sk_buff *skb, struct tcmsg *t)
601{
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000602 struct rsvp_filter *f = (struct rsvp_filter *)fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 struct rsvp_session *s;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700604 unsigned char *b = skb_tail_pointer(skb);
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800605 struct nlattr *nest;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 struct tc_rsvp_pinfo pinfo;
607
608 if (f == NULL)
609 return skb->len;
610 s = f->sess;
611
612 t->tcm_handle = f->handle;
613
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800614 nest = nla_nest_start(skb, TCA_OPTIONS);
615 if (nest == NULL)
616 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
Patrick McHardyadd93b62008-01-22 22:11:33 -0800618 NLA_PUT(skb, TCA_RSVP_DST, sizeof(s->dst), &s->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 pinfo.dpi = s->dpi;
620 pinfo.spi = f->spi;
621 pinfo.protocol = s->protocol;
622 pinfo.tunnelid = s->tunnelid;
623 pinfo.tunnelhdr = f->tunnelhdr;
Patrick McHardy8a470772005-06-28 12:56:45 -0700624 pinfo.pad = 0;
Patrick McHardyadd93b62008-01-22 22:11:33 -0800625 NLA_PUT(skb, TCA_RSVP_PINFO, sizeof(pinfo), &pinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 if (f->res.classid)
Patrick McHardy24beeab2008-01-23 20:34:48 -0800627 NLA_PUT_U32(skb, TCA_RSVP_CLASSID, f->res.classid);
Eric Dumazetcc7ec452011-01-19 19:26:56 +0000628 if (((f->handle >> 8) & 0xFF) != 16)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800629 NLA_PUT(skb, TCA_RSVP_SRC, sizeof(f->src), f->src);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
631 if (tcf_exts_dump(skb, &f->exts, &rsvp_ext_map) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800632 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800634 nla_nest_end(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
636 if (tcf_exts_dump_stats(skb, &f->exts, &rsvp_ext_map) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800637 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 return skb->len;
639
Patrick McHardyadd93b62008-01-22 22:11:33 -0800640nla_put_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700641 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return -1;
643}
644
Igor Maravić27e95a82011-08-30 03:12:55 +0000645static struct tcf_proto_ops RSVP_OPS __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 .kind = RSVP_ID,
647 .classify = rsvp_classify,
648 .init = rsvp_init,
649 .destroy = rsvp_destroy,
650 .get = rsvp_get,
651 .put = rsvp_put,
652 .change = rsvp_change,
653 .delete = rsvp_delete,
654 .walk = rsvp_walk,
655 .dump = rsvp_dump,
656 .owner = THIS_MODULE,
657};
658
659static int __init init_rsvp(void)
660{
661 return register_tcf_proto_ops(&RSVP_OPS);
662}
663
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900664static void __exit exit_rsvp(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
666 unregister_tcf_proto_ops(&RSVP_OPS);
667}
668
669module_init(init_rsvp)
670module_exit(exit_rsvp)