?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.1.16
[linux/fpc-iii.git] / net / sched / cls_rsvp.h
blob02fa82792dab8334d1dc14408f7ed42a4db0c141
1 /*
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
68
69 struct rsvp_head {
70 u32 tmap[256/32];
71 u32 hgenerator;
72 u8 tgenerator;
73 struct rsvp_session __rcu *ht[256];
74 struct rcu_head rcu;
75 };
76
77 struct rsvp_session {
78 struct rsvp_session __rcu *next;
79 __be32 dst[RSVP_DST_LEN];
80 struct tc_rsvp_gpi dpi;
81 u8 protocol;
82 u8 tunnelid;
83 /* 16 (src,sport) hash slots, and one wildcard source slot */
84 struct rsvp_filter __rcu *ht[16 + 1];
85 struct rcu_head rcu;
86 };
87
88
89 struct rsvp_filter {
90 struct rsvp_filter __rcu *next;
91 __be32 src[RSVP_DST_LEN];
92 struct tc_rsvp_gpi spi;
93 u8 tunnelhdr;
94
95 struct tcf_result res;
96 struct tcf_exts exts;
97
98 u32 handle;
99 struct rsvp_session *sess;
100 struct rcu_head rcu;
101 };
102
103 static inline unsigned int hash_dst(__be32 *dst, u8 protocol, u8 tunnelid)
104 {
105 unsigned int h = (__force __u32)dst[RSVP_DST_LEN - 1];
106
107 h ^= h>>16;
108 h ^= h>>8;
109 return (h ^ protocol ^ tunnelid) & 0xFF;
110 }
111
112 static inline unsigned int hash_src(__be32 *src)
113 {
114 unsigned int h = (__force __u32)src[RSVP_DST_LEN-1];
115
116 h ^= h>>16;
117 h ^= h>>8;
118 h ^= h>>4;
119 return h & 0xF;
120 }
121
122 #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 }
130
131 static int rsvp_classify(struct sk_buff *skb, const struct tcf_proto *tp,
132 struct tcf_result *res)
133 {
134 struct rsvp_head *head = rcu_dereference_bh(tp->root);
135 struct rsvp_session *s;
136 struct rsvp_filter *f;
137 unsigned int h1, h2;
138 __be32 *dst, *src;
139 u8 protocol;
140 u8 tunnelid = 0;
141 u8 *xprt;
142 #if RSVP_DST_LEN == 4
143 struct ipv6hdr *nhptr;
144
145 if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
146 return -1;
147 nhptr = ipv6_hdr(skb);
148 #else
149 struct iphdr *nhptr;
150
151 if (!pskb_network_may_pull(skb, sizeof(*nhptr)))
152 return -1;
153 nhptr = ip_hdr(skb);
154 #endif
155
156 restart:
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;
162 xprt = ((u8 *)nhptr) + sizeof(struct ipv6hdr);
163 #else
164 src = &nhptr->saddr;
165 dst = &nhptr->daddr;
166 protocol = nhptr->protocol;
167 xprt = ((u8 *)nhptr) + (nhptr->ihl<<2);
168 if (ip_is_fragment(nhptr))
169 return -1;
170 #endif
171
172 h1 = hash_dst(dst, protocol, tunnelid);
173 h2 = hash_src(src);
174
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 &&
179 !(s->dpi.mask &
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] &&
185 #endif
186 tunnelid == s->tunnelid) {
187
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
193 &&
194 src[0] == f->src[0] &&
195 src[1] == f->src[1] &&
196 src[2] == f->src[2]
197 #endif
198 ) {
199 *res = f->res;
200 RSVP_APPLY_RESULT();
201
202 matched:
203 if (f->tunnelhdr == 0)
204 return 0;
205
206 tunnelid = f->res.classid;
207 nhptr = (void *)(xprt + f->tunnelhdr - sizeof(*nhptr));
208 goto restart;
209 }
210 }
211
212 /* And wildcard bucket... */
213 for (f = rcu_dereference_bh(s->ht[16]); f;
214 f = rcu_dereference_bh(f->next)) {
215 *res = f->res;
216 RSVP_APPLY_RESULT();
217 goto matched;
218 }
219 return -1;
220 }
221 }
222 return -1;
223 }
224
225 static 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
252 static unsigned long rsvp_get(struct tcf_proto *tp, u32 handle)
253 {
254 struct rsvp_head *head = rtnl_dereference(tp->root);
255 struct rsvp_session *s;
256 struct rsvp_filter *f;
257 unsigned int h1 = handle & 0xFF;
258 unsigned int h2 = (handle >> 8) & 0xFF;
259
260 if (h2 > 16)
261 return 0;
262
263 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)) {
267 if (f->handle == handle)
268 return (unsigned long)f;
269 }
270 }
271 return 0;
272 }
273
274 static int rsvp_init(struct tcf_proto *tp)
275 {
276 struct rsvp_head *data;
277
278 data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL);
279 if (data) {
280 rcu_assign_pointer(tp->root, data);
281 return 0;
282 }
283 return -ENOBUFS;
284 }
285
286 static void
287 rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)
288 {
289 tcf_unbind_filter(tp, &f->res);
290 tcf_exts_destroy(&f->exts);
291 kfree_rcu(f, rcu);
292 }
293
294 static bool rsvp_destroy(struct tcf_proto *tp, bool force)
295 {
296 struct rsvp_head *data = rtnl_dereference(tp->root);
297 int h1, h2;
298
299 if (data == NULL)
300 return true;
301
302 if (!force) {
303 for (h1 = 0; h1 < 256; h1++) {
304 if (rcu_access_pointer(data->ht[h1]))
305 return false;
306 }
307 }
308
309 RCU_INIT_POINTER(tp->root, NULL);
310
311 for (h1 = 0; h1 < 256; h1++) {
312 struct rsvp_session *s;
313
314 while ((s = rtnl_dereference(data->ht[h1])) != NULL) {
315 RCU_INIT_POINTER(data->ht[h1], s->next);
316
317 for (h2 = 0; h2 <= 16; h2++) {
318 struct rsvp_filter *f;
319
320 while ((f = rtnl_dereference(s->ht[h2])) != NULL) {
321 rcu_assign_pointer(s->ht[h2], f->next);
322 rsvp_delete_filter(tp, f);
323 }
324 }
325 kfree_rcu(s, rcu);
326 }
327 }
328 kfree_rcu(data, rcu);
329 return true;
330 }
331
332 static int rsvp_delete(struct tcf_proto *tp, unsigned long arg)
333 {
334 struct rsvp_head *head = rtnl_dereference(tp->root);
335 struct rsvp_filter *nfp, *f = (struct rsvp_filter *)arg;
336 struct rsvp_filter __rcu **fp;
337 unsigned int h = f->handle;
338 struct rsvp_session __rcu **sp;
339 struct rsvp_session *nsp, *s = f->sess;
340 int i;
341
342 fp = &s->ht[(h >> 8) & 0xFF];
343 for (nfp = rtnl_dereference(*fp); nfp;
344 fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
345 if (nfp == f) {
346 RCU_INIT_POINTER(*fp, f->next);
347 rsvp_delete_filter(tp, f);
348
349 /* Strip tree */
350
351 for (i = 0; i <= 16; i++)
352 if (s->ht[i])
353 return 0;
354
355 /* OK, session has no flows */
356 sp = &head->ht[h & 0xFF];
357 for (nsp = rtnl_dereference(*sp); nsp;
358 sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
359 if (nsp == s) {
360 RCU_INIT_POINTER(*sp, s->next);
361 kfree_rcu(s, rcu);
362 return 0;
363 }
364 }
365
366 return 0;
367 }
368 }
369 return 0;
370 }
371
372 static unsigned int gen_handle(struct tcf_proto *tp, unsigned salt)
373 {
374 struct rsvp_head *data = rtnl_dereference(tp->root);
375 int i = 0xFFFF;
376
377 while (i-- > 0) {
378 u32 h;
379
380 if ((data->hgenerator += 0x10000) == 0)
381 data->hgenerator = 0x10000;
382 h = data->hgenerator|salt;
383 if (rsvp_get(tp, h) == 0)
384 return h;
385 }
386 return 0;
387 }
388
389 static int tunnel_bts(struct rsvp_head *data)
390 {
391 int n = data->tgenerator >> 5;
392 u32 b = 1 << (data->tgenerator & 0x1F);
393
394 if (data->tmap[n] & b)
395 return 0;
396 data->tmap[n] |= b;
397 return 1;
398 }
399
400 static void tunnel_recycle(struct rsvp_head *data)
401 {
402 struct rsvp_session __rcu **sht = data->ht;
403 u32 tmap[256/32];
404 int h1, h2;
405
406 memset(tmap, 0, sizeof(tmap));
407
408 for (h1 = 0; h1 < 256; h1++) {
409 struct rsvp_session *s;
410 for (s = rtnl_dereference(sht[h1]); s;
411 s = rtnl_dereference(s->next)) {
412 for (h2 = 0; h2 <= 16; h2++) {
413 struct rsvp_filter *f;
414
415 for (f = rtnl_dereference(s->ht[h2]); f;
416 f = rtnl_dereference(f->next)) {
417 if (f->tunnelhdr == 0)
418 continue;
419 data->tgenerator = f->res.classid;
420 tunnel_bts(data);
421 }
422 }
423 }
424 }
425
426 memcpy(data->tmap, tmap, sizeof(tmap));
427 }
428
429 static u32 gen_tunnel(struct rsvp_head *data)
430 {
431 int i, k;
432
433 for (k = 0; k < 2; k++) {
434 for (i = 255; i > 0; i--) {
435 if (++data->tgenerator == 0)
436 data->tgenerator = 1;
437 if (tunnel_bts(data))
438 return data->tgenerator;
439 }
440 tunnel_recycle(data);
441 }
442 return 0;
443 }
444
445 static const struct nla_policy rsvp_policy[TCA_RSVP_MAX + 1] = {
446 [TCA_RSVP_CLASSID] = { .type = NLA_U32 },
447 [TCA_RSVP_DST] = { .type = NLA_BINARY,
448 .len = RSVP_DST_LEN * sizeof(u32) },
449 [TCA_RSVP_SRC] = { .type = NLA_BINARY,
450 .len = RSVP_DST_LEN * sizeof(u32) },
451 [TCA_RSVP_PINFO] = { .len = sizeof(struct tc_rsvp_pinfo) },
452 };
453
454 static int rsvp_change(struct net *net, struct sk_buff *in_skb,
455 struct tcf_proto *tp, unsigned long base,
456 u32 handle,
457 struct nlattr **tca,
458 unsigned long *arg, bool ovr)
459 {
460 struct rsvp_head *data = rtnl_dereference(tp->root);
461 struct rsvp_filter *f, *nfp;
462 struct rsvp_filter __rcu **fp;
463 struct rsvp_session *nsp, *s;
464 struct rsvp_session __rcu **sp;
465 struct tc_rsvp_pinfo *pinfo = NULL;
466 struct nlattr *opt = tca[TCA_OPTIONS];
467 struct nlattr *tb[TCA_RSVP_MAX + 1];
468 struct tcf_exts e;
469 unsigned int h1, h2;
470 __be32 *dst;
471 int err;
472
473 if (opt == NULL)
474 return handle ? -EINVAL : 0;
475
476 err = nla_parse_nested(tb, TCA_RSVP_MAX, opt, rsvp_policy);
477 if (err < 0)
478 return err;
479
480 tcf_exts_init(&e, TCA_RSVP_ACT, TCA_RSVP_POLICE);
481 err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, ovr);
482 if (err < 0)
483 return err;
484
485 f = (struct rsvp_filter *)*arg;
486 if (f) {
487 /* Node exists: adjust only classid */
488 struct rsvp_filter *n;
489
490 if (f->handle != handle && handle)
491 goto errout2;
492
493 n = kmemdup(f, sizeof(*f), GFP_KERNEL);
494 if (!n) {
495 err = -ENOMEM;
496 goto errout2;
497 }
498
499 tcf_exts_init(&n->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
500
501 if (tb[TCA_RSVP_CLASSID]) {
502 n->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
503 tcf_bind_filter(tp, &n->res, base);
504 }
505
506 tcf_exts_change(tp, &n->exts, &e);
507 rsvp_replace(tp, n, handle);
508 return 0;
509 }
510
511 /* Now more serious part... */
512 err = -EINVAL;
513 if (handle)
514 goto errout2;
515 if (tb[TCA_RSVP_DST] == NULL)
516 goto errout2;
517
518 err = -ENOBUFS;
519 f = kzalloc(sizeof(struct rsvp_filter), GFP_KERNEL);
520 if (f == NULL)
521 goto errout2;
522
523 tcf_exts_init(&f->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
524 h2 = 16;
525 if (tb[TCA_RSVP_SRC]) {
526 memcpy(f->src, nla_data(tb[TCA_RSVP_SRC]), sizeof(f->src));
527 h2 = hash_src(f->src);
528 }
529 if (tb[TCA_RSVP_PINFO]) {
530 pinfo = nla_data(tb[TCA_RSVP_PINFO]);
531 f->spi = pinfo->spi;
532 f->tunnelhdr = pinfo->tunnelhdr;
533 }
534 if (tb[TCA_RSVP_CLASSID])
535 f->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
536
537 dst = nla_data(tb[TCA_RSVP_DST]);
538 h1 = hash_dst(dst, pinfo ? pinfo->protocol : 0, pinfo ? pinfo->tunnelid : 0);
539
540 err = -ENOMEM;
541 if ((f->handle = gen_handle(tp, h1 | (h2<<8))) == 0)
542 goto errout;
543
544 if (f->tunnelhdr) {
545 err = -EINVAL;
546 if (f->res.classid > 255)
547 goto errout;
548
549 err = -ENOMEM;
550 if (f->res.classid == 0 &&
551 (f->res.classid = gen_tunnel(data)) == 0)
552 goto errout;
553 }
554
555 for (sp = &data->ht[h1];
556 (s = rtnl_dereference(*sp)) != NULL;
557 sp = &s->next) {
558 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] &&
559 pinfo && pinfo->protocol == s->protocol &&
560 memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 &&
561 #if RSVP_DST_LEN == 4
562 dst[0] == s->dst[0] &&
563 dst[1] == s->dst[1] &&
564 dst[2] == s->dst[2] &&
565 #endif
566 pinfo->tunnelid == s->tunnelid) {
567
568 insert:
569 /* OK, we found appropriate session */
570
571 fp = &s->ht[h2];
572
573 f->sess = s;
574 if (f->tunnelhdr == 0)
575 tcf_bind_filter(tp, &f->res, base);
576
577 tcf_exts_change(tp, &f->exts, &e);
578
579 fp = &s->ht[h2];
580 for (nfp = rtnl_dereference(*fp); nfp;
581 fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
582 __u32 mask = nfp->spi.mask & f->spi.mask;
583
584 if (mask != f->spi.mask)
585 break;
586 }
587 RCU_INIT_POINTER(f->next, nfp);
588 rcu_assign_pointer(*fp, f);
589
590 *arg = (unsigned long)f;
591 return 0;
592 }
593 }
594
595 /* No session found. Create new one. */
596
597 err = -ENOBUFS;
598 s = kzalloc(sizeof(struct rsvp_session), GFP_KERNEL);
599 if (s == NULL)
600 goto errout;
601 memcpy(s->dst, dst, sizeof(s->dst));
602
603 if (pinfo) {
604 s->dpi = pinfo->dpi;
605 s->protocol = pinfo->protocol;
606 s->tunnelid = pinfo->tunnelid;
607 }
608 sp = &data->ht[h1];
609 for (nsp = rtnl_dereference(*sp); nsp;
610 sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
611 if ((nsp->dpi.mask & s->dpi.mask) != s->dpi.mask)
612 break;
613 }
614 RCU_INIT_POINTER(s->next, nsp);
615 rcu_assign_pointer(*sp, s);
616
617 goto insert;
618
619 errout:
620 kfree(f);
621 errout2:
622 tcf_exts_destroy(&e);
623 return err;
624 }
625
626 static void rsvp_walk(struct tcf_proto *tp, struct tcf_walker *arg)
627 {
628 struct rsvp_head *head = rtnl_dereference(tp->root);
629 unsigned int h, h1;
630
631 if (arg->stop)
632 return;
633
634 for (h = 0; h < 256; h++) {
635 struct rsvp_session *s;
636
637 for (s = rtnl_dereference(head->ht[h]); s;
638 s = rtnl_dereference(s->next)) {
639 for (h1 = 0; h1 <= 16; h1++) {
640 struct rsvp_filter *f;
641
642 for (f = rtnl_dereference(s->ht[h1]); f;
643 f = rtnl_dereference(f->next)) {
644 if (arg->count < arg->skip) {
645 arg->count++;
646 continue;
647 }
648 if (arg->fn(tp, (unsigned long)f, arg) < 0) {
649 arg->stop = 1;
650 return;
651 }
652 arg->count++;
653 }
654 }
655 }
656 }
657 }
658
659 static int rsvp_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
660 struct sk_buff *skb, struct tcmsg *t)
661 {
662 struct rsvp_filter *f = (struct rsvp_filter *)fh;
663 struct rsvp_session *s;
664 struct nlattr *nest;
665 struct tc_rsvp_pinfo pinfo;
666
667 if (f == NULL)
668 return skb->len;
669 s = f->sess;
670
671 t->tcm_handle = f->handle;
672
673 nest = nla_nest_start(skb, TCA_OPTIONS);
674 if (nest == NULL)
675 goto nla_put_failure;
676
677 if (nla_put(skb, TCA_RSVP_DST, sizeof(s->dst), &s->dst))
678 goto nla_put_failure;
679 pinfo.dpi = s->dpi;
680 pinfo.spi = f->spi;
681 pinfo.protocol = s->protocol;
682 pinfo.tunnelid = s->tunnelid;
683 pinfo.tunnelhdr = f->tunnelhdr;
684 pinfo.pad = 0;
685 if (nla_put(skb, TCA_RSVP_PINFO, sizeof(pinfo), &pinfo))
686 goto nla_put_failure;
687 if (f->res.classid &&
688 nla_put_u32(skb, TCA_RSVP_CLASSID, f->res.classid))
689 goto nla_put_failure;
690 if (((f->handle >> 8) & 0xFF) != 16 &&
691 nla_put(skb, TCA_RSVP_SRC, sizeof(f->src), f->src))
692 goto nla_put_failure;
693
694 if (tcf_exts_dump(skb, &f->exts) < 0)
695 goto nla_put_failure;
696
697 nla_nest_end(skb, nest);
698
699 if (tcf_exts_dump_stats(skb, &f->exts) < 0)
700 goto nla_put_failure;
701 return skb->len;
702
703 nla_put_failure:
704 nla_nest_cancel(skb, nest);
705 return -1;
706 }
707
708 static struct tcf_proto_ops RSVP_OPS __read_mostly = {
709 .kind = RSVP_ID,
710 .classify = rsvp_classify,
711 .init = rsvp_init,
712 .destroy = rsvp_destroy,
713 .get = rsvp_get,
714 .change = rsvp_change,
715 .delete = rsvp_delete,
716 .walk = rsvp_walk,
717 .dump = rsvp_dump,
718 .owner = THIS_MODULE,
719 };
720
721 static int __init init_rsvp(void)
722 {
723 return register_tcf_proto_ops(&RSVP_OPS);
724 }
725
726 static void __exit exit_rsvp(void)
727 {
728 unregister_tcf_proto_ops(&RSVP_OPS);
729 }
730
731 module_init(init_rsvp)
732 module_exit(exit_rsvp)
Linux with added FPC-III support