?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.168
[linux/fpc-iii.git] / net / sched / cls_rsvp.h
blobeb1dd2afc5a129473d05b571ff3d181b13cc4bd5
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_work rwork;
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 restart:
156
157 #if RSVP_DST_LEN == 4
158 src = &nhptr->saddr.s6_addr32[0];
159 dst = &nhptr->daddr.s6_addr32[0];
160 protocol = nhptr->nexthdr;
161 xprt = ((u8 *)nhptr) + sizeof(struct ipv6hdr);
162 #else
163 src = &nhptr->saddr;
164 dst = &nhptr->daddr;
165 protocol = nhptr->protocol;
166 xprt = ((u8 *)nhptr) + (nhptr->ihl<<2);
167 if (ip_is_fragment(nhptr))
168 return -1;
169 #endif
170
171 h1 = hash_dst(dst, protocol, tunnelid);
172 h2 = hash_src(src);
173
174 for (s = rcu_dereference_bh(head->ht[h1]); s;
175 s = rcu_dereference_bh(s->next)) {
176 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN - 1] &&
177 protocol == s->protocol &&
178 !(s->dpi.mask &
179 (*(u32 *)(xprt + s->dpi.offset) ^ s->dpi.key)) &&
180 #if RSVP_DST_LEN == 4
181 dst[0] == s->dst[0] &&
182 dst[1] == s->dst[1] &&
183 dst[2] == s->dst[2] &&
184 #endif
185 tunnelid == s->tunnelid) {
186
187 for (f = rcu_dereference_bh(s->ht[h2]); f;
188 f = rcu_dereference_bh(f->next)) {
189 if (src[RSVP_DST_LEN-1] == f->src[RSVP_DST_LEN - 1] &&
190 !(f->spi.mask & (*(u32 *)(xprt + f->spi.offset) ^ f->spi.key))
191 #if RSVP_DST_LEN == 4
192 &&
193 src[0] == f->src[0] &&
194 src[1] == f->src[1] &&
195 src[2] == f->src[2]
196 #endif
197 ) {
198 *res = f->res;
199 RSVP_APPLY_RESULT();
200
201 matched:
202 if (f->tunnelhdr == 0)
203 return 0;
204
205 tunnelid = f->res.classid;
206 nhptr = (void *)(xprt + f->tunnelhdr - sizeof(*nhptr));
207 goto restart;
208 }
209 }
210
211 /* And wildcard bucket... */
212 for (f = rcu_dereference_bh(s->ht[16]); f;
213 f = rcu_dereference_bh(f->next)) {
214 *res = f->res;
215 RSVP_APPLY_RESULT();
216 goto matched;
217 }
218 return -1;
219 }
220 }
221 return -1;
222 }
223
224 static void rsvp_replace(struct tcf_proto *tp, struct rsvp_filter *n, u32 h)
225 {
226 struct rsvp_head *head = rtnl_dereference(tp->root);
227 struct rsvp_session *s;
228 struct rsvp_filter __rcu **ins;
229 struct rsvp_filter *pins;
230 unsigned int h1 = h & 0xFF;
231 unsigned int h2 = (h >> 8) & 0xFF;
232
233 for (s = rtnl_dereference(head->ht[h1]); s;
234 s = rtnl_dereference(s->next)) {
235 for (ins = &s->ht[h2], pins = rtnl_dereference(*ins); ;
236 ins = &pins->next, pins = rtnl_dereference(*ins)) {
237 if (pins->handle == h) {
238 RCU_INIT_POINTER(n->next, pins->next);
239 rcu_assign_pointer(*ins, n);
240 return;
241 }
242 }
243 }
244
245 /* Something went wrong if we are trying to replace a non-existant
246 * node. Mind as well halt instead of silently failing.
247 */
248 BUG_ON(1);
249 }
250
251 static void *rsvp_get(struct tcf_proto *tp, u32 handle)
252 {
253 struct rsvp_head *head = rtnl_dereference(tp->root);
254 struct rsvp_session *s;
255 struct rsvp_filter *f;
256 unsigned int h1 = handle & 0xFF;
257 unsigned int h2 = (handle >> 8) & 0xFF;
258
259 if (h2 > 16)
260 return NULL;
261
262 for (s = rtnl_dereference(head->ht[h1]); s;
263 s = rtnl_dereference(s->next)) {
264 for (f = rtnl_dereference(s->ht[h2]); f;
265 f = rtnl_dereference(f->next)) {
266 if (f->handle == handle)
267 return f;
268 }
269 }
270 return NULL;
271 }
272
273 static int rsvp_init(struct tcf_proto *tp)
274 {
275 struct rsvp_head *data;
276
277 data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL);
278 if (data) {
279 rcu_assign_pointer(tp->root, data);
280 return 0;
281 }
282 return -ENOBUFS;
283 }
284
285 static void __rsvp_delete_filter(struct rsvp_filter *f)
286 {
287 tcf_exts_destroy(&f->exts);
288 tcf_exts_put_net(&f->exts);
289 kfree(f);
290 }
291
292 static void rsvp_delete_filter_work(struct work_struct *work)
293 {
294 struct rsvp_filter *f = container_of(to_rcu_work(work),
295 struct rsvp_filter,
296 rwork);
297 rtnl_lock();
298 __rsvp_delete_filter(f);
299 rtnl_unlock();
300 }
301
302 static void rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)
303 {
304 tcf_unbind_filter(tp, &f->res);
305 /* all classifiers are required to call tcf_exts_destroy() after rcu
306 * grace period, since converted-to-rcu actions are relying on that
307 * in cleanup() callback
308 */
309 if (tcf_exts_get_net(&f->exts))
310 tcf_queue_work(&f->rwork, rsvp_delete_filter_work);
311 else
312 __rsvp_delete_filter(f);
313 }
314
315 static void rsvp_destroy(struct tcf_proto *tp, struct netlink_ext_ack *extack)
316 {
317 struct rsvp_head *data = rtnl_dereference(tp->root);
318 int h1, h2;
319
320 if (data == NULL)
321 return;
322
323 for (h1 = 0; h1 < 256; h1++) {
324 struct rsvp_session *s;
325
326 while ((s = rtnl_dereference(data->ht[h1])) != NULL) {
327 RCU_INIT_POINTER(data->ht[h1], s->next);
328
329 for (h2 = 0; h2 <= 16; h2++) {
330 struct rsvp_filter *f;
331
332 while ((f = rtnl_dereference(s->ht[h2])) != NULL) {
333 rcu_assign_pointer(s->ht[h2], f->next);
334 rsvp_delete_filter(tp, f);
335 }
336 }
337 kfree_rcu(s, rcu);
338 }
339 }
340 kfree_rcu(data, rcu);
341 }
342
343 static int rsvp_delete(struct tcf_proto *tp, void *arg, bool *last,
344 struct netlink_ext_ack *extack)
345 {
346 struct rsvp_head *head = rtnl_dereference(tp->root);
347 struct rsvp_filter *nfp, *f = arg;
348 struct rsvp_filter __rcu **fp;
349 unsigned int h = f->handle;
350 struct rsvp_session __rcu **sp;
351 struct rsvp_session *nsp, *s = f->sess;
352 int i, h1;
353
354 fp = &s->ht[(h >> 8) & 0xFF];
355 for (nfp = rtnl_dereference(*fp); nfp;
356 fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
357 if (nfp == f) {
358 RCU_INIT_POINTER(*fp, f->next);
359 rsvp_delete_filter(tp, f);
360
361 /* Strip tree */
362
363 for (i = 0; i <= 16; i++)
364 if (s->ht[i])
365 goto out;
366
367 /* OK, session has no flows */
368 sp = &head->ht[h & 0xFF];
369 for (nsp = rtnl_dereference(*sp); nsp;
370 sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
371 if (nsp == s) {
372 RCU_INIT_POINTER(*sp, s->next);
373 kfree_rcu(s, rcu);
374 goto out;
375 }
376 }
377
378 break;
379 }
380 }
381
382 out:
383 *last = true;
384 for (h1 = 0; h1 < 256; h1++) {
385 if (rcu_access_pointer(head->ht[h1])) {
386 *last = false;
387 break;
388 }
389 }
390
391 return 0;
392 }
393
394 static unsigned int gen_handle(struct tcf_proto *tp, unsigned salt)
395 {
396 struct rsvp_head *data = rtnl_dereference(tp->root);
397 int i = 0xFFFF;
398
399 while (i-- > 0) {
400 u32 h;
401
402 if ((data->hgenerator += 0x10000) == 0)
403 data->hgenerator = 0x10000;
404 h = data->hgenerator|salt;
405 if (!rsvp_get(tp, h))
406 return h;
407 }
408 return 0;
409 }
410
411 static int tunnel_bts(struct rsvp_head *data)
412 {
413 int n = data->tgenerator >> 5;
414 u32 b = 1 << (data->tgenerator & 0x1F);
415
416 if (data->tmap[n] & b)
417 return 0;
418 data->tmap[n] |= b;
419 return 1;
420 }
421
422 static void tunnel_recycle(struct rsvp_head *data)
423 {
424 struct rsvp_session __rcu **sht = data->ht;
425 u32 tmap[256/32];
426 int h1, h2;
427
428 memset(tmap, 0, sizeof(tmap));
429
430 for (h1 = 0; h1 < 256; h1++) {
431 struct rsvp_session *s;
432 for (s = rtnl_dereference(sht[h1]); s;
433 s = rtnl_dereference(s->next)) {
434 for (h2 = 0; h2 <= 16; h2++) {
435 struct rsvp_filter *f;
436
437 for (f = rtnl_dereference(s->ht[h2]); f;
438 f = rtnl_dereference(f->next)) {
439 if (f->tunnelhdr == 0)
440 continue;
441 data->tgenerator = f->res.classid;
442 tunnel_bts(data);
443 }
444 }
445 }
446 }
447
448 memcpy(data->tmap, tmap, sizeof(tmap));
449 }
450
451 static u32 gen_tunnel(struct rsvp_head *data)
452 {
453 int i, k;
454
455 for (k = 0; k < 2; k++) {
456 for (i = 255; i > 0; i--) {
457 if (++data->tgenerator == 0)
458 data->tgenerator = 1;
459 if (tunnel_bts(data))
460 return data->tgenerator;
461 }
462 tunnel_recycle(data);
463 }
464 return 0;
465 }
466
467 static const struct nla_policy rsvp_policy[TCA_RSVP_MAX + 1] = {
468 [TCA_RSVP_CLASSID] = { .type = NLA_U32 },
469 [TCA_RSVP_DST] = { .len = RSVP_DST_LEN * sizeof(u32) },
470 [TCA_RSVP_SRC] = { .len = RSVP_DST_LEN * sizeof(u32) },
471 [TCA_RSVP_PINFO] = { .len = sizeof(struct tc_rsvp_pinfo) },
472 };
473
474 static int rsvp_change(struct net *net, struct sk_buff *in_skb,
475 struct tcf_proto *tp, unsigned long base,
476 u32 handle,
477 struct nlattr **tca,
478 void **arg, bool ovr, struct netlink_ext_ack *extack)
479 {
480 struct rsvp_head *data = rtnl_dereference(tp->root);
481 struct rsvp_filter *f, *nfp;
482 struct rsvp_filter __rcu **fp;
483 struct rsvp_session *nsp, *s;
484 struct rsvp_session __rcu **sp;
485 struct tc_rsvp_pinfo *pinfo = NULL;
486 struct nlattr *opt = tca[TCA_OPTIONS];
487 struct nlattr *tb[TCA_RSVP_MAX + 1];
488 struct tcf_exts e;
489 unsigned int h1, h2;
490 __be32 *dst;
491 int err;
492
493 if (opt == NULL)
494 return handle ? -EINVAL : 0;
495
496 err = nla_parse_nested(tb, TCA_RSVP_MAX, opt, rsvp_policy, NULL);
497 if (err < 0)
498 return err;
499
500 err = tcf_exts_init(&e, TCA_RSVP_ACT, TCA_RSVP_POLICE);
501 if (err < 0)
502 return err;
503 err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, ovr, extack);
504 if (err < 0)
505 goto errout2;
506
507 f = *arg;
508 if (f) {
509 /* Node exists: adjust only classid */
510 struct rsvp_filter *n;
511
512 if (f->handle != handle && handle)
513 goto errout2;
514
515 n = kmemdup(f, sizeof(*f), GFP_KERNEL);
516 if (!n) {
517 err = -ENOMEM;
518 goto errout2;
519 }
520
521 err = tcf_exts_init(&n->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
522 if (err < 0) {
523 kfree(n);
524 goto errout2;
525 }
526
527 if (tb[TCA_RSVP_CLASSID]) {
528 n->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
529 tcf_bind_filter(tp, &n->res, base);
530 }
531
532 tcf_exts_change(&n->exts, &e);
533 rsvp_replace(tp, n, handle);
534 return 0;
535 }
536
537 /* Now more serious part... */
538 err = -EINVAL;
539 if (handle)
540 goto errout2;
541 if (tb[TCA_RSVP_DST] == NULL)
542 goto errout2;
543
544 err = -ENOBUFS;
545 f = kzalloc(sizeof(struct rsvp_filter), GFP_KERNEL);
546 if (f == NULL)
547 goto errout2;
548
549 err = tcf_exts_init(&f->exts, TCA_RSVP_ACT, TCA_RSVP_POLICE);
550 if (err < 0)
551 goto errout;
552 h2 = 16;
553 if (tb[TCA_RSVP_SRC]) {
554 memcpy(f->src, nla_data(tb[TCA_RSVP_SRC]), sizeof(f->src));
555 h2 = hash_src(f->src);
556 }
557 if (tb[TCA_RSVP_PINFO]) {
558 pinfo = nla_data(tb[TCA_RSVP_PINFO]);
559 f->spi = pinfo->spi;
560 f->tunnelhdr = pinfo->tunnelhdr;
561 }
562 if (tb[TCA_RSVP_CLASSID])
563 f->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]);
564
565 dst = nla_data(tb[TCA_RSVP_DST]);
566 h1 = hash_dst(dst, pinfo ? pinfo->protocol : 0, pinfo ? pinfo->tunnelid : 0);
567
568 err = -ENOMEM;
569 if ((f->handle = gen_handle(tp, h1 | (h2<<8))) == 0)
570 goto errout;
571
572 if (f->tunnelhdr) {
573 err = -EINVAL;
574 if (f->res.classid > 255)
575 goto errout;
576
577 err = -ENOMEM;
578 if (f->res.classid == 0 &&
579 (f->res.classid = gen_tunnel(data)) == 0)
580 goto errout;
581 }
582
583 for (sp = &data->ht[h1];
584 (s = rtnl_dereference(*sp)) != NULL;
585 sp = &s->next) {
586 if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] &&
587 pinfo && pinfo->protocol == s->protocol &&
588 memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 &&
589 #if RSVP_DST_LEN == 4
590 dst[0] == s->dst[0] &&
591 dst[1] == s->dst[1] &&
592 dst[2] == s->dst[2] &&
593 #endif
594 pinfo->tunnelid == s->tunnelid) {
595
596 insert:
597 /* OK, we found appropriate session */
598
599 fp = &s->ht[h2];
600
601 f->sess = s;
602 if (f->tunnelhdr == 0)
603 tcf_bind_filter(tp, &f->res, base);
604
605 tcf_exts_change(&f->exts, &e);
606
607 fp = &s->ht[h2];
608 for (nfp = rtnl_dereference(*fp); nfp;
609 fp = &nfp->next, nfp = rtnl_dereference(*fp)) {
610 __u32 mask = nfp->spi.mask & f->spi.mask;
611
612 if (mask != f->spi.mask)
613 break;
614 }
615 RCU_INIT_POINTER(f->next, nfp);
616 rcu_assign_pointer(*fp, f);
617
618 *arg = f;
619 return 0;
620 }
621 }
622
623 /* No session found. Create new one. */
624
625 err = -ENOBUFS;
626 s = kzalloc(sizeof(struct rsvp_session), GFP_KERNEL);
627 if (s == NULL)
628 goto errout;
629 memcpy(s->dst, dst, sizeof(s->dst));
630
631 if (pinfo) {
632 s->dpi = pinfo->dpi;
633 s->protocol = pinfo->protocol;
634 s->tunnelid = pinfo->tunnelid;
635 }
636 sp = &data->ht[h1];
637 for (nsp = rtnl_dereference(*sp); nsp;
638 sp = &nsp->next, nsp = rtnl_dereference(*sp)) {
639 if ((nsp->dpi.mask & s->dpi.mask) != s->dpi.mask)
640 break;
641 }
642 RCU_INIT_POINTER(s->next, nsp);
643 rcu_assign_pointer(*sp, s);
644
645 goto insert;
646
647 errout:
648 tcf_exts_destroy(&f->exts);
649 kfree(f);
650 errout2:
651 tcf_exts_destroy(&e);
652 return err;
653 }
654
655 static void rsvp_walk(struct tcf_proto *tp, struct tcf_walker *arg)
656 {
657 struct rsvp_head *head = rtnl_dereference(tp->root);
658 unsigned int h, h1;
659
660 if (arg->stop)
661 return;
662
663 for (h = 0; h < 256; h++) {
664 struct rsvp_session *s;
665
666 for (s = rtnl_dereference(head->ht[h]); s;
667 s = rtnl_dereference(s->next)) {
668 for (h1 = 0; h1 <= 16; h1++) {
669 struct rsvp_filter *f;
670
671 for (f = rtnl_dereference(s->ht[h1]); f;
672 f = rtnl_dereference(f->next)) {
673 if (arg->count < arg->skip) {
674 arg->count++;
675 continue;
676 }
677 if (arg->fn(tp, f, arg) < 0) {
678 arg->stop = 1;
679 return;
680 }
681 arg->count++;
682 }
683 }
684 }
685 }
686 }
687
688 static int rsvp_dump(struct net *net, struct tcf_proto *tp, void *fh,
689 struct sk_buff *skb, struct tcmsg *t)
690 {
691 struct rsvp_filter *f = fh;
692 struct rsvp_session *s;
693 struct nlattr *nest;
694 struct tc_rsvp_pinfo pinfo;
695
696 if (f == NULL)
697 return skb->len;
698 s = f->sess;
699
700 t->tcm_handle = f->handle;
701
702 nest = nla_nest_start(skb, TCA_OPTIONS);
703 if (nest == NULL)
704 goto nla_put_failure;
705
706 if (nla_put(skb, TCA_RSVP_DST, sizeof(s->dst), &s->dst))
707 goto nla_put_failure;
708 pinfo.dpi = s->dpi;
709 pinfo.spi = f->spi;
710 pinfo.protocol = s->protocol;
711 pinfo.tunnelid = s->tunnelid;
712 pinfo.tunnelhdr = f->tunnelhdr;
713 pinfo.pad = 0;
714 if (nla_put(skb, TCA_RSVP_PINFO, sizeof(pinfo), &pinfo))
715 goto nla_put_failure;
716 if (f->res.classid &&
717 nla_put_u32(skb, TCA_RSVP_CLASSID, f->res.classid))
718 goto nla_put_failure;
719 if (((f->handle >> 8) & 0xFF) != 16 &&
720 nla_put(skb, TCA_RSVP_SRC, sizeof(f->src), f->src))
721 goto nla_put_failure;
722
723 if (tcf_exts_dump(skb, &f->exts) < 0)
724 goto nla_put_failure;
725
726 nla_nest_end(skb, nest);
727
728 if (tcf_exts_dump_stats(skb, &f->exts) < 0)
729 goto nla_put_failure;
730 return skb->len;
731
732 nla_put_failure:
733 nla_nest_cancel(skb, nest);
734 return -1;
735 }
736
737 static void rsvp_bind_class(void *fh, u32 classid, unsigned long cl, void *q,
738 unsigned long base)
739 {
740 struct rsvp_filter *f = fh;
741
742 if (f && f->res.classid == classid) {
743 if (cl)
744 __tcf_bind_filter(q, &f->res, base);
745 else
746 __tcf_unbind_filter(q, &f->res);
747 }
748 }
749
750 static struct tcf_proto_ops RSVP_OPS __read_mostly = {
751 .kind = RSVP_ID,
752 .classify = rsvp_classify,
753 .init = rsvp_init,
754 .destroy = rsvp_destroy,
755 .get = rsvp_get,
756 .change = rsvp_change,
757 .delete = rsvp_delete,
758 .walk = rsvp_walk,
759 .dump = rsvp_dump,
760 .bind_class = rsvp_bind_class,
761 .owner = THIS_MODULE,
762 };
763
764 static int __init init_rsvp(void)
765 {
766 return register_tcf_proto_ops(&RSVP_OPS);
767 }
768
769 static void __exit exit_rsvp(void)
770 {
771 unregister_tcf_proto_ops(&RSVP_OPS);
772 }
773
774 module_init(init_rsvp)
775 module_exit(exit_rsvp)
Linux with added FPC-III support