Commit | Line | Data |
---|---|---|
2874c5fd | 1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
1da177e4 LT |
2 | /* |
3 | * net/sched/cls_rsvp.h Template file for RSVPv[46] classifiers. | |
4 | * | |
1da177e4 LT |
5 | * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> |
6 | */ | |
7 | ||
8 | /* | |
9 | Comparing to general packet classification problem, | |
37f2ad2b | 10 | RSVP needs only several relatively simple rules: |
1da177e4 LT |
11 | |
12 | * (dst, protocol) are always specified, | |
13 | so that we are able to hash them. | |
14 | * src may be exact, or may be wildcard, so that | |
15 | we can keep a hash table plus one wildcard entry. | |
16 | * source port (or flow label) is important only if src is given. | |
17 | ||
18 | IMPLEMENTATION. | |
19 | ||
20 | We use a two level hash table: The top level is keyed by | |
21 | destination address and protocol ID, every bucket contains a list | |
22 | of "rsvp sessions", identified by destination address, protocol and | |
23 | DPI(="Destination Port ID"): triple (key, mask, offset). | |
24 | ||
25 | Every bucket has a smaller hash table keyed by source address | |
26 | (cf. RSVP flowspec) and one wildcard entry for wildcard reservations. | |
27 | Every bucket is again a list of "RSVP flows", selected by | |
28 | source address and SPI(="Source Port ID" here rather than | |
29 | "security parameter index"): triple (key, mask, offset). | |
30 | ||
31 | ||
32 | NOTE 1. All the packets with IPv6 extension headers (but AH and ESP) | |
33 | and all fragmented packets go to the best-effort traffic class. | |
34 | ||
35 | ||
36 | NOTE 2. Two "port id"'s seems to be redundant, rfc2207 requires | |
37 | only one "Generalized Port Identifier". So that for classic | |
38 | ah, esp (and udp,tcp) both *pi should coincide or one of them | |
39 | should be wildcard. | |
40 | ||
41 | At first sight, this redundancy is just a waste of CPU | |
42 | resources. But DPI and SPI add the possibility to assign different | |
43 | priorities to GPIs. Look also at note 4 about tunnels below. | |
44 | ||
45 | ||
46 | NOTE 3. One complication is the case of tunneled packets. | |
47 | We implement it as following: if the first lookup | |
48 | matches a special session with "tunnelhdr" value not zero, | |
49 | flowid doesn't contain the true flow ID, but the tunnel ID (1...255). | |
50 | In this case, we pull tunnelhdr bytes and restart lookup | |
51 | with tunnel ID added to the list of keys. Simple and stupid 8)8) | |
52 | It's enough for PIMREG and IPIP. | |
53 | ||
54 | ||
55 | NOTE 4. Two GPIs make it possible to parse even GRE packets. | |
56 | F.e. DPI can select ETH_P_IP (and necessary flags to make | |
57 | tunnelhdr correct) in GRE protocol field and SPI matches | |
58 | GRE key. Is it not nice? 8)8) | |
59 | ||
60 | ||
61 | Well, as result, despite its simplicity, we get a pretty | |
62 | powerful classification engine. */ | |
63 | ||
1da177e4 | 64 | |
cc7ec456 | 65 | struct rsvp_head { |
1da177e4 LT |
66 | u32 tmap[256/32]; |
67 | u32 hgenerator; | |
68 | u8 tgenerator; | |
b929d86d JF |
69 | struct rsvp_session __rcu *ht[256]; |
70 | struct rcu_head rcu; | |
1da177e4 LT |
71 | }; |
72 | ||
cc7ec456 | 73 | struct rsvp_session { |
b929d86d JF |
74 | struct rsvp_session __rcu *next; |
75 | __be32 dst[RSVP_DST_LEN]; | |
76 | struct tc_rsvp_gpi dpi; | |
77 | u8 protocol; | |
78 | u8 tunnelid; | |
1da177e4 | 79 | /* 16 (src,sport) hash slots, and one wildcard source slot */ |
b929d86d JF |
80 | struct rsvp_filter __rcu *ht[16 + 1]; |
81 | struct rcu_head rcu; | |
1da177e4 LT |
82 | }; |
83 | ||
84 | ||
cc7ec456 | 85 | struct rsvp_filter { |
b929d86d JF |
86 | struct rsvp_filter __rcu *next; |
87 | __be32 src[RSVP_DST_LEN]; | |
88 | struct tc_rsvp_gpi spi; | |
89 | u8 tunnelhdr; | |
1da177e4 | 90 | |
b929d86d JF |
91 | struct tcf_result res; |
92 | struct tcf_exts exts; | |
1da177e4 | 93 | |
b929d86d JF |
94 | u32 handle; |
95 | struct rsvp_session *sess; | |
aaa908ff | 96 | struct rcu_work rwork; |
1da177e4 LT |
97 | }; |
98 | ||
cc7ec456 | 99 | static inline unsigned int hash_dst(__be32 *dst, u8 protocol, u8 tunnelid) |
1da177e4 | 100 | { |
cc7ec456 ED |
101 | unsigned int h = (__force __u32)dst[RSVP_DST_LEN - 1]; |
102 | ||
1da177e4 LT |
103 | h ^= h>>16; |
104 | h ^= h>>8; | |
105 | return (h ^ protocol ^ tunnelid) & 0xFF; | |
106 | } | |
107 | ||
cc7ec456 | 108 | static inline unsigned int hash_src(__be32 *src) |
1da177e4 | 109 | { |
cc7ec456 ED |
110 | unsigned int h = (__force __u32)src[RSVP_DST_LEN-1]; |
111 | ||
1da177e4 LT |
112 | h ^= h>>16; |
113 | h ^= h>>8; | |
114 | h ^= h>>4; | |
115 | return h & 0xF; | |
116 | } | |
117 | ||
1da177e4 LT |
118 | #define RSVP_APPLY_RESULT() \ |
119 | { \ | |
120 | int r = tcf_exts_exec(skb, &f->exts, res); \ | |
121 | if (r < 0) \ | |
122 | continue; \ | |
123 | else if (r > 0) \ | |
124 | return r; \ | |
125 | } | |
10297b99 | 126 | |
dc7f9f6e | 127 | static int rsvp_classify(struct sk_buff *skb, const struct tcf_proto *tp, |
1da177e4 LT |
128 | struct tcf_result *res) |
129 | { | |
b929d86d | 130 | struct rsvp_head *head = rcu_dereference_bh(tp->root); |
1da177e4 LT |
131 | struct rsvp_session *s; |
132 | struct rsvp_filter *f; | |
cc7ec456 | 133 | unsigned int h1, h2; |
66c6f529 | 134 | __be32 *dst, *src; |
1da177e4 LT |
135 | u8 protocol; |
136 | u8 tunnelid = 0; | |
137 | u8 *xprt; | |
138 | #if RSVP_DST_LEN == 4 | |
12dc96d1 CG |
139 | struct ipv6hdr *nhptr; |
140 | ||
141 | if (!pskb_network_may_pull(skb, sizeof(*nhptr))) | |
142 | return -1; | |
143 | nhptr = ipv6_hdr(skb); | |
1da177e4 | 144 | #else |
12dc96d1 CG |
145 | struct iphdr *nhptr; |
146 | ||
147 | if (!pskb_network_may_pull(skb, sizeof(*nhptr))) | |
148 | return -1; | |
149 | nhptr = ip_hdr(skb); | |
1da177e4 | 150 | #endif |
1da177e4 LT |
151 | restart: |
152 | ||
153 | #if RSVP_DST_LEN == 4 | |
154 | src = &nhptr->saddr.s6_addr32[0]; | |
155 | dst = &nhptr->daddr.s6_addr32[0]; | |
156 | protocol = nhptr->nexthdr; | |
cc7ec456 | 157 | xprt = ((u8 *)nhptr) + sizeof(struct ipv6hdr); |
1da177e4 LT |
158 | #else |
159 | src = &nhptr->saddr; | |
160 | dst = &nhptr->daddr; | |
161 | protocol = nhptr->protocol; | |
cc7ec456 | 162 | xprt = ((u8 *)nhptr) + (nhptr->ihl<<2); |
56f8a75c | 163 | if (ip_is_fragment(nhptr)) |
1da177e4 LT |
164 | return -1; |
165 | #endif | |
166 | ||
167 | h1 = hash_dst(dst, protocol, tunnelid); | |
168 | h2 = hash_src(src); | |
169 | ||
b929d86d JF |
170 | for (s = rcu_dereference_bh(head->ht[h1]); s; |
171 | s = rcu_dereference_bh(s->next)) { | |
cc7ec456 | 172 | if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN - 1] && |
1da177e4 | 173 | protocol == s->protocol && |
f64f9e71 | 174 | !(s->dpi.mask & |
cc7ec456 | 175 | (*(u32 *)(xprt + s->dpi.offset) ^ s->dpi.key)) && |
1da177e4 | 176 | #if RSVP_DST_LEN == 4 |
f64f9e71 JP |
177 | dst[0] == s->dst[0] && |
178 | dst[1] == s->dst[1] && | |
179 | dst[2] == s->dst[2] && | |
1da177e4 | 180 | #endif |
f64f9e71 | 181 | tunnelid == s->tunnelid) { |
1da177e4 | 182 | |
b929d86d JF |
183 | for (f = rcu_dereference_bh(s->ht[h2]); f; |
184 | f = rcu_dereference_bh(f->next)) { | |
cc7ec456 ED |
185 | if (src[RSVP_DST_LEN-1] == f->src[RSVP_DST_LEN - 1] && |
186 | !(f->spi.mask & (*(u32 *)(xprt + f->spi.offset) ^ f->spi.key)) | |
1da177e4 | 187 | #if RSVP_DST_LEN == 4 |
f64f9e71 JP |
188 | && |
189 | src[0] == f->src[0] && | |
190 | src[1] == f->src[1] && | |
191 | src[2] == f->src[2] | |
1da177e4 LT |
192 | #endif |
193 | ) { | |
194 | *res = f->res; | |
195 | RSVP_APPLY_RESULT(); | |
196 | ||
197 | matched: | |
198 | if (f->tunnelhdr == 0) | |
199 | return 0; | |
200 | ||
201 | tunnelid = f->res.classid; | |
cc7ec456 | 202 | nhptr = (void *)(xprt + f->tunnelhdr - sizeof(*nhptr)); |
1da177e4 LT |
203 | goto restart; |
204 | } | |
205 | } | |
206 | ||
207 | /* And wildcard bucket... */ | |
b929d86d JF |
208 | for (f = rcu_dereference_bh(s->ht[16]); f; |
209 | f = rcu_dereference_bh(f->next)) { | |
1da177e4 LT |
210 | *res = f->res; |
211 | RSVP_APPLY_RESULT(); | |
212 | goto matched; | |
213 | } | |
214 | return -1; | |
215 | } | |
216 | } | |
217 | return -1; | |
218 | } | |
219 | ||
53dfd501 JF |
220 | static void rsvp_replace(struct tcf_proto *tp, struct rsvp_filter *n, u32 h) |
221 | { | |
222 | struct rsvp_head *head = rtnl_dereference(tp->root); | |
223 | struct rsvp_session *s; | |
224 | struct rsvp_filter __rcu **ins; | |
225 | struct rsvp_filter *pins; | |
226 | unsigned int h1 = h & 0xFF; | |
227 | unsigned int h2 = (h >> 8) & 0xFF; | |
228 | ||
229 | for (s = rtnl_dereference(head->ht[h1]); s; | |
230 | s = rtnl_dereference(s->next)) { | |
231 | for (ins = &s->ht[h2], pins = rtnl_dereference(*ins); ; | |
232 | ins = &pins->next, pins = rtnl_dereference(*ins)) { | |
233 | if (pins->handle == h) { | |
234 | RCU_INIT_POINTER(n->next, pins->next); | |
235 | rcu_assign_pointer(*ins, n); | |
236 | return; | |
237 | } | |
238 | } | |
239 | } | |
240 | ||
e5a4b17d | 241 | /* Something went wrong if we are trying to replace a non-existent |
53dfd501 JF |
242 | * node. Mind as well halt instead of silently failing. |
243 | */ | |
244 | BUG_ON(1); | |
245 | } | |
246 | ||
8113c095 | 247 | static void *rsvp_get(struct tcf_proto *tp, u32 handle) |
1da177e4 | 248 | { |
b929d86d | 249 | struct rsvp_head *head = rtnl_dereference(tp->root); |
1da177e4 LT |
250 | struct rsvp_session *s; |
251 | struct rsvp_filter *f; | |
cc7ec456 ED |
252 | unsigned int h1 = handle & 0xFF; |
253 | unsigned int h2 = (handle >> 8) & 0xFF; | |
1da177e4 LT |
254 | |
255 | if (h2 > 16) | |
8113c095 | 256 | return NULL; |
1da177e4 | 257 | |
b929d86d JF |
258 | for (s = rtnl_dereference(head->ht[h1]); s; |
259 | s = rtnl_dereference(s->next)) { | |
260 | for (f = rtnl_dereference(s->ht[h2]); f; | |
261 | f = rtnl_dereference(f->next)) { | |
1da177e4 | 262 | if (f->handle == handle) |
8113c095 | 263 | return f; |
1da177e4 LT |
264 | } |
265 | } | |
8113c095 | 266 | return NULL; |
1da177e4 LT |
267 | } |
268 | ||
1da177e4 LT |
269 | static int rsvp_init(struct tcf_proto *tp) |
270 | { | |
271 | struct rsvp_head *data; | |
272 | ||
0da974f4 | 273 | data = kzalloc(sizeof(struct rsvp_head), GFP_KERNEL); |
1da177e4 | 274 | if (data) { |
b929d86d | 275 | rcu_assign_pointer(tp->root, data); |
1da177e4 LT |
276 | return 0; |
277 | } | |
278 | return -ENOBUFS; | |
279 | } | |
280 | ||
96585063 CW |
281 | static void __rsvp_delete_filter(struct rsvp_filter *f) |
282 | { | |
283 | tcf_exts_destroy(&f->exts); | |
284 | tcf_exts_put_net(&f->exts); | |
285 | kfree(f); | |
286 | } | |
287 | ||
d4f84a41 | 288 | static void rsvp_delete_filter_work(struct work_struct *work) |
1da177e4 | 289 | { |
aaa908ff CW |
290 | struct rsvp_filter *f = container_of(to_rcu_work(work), |
291 | struct rsvp_filter, | |
292 | rwork); | |
d4f84a41 | 293 | rtnl_lock(); |
96585063 | 294 | __rsvp_delete_filter(f); |
d4f84a41 CW |
295 | rtnl_unlock(); |
296 | } | |
297 | ||
9e528d89 AS |
298 | static void rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f) |
299 | { | |
300 | tcf_unbind_filter(tp, &f->res); | |
301 | /* all classifiers are required to call tcf_exts_destroy() after rcu | |
302 | * grace period, since converted-to-rcu actions are relying on that | |
303 | * in cleanup() callback | |
304 | */ | |
96585063 | 305 | if (tcf_exts_get_net(&f->exts)) |
aaa908ff | 306 | tcf_queue_work(&f->rwork, rsvp_delete_filter_work); |
96585063 CW |
307 | else |
308 | __rsvp_delete_filter(f); | |
1da177e4 LT |
309 | } |
310 | ||
12db03b6 VB |
311 | static void rsvp_destroy(struct tcf_proto *tp, bool rtnl_held, |
312 | struct netlink_ext_ack *extack) | |
1da177e4 | 313 | { |
b929d86d | 314 | struct rsvp_head *data = rtnl_dereference(tp->root); |
1da177e4 LT |
315 | int h1, h2; |
316 | ||
317 | if (data == NULL) | |
763dbf63 | 318 | return; |
1da177e4 | 319 | |
cc7ec456 | 320 | for (h1 = 0; h1 < 256; h1++) { |
1da177e4 LT |
321 | struct rsvp_session *s; |
322 | ||
b929d86d JF |
323 | while ((s = rtnl_dereference(data->ht[h1])) != NULL) { |
324 | RCU_INIT_POINTER(data->ht[h1], s->next); | |
1da177e4 | 325 | |
cc7ec456 | 326 | for (h2 = 0; h2 <= 16; h2++) { |
1da177e4 LT |
327 | struct rsvp_filter *f; |
328 | ||
b929d86d JF |
329 | while ((f = rtnl_dereference(s->ht[h2])) != NULL) { |
330 | rcu_assign_pointer(s->ht[h2], f->next); | |
1da177e4 LT |
331 | rsvp_delete_filter(tp, f); |
332 | } | |
333 | } | |
b929d86d | 334 | kfree_rcu(s, rcu); |
1da177e4 LT |
335 | } |
336 | } | |
b929d86d | 337 | kfree_rcu(data, rcu); |
1da177e4 LT |
338 | } |
339 | ||
571acf21 | 340 | static int rsvp_delete(struct tcf_proto *tp, void *arg, bool *last, |
12db03b6 | 341 | bool rtnl_held, struct netlink_ext_ack *extack) |
1da177e4 | 342 | { |
b929d86d | 343 | struct rsvp_head *head = rtnl_dereference(tp->root); |
8113c095 | 344 | struct rsvp_filter *nfp, *f = arg; |
b929d86d | 345 | struct rsvp_filter __rcu **fp; |
cc7ec456 | 346 | unsigned int h = f->handle; |
b929d86d JF |
347 | struct rsvp_session __rcu **sp; |
348 | struct rsvp_session *nsp, *s = f->sess; | |
763dbf63 | 349 | int i, h1; |
1da177e4 | 350 | |
b929d86d JF |
351 | fp = &s->ht[(h >> 8) & 0xFF]; |
352 | for (nfp = rtnl_dereference(*fp); nfp; | |
353 | fp = &nfp->next, nfp = rtnl_dereference(*fp)) { | |
354 | if (nfp == f) { | |
355 | RCU_INIT_POINTER(*fp, f->next); | |
1da177e4 LT |
356 | rsvp_delete_filter(tp, f); |
357 | ||
358 | /* Strip tree */ | |
359 | ||
cc7ec456 | 360 | for (i = 0; i <= 16; i++) |
1da177e4 | 361 | if (s->ht[i]) |
763dbf63 | 362 | goto out; |
1da177e4 LT |
363 | |
364 | /* OK, session has no flows */ | |
b929d86d JF |
365 | sp = &head->ht[h & 0xFF]; |
366 | for (nsp = rtnl_dereference(*sp); nsp; | |
367 | sp = &nsp->next, nsp = rtnl_dereference(*sp)) { | |
368 | if (nsp == s) { | |
369 | RCU_INIT_POINTER(*sp, s->next); | |
370 | kfree_rcu(s, rcu); | |
763dbf63 | 371 | goto out; |
1da177e4 LT |
372 | } |
373 | } | |
374 | ||
763dbf63 WC |
375 | break; |
376 | } | |
377 | } | |
378 | ||
379 | out: | |
380 | *last = true; | |
381 | for (h1 = 0; h1 < 256; h1++) { | |
382 | if (rcu_access_pointer(head->ht[h1])) { | |
383 | *last = false; | |
384 | break; | |
1da177e4 LT |
385 | } |
386 | } | |
763dbf63 | 387 | |
1da177e4 LT |
388 | return 0; |
389 | } | |
390 | ||
cc7ec456 | 391 | static unsigned int gen_handle(struct tcf_proto *tp, unsigned salt) |
1da177e4 | 392 | { |
b929d86d | 393 | struct rsvp_head *data = rtnl_dereference(tp->root); |
1da177e4 LT |
394 | int i = 0xFFFF; |
395 | ||
396 | while (i-- > 0) { | |
397 | u32 h; | |
cc7ec456 | 398 | |
1da177e4 LT |
399 | if ((data->hgenerator += 0x10000) == 0) |
400 | data->hgenerator = 0x10000; | |
401 | h = data->hgenerator|salt; | |
230cfd2d | 402 | if (!rsvp_get(tp, h)) |
1da177e4 LT |
403 | return h; |
404 | } | |
405 | return 0; | |
406 | } | |
407 | ||
408 | static int tunnel_bts(struct rsvp_head *data) | |
409 | { | |
cc7ec456 ED |
410 | int n = data->tgenerator >> 5; |
411 | u32 b = 1 << (data->tgenerator & 0x1F); | |
10297b99 | 412 | |
cc7ec456 | 413 | if (data->tmap[n] & b) |
1da177e4 LT |
414 | return 0; |
415 | data->tmap[n] |= b; | |
416 | return 1; | |
417 | } | |
418 | ||
419 | static void tunnel_recycle(struct rsvp_head *data) | |
420 | { | |
b929d86d | 421 | struct rsvp_session __rcu **sht = data->ht; |
1da177e4 LT |
422 | u32 tmap[256/32]; |
423 | int h1, h2; | |
424 | ||
425 | memset(tmap, 0, sizeof(tmap)); | |
426 | ||
cc7ec456 | 427 | for (h1 = 0; h1 < 256; h1++) { |
1da177e4 | 428 | struct rsvp_session *s; |
b929d86d JF |
429 | for (s = rtnl_dereference(sht[h1]); s; |
430 | s = rtnl_dereference(s->next)) { | |
cc7ec456 | 431 | for (h2 = 0; h2 <= 16; h2++) { |
1da177e4 LT |
432 | struct rsvp_filter *f; |
433 | ||
b929d86d JF |
434 | for (f = rtnl_dereference(s->ht[h2]); f; |
435 | f = rtnl_dereference(f->next)) { | |
1da177e4 LT |
436 | if (f->tunnelhdr == 0) |
437 | continue; | |
438 | data->tgenerator = f->res.classid; | |
439 | tunnel_bts(data); | |
440 | } | |
441 | } | |
442 | } | |
443 | } | |
444 | ||
445 | memcpy(data->tmap, tmap, sizeof(tmap)); | |
446 | } | |
447 | ||
448 | static u32 gen_tunnel(struct rsvp_head *data) | |
449 | { | |
450 | int i, k; | |
451 | ||
cc7ec456 ED |
452 | for (k = 0; k < 2; k++) { |
453 | for (i = 255; i > 0; i--) { | |
1da177e4 LT |
454 | if (++data->tgenerator == 0) |
455 | data->tgenerator = 1; | |
456 | if (tunnel_bts(data)) | |
457 | return data->tgenerator; | |
458 | } | |
459 | tunnel_recycle(data); | |
460 | } | |
461 | return 0; | |
462 | } | |
463 | ||
6fa8c014 PM |
464 | static const struct nla_policy rsvp_policy[TCA_RSVP_MAX + 1] = { |
465 | [TCA_RSVP_CLASSID] = { .type = NLA_U32 }, | |
cb3c0e6b ED |
466 | [TCA_RSVP_DST] = { .len = RSVP_DST_LEN * sizeof(u32) }, |
467 | [TCA_RSVP_SRC] = { .len = RSVP_DST_LEN * sizeof(u32) }, | |
6fa8c014 PM |
468 | [TCA_RSVP_PINFO] = { .len = sizeof(struct tc_rsvp_pinfo) }, |
469 | }; | |
470 | ||
c1b52739 | 471 | static int rsvp_change(struct net *net, struct sk_buff *in_skb, |
af4c6641 | 472 | struct tcf_proto *tp, unsigned long base, |
695176bf CW |
473 | u32 handle, struct nlattr **tca, |
474 | void **arg, u32 flags, | |
12db03b6 | 475 | struct netlink_ext_ack *extack) |
1da177e4 | 476 | { |
b929d86d JF |
477 | struct rsvp_head *data = rtnl_dereference(tp->root); |
478 | struct rsvp_filter *f, *nfp; | |
479 | struct rsvp_filter __rcu **fp; | |
480 | struct rsvp_session *nsp, *s; | |
481 | struct rsvp_session __rcu **sp; | |
1da177e4 | 482 | struct tc_rsvp_pinfo *pinfo = NULL; |
27e95a8c | 483 | struct nlattr *opt = tca[TCA_OPTIONS]; |
add93b61 | 484 | struct nlattr *tb[TCA_RSVP_MAX + 1]; |
1da177e4 | 485 | struct tcf_exts e; |
cc7ec456 | 486 | unsigned int h1, h2; |
66c6f529 | 487 | __be32 *dst; |
1da177e4 LT |
488 | int err; |
489 | ||
490 | if (opt == NULL) | |
491 | return handle ? -EINVAL : 0; | |
492 | ||
8cb08174 JB |
493 | err = nla_parse_nested_deprecated(tb, TCA_RSVP_MAX, opt, rsvp_policy, |
494 | NULL); | |
cee63723 PM |
495 | if (err < 0) |
496 | return err; | |
1da177e4 | 497 | |
14215108 | 498 | err = tcf_exts_init(&e, net, TCA_RSVP_ACT, TCA_RSVP_POLICE); |
1da177e4 LT |
499 | if (err < 0) |
500 | return err; | |
695176bf | 501 | err = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &e, flags, |
ec6743a1 | 502 | extack); |
b9a24bb7 WC |
503 | if (err < 0) |
504 | goto errout2; | |
1da177e4 | 505 | |
8113c095 | 506 | f = *arg; |
cc7ec456 | 507 | if (f) { |
1da177e4 | 508 | /* Node exists: adjust only classid */ |
53dfd501 | 509 | struct rsvp_filter *n; |
1da177e4 LT |
510 | |
511 | if (f->handle != handle && handle) | |
512 | goto errout2; | |
53dfd501 JF |
513 | |
514 | n = kmemdup(f, sizeof(*f), GFP_KERNEL); | |
515 | if (!n) { | |
516 | err = -ENOMEM; | |
517 | goto errout2; | |
518 | } | |
519 | ||
14215108 CW |
520 | err = tcf_exts_init(&n->exts, net, TCA_RSVP_ACT, |
521 | TCA_RSVP_POLICE); | |
b9a24bb7 WC |
522 | if (err < 0) { |
523 | kfree(n); | |
524 | goto errout2; | |
525 | } | |
53dfd501 | 526 | |
27e95a8c | 527 | if (tb[TCA_RSVP_CLASSID]) { |
53dfd501 JF |
528 | n->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]); |
529 | tcf_bind_filter(tp, &n->res, base); | |
1da177e4 LT |
530 | } |
531 | ||
9b0d4446 | 532 | tcf_exts_change(&n->exts, &e); |
53dfd501 | 533 | rsvp_replace(tp, n, handle); |
1da177e4 LT |
534 | return 0; |
535 | } | |
536 | ||
537 | /* Now more serious part... */ | |
538 | err = -EINVAL; | |
539 | if (handle) | |
540 | goto errout2; | |
27e95a8c | 541 | if (tb[TCA_RSVP_DST] == NULL) |
1da177e4 LT |
542 | goto errout2; |
543 | ||
544 | err = -ENOBUFS; | |
0da974f4 | 545 | f = kzalloc(sizeof(struct rsvp_filter), GFP_KERNEL); |
1da177e4 LT |
546 | if (f == NULL) |
547 | goto errout2; | |
548 | ||
14215108 | 549 | err = tcf_exts_init(&f->exts, net, TCA_RSVP_ACT, TCA_RSVP_POLICE); |
b9a24bb7 WC |
550 | if (err < 0) |
551 | goto errout; | |
1da177e4 | 552 | h2 = 16; |
27e95a8c IM |
553 | if (tb[TCA_RSVP_SRC]) { |
554 | memcpy(f->src, nla_data(tb[TCA_RSVP_SRC]), sizeof(f->src)); | |
1da177e4 LT |
555 | h2 = hash_src(f->src); |
556 | } | |
27e95a8c IM |
557 | if (tb[TCA_RSVP_PINFO]) { |
558 | pinfo = nla_data(tb[TCA_RSVP_PINFO]); | |
1da177e4 LT |
559 | f->spi = pinfo->spi; |
560 | f->tunnelhdr = pinfo->tunnelhdr; | |
561 | } | |
27e95a8c IM |
562 | if (tb[TCA_RSVP_CLASSID]) |
563 | f->res.classid = nla_get_u32(tb[TCA_RSVP_CLASSID]); | |
1da177e4 | 564 | |
27e95a8c | 565 | dst = nla_data(tb[TCA_RSVP_DST]); |
1da177e4 LT |
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 | ||
b929d86d JF |
583 | for (sp = &data->ht[h1]; |
584 | (s = rtnl_dereference(*sp)) != NULL; | |
585 | sp = &s->next) { | |
1da177e4 LT |
586 | if (dst[RSVP_DST_LEN-1] == s->dst[RSVP_DST_LEN-1] && |
587 | pinfo && pinfo->protocol == s->protocol && | |
f64f9e71 | 588 | memcmp(&pinfo->dpi, &s->dpi, sizeof(s->dpi)) == 0 && |
1da177e4 | 589 | #if RSVP_DST_LEN == 4 |
f64f9e71 JP |
590 | dst[0] == s->dst[0] && |
591 | dst[1] == s->dst[1] && | |
592 | dst[2] == s->dst[2] && | |
1da177e4 | 593 | #endif |
f64f9e71 | 594 | pinfo->tunnelid == s->tunnelid) { |
1da177e4 LT |
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 | ||
9b0d4446 | 605 | tcf_exts_change(&f->exts, &e); |
1da177e4 | 606 | |
b929d86d JF |
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) | |
1da177e4 | 613 | break; |
b929d86d JF |
614 | } |
615 | RCU_INIT_POINTER(f->next, nfp); | |
616 | rcu_assign_pointer(*fp, f); | |
1da177e4 | 617 | |
8113c095 | 618 | *arg = f; |
1da177e4 LT |
619 | return 0; |
620 | } | |
621 | } | |
622 | ||
623 | /* No session found. Create new one. */ | |
624 | ||
625 | err = -ENOBUFS; | |
0da974f4 | 626 | s = kzalloc(sizeof(struct rsvp_session), GFP_KERNEL); |
1da177e4 LT |
627 | if (s == NULL) |
628 | goto errout; | |
1da177e4 LT |
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 | } | |
b929d86d JF |
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) | |
1da177e4 LT |
640 | break; |
641 | } | |
b929d86d JF |
642 | RCU_INIT_POINTER(s->next, nsp); |
643 | rcu_assign_pointer(*sp, s); | |
10297b99 | 644 | |
1da177e4 LT |
645 | goto insert; |
646 | ||
647 | errout: | |
b9a24bb7 | 648 | tcf_exts_destroy(&f->exts); |
a51482bd | 649 | kfree(f); |
1da177e4 | 650 | errout2: |
18d0264f | 651 | tcf_exts_destroy(&e); |
1da177e4 LT |
652 | return err; |
653 | } | |
654 | ||
12db03b6 VB |
655 | static void rsvp_walk(struct tcf_proto *tp, struct tcf_walker *arg, |
656 | bool rtnl_held) | |
1da177e4 | 657 | { |
b929d86d | 658 | struct rsvp_head *head = rtnl_dereference(tp->root); |
cc7ec456 | 659 | unsigned int h, h1; |
1da177e4 LT |
660 | |
661 | if (arg->stop) | |
662 | return; | |
663 | ||
664 | for (h = 0; h < 256; h++) { | |
665 | struct rsvp_session *s; | |
666 | ||
b929d86d JF |
667 | for (s = rtnl_dereference(head->ht[h]); s; |
668 | s = rtnl_dereference(s->next)) { | |
1da177e4 LT |
669 | for (h1 = 0; h1 <= 16; h1++) { |
670 | struct rsvp_filter *f; | |
671 | ||
b929d86d JF |
672 | for (f = rtnl_dereference(s->ht[h1]); f; |
673 | f = rtnl_dereference(f->next)) { | |
1da177e4 LT |
674 | if (arg->count < arg->skip) { |
675 | arg->count++; | |
676 | continue; | |
677 | } | |
8113c095 | 678 | if (arg->fn(tp, f, arg) < 0) { |
1da177e4 LT |
679 | arg->stop = 1; |
680 | return; | |
681 | } | |
682 | arg->count++; | |
683 | } | |
684 | } | |
685 | } | |
686 | } | |
687 | } | |
688 | ||
8113c095 | 689 | static int rsvp_dump(struct net *net, struct tcf_proto *tp, void *fh, |
12db03b6 | 690 | struct sk_buff *skb, struct tcmsg *t, bool rtnl_held) |
1da177e4 | 691 | { |
8113c095 | 692 | struct rsvp_filter *f = fh; |
1da177e4 | 693 | struct rsvp_session *s; |
4b3550ef | 694 | struct nlattr *nest; |
1da177e4 LT |
695 | struct tc_rsvp_pinfo pinfo; |
696 | ||
697 | if (f == NULL) | |
698 | return skb->len; | |
699 | s = f->sess; | |
700 | ||
701 | t->tcm_handle = f->handle; | |
702 | ||
ae0be8de | 703 | nest = nla_nest_start_noflag(skb, TCA_OPTIONS); |
4b3550ef PM |
704 | if (nest == NULL) |
705 | goto nla_put_failure; | |
1da177e4 | 706 | |
1b34ec43 DM |
707 | if (nla_put(skb, TCA_RSVP_DST, sizeof(s->dst), &s->dst)) |
708 | goto nla_put_failure; | |
1da177e4 LT |
709 | pinfo.dpi = s->dpi; |
710 | pinfo.spi = f->spi; | |
711 | pinfo.protocol = s->protocol; | |
712 | pinfo.tunnelid = s->tunnelid; | |
713 | pinfo.tunnelhdr = f->tunnelhdr; | |
8a47077a | 714 | pinfo.pad = 0; |
1b34ec43 DM |
715 | if (nla_put(skb, TCA_RSVP_PINFO, sizeof(pinfo), &pinfo)) |
716 | goto nla_put_failure; | |
717 | if (f->res.classid && | |
718 | nla_put_u32(skb, TCA_RSVP_CLASSID, f->res.classid)) | |
719 | goto nla_put_failure; | |
720 | if (((f->handle >> 8) & 0xFF) != 16 && | |
721 | nla_put(skb, TCA_RSVP_SRC, sizeof(f->src), f->src)) | |
722 | goto nla_put_failure; | |
1da177e4 | 723 | |
5da57f42 | 724 | if (tcf_exts_dump(skb, &f->exts) < 0) |
add93b61 | 725 | goto nla_put_failure; |
1da177e4 | 726 | |
4b3550ef | 727 | nla_nest_end(skb, nest); |
1da177e4 | 728 | |
5da57f42 | 729 | if (tcf_exts_dump_stats(skb, &f->exts) < 0) |
add93b61 | 730 | goto nla_put_failure; |
1da177e4 LT |
731 | return skb->len; |
732 | ||
add93b61 | 733 | nla_put_failure: |
6ea3b446 | 734 | nla_nest_cancel(skb, nest); |
1da177e4 LT |
735 | return -1; |
736 | } | |
737 | ||
2e24cd75 CW |
738 | static void rsvp_bind_class(void *fh, u32 classid, unsigned long cl, void *q, |
739 | unsigned long base) | |
07d79fc7 CW |
740 | { |
741 | struct rsvp_filter *f = fh; | |
742 | ||
2e24cd75 CW |
743 | if (f && f->res.classid == classid) { |
744 | if (cl) | |
745 | __tcf_bind_filter(q, &f->res, base); | |
746 | else | |
747 | __tcf_unbind_filter(q, &f->res); | |
748 | } | |
07d79fc7 CW |
749 | } |
750 | ||
27e95a8c | 751 | static struct tcf_proto_ops RSVP_OPS __read_mostly = { |
1da177e4 LT |
752 | .kind = RSVP_ID, |
753 | .classify = rsvp_classify, | |
754 | .init = rsvp_init, | |
755 | .destroy = rsvp_destroy, | |
756 | .get = rsvp_get, | |
1da177e4 LT |
757 | .change = rsvp_change, |
758 | .delete = rsvp_delete, | |
759 | .walk = rsvp_walk, | |
760 | .dump = rsvp_dump, | |
07d79fc7 | 761 | .bind_class = rsvp_bind_class, |
1da177e4 LT |
762 | .owner = THIS_MODULE, |
763 | }; | |
764 | ||
765 | static int __init init_rsvp(void) | |
766 | { | |
767 | return register_tcf_proto_ops(&RSVP_OPS); | |
768 | } | |
769 | ||
10297b99 | 770 | static void __exit exit_rsvp(void) |
1da177e4 LT |
771 | { |
772 | unregister_tcf_proto_ops(&RSVP_OPS); | |
773 | } | |
774 | ||
775 | module_init(init_rsvp) | |
776 | module_exit(exit_rsvp) |