?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'io_uring-5.11-2021-01-16' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / net / sched / act_tunnel_key.c
blob85c0d0d5b9da5cdd884028387654090b6a0f7799
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (c) 2016, Amir Vadai <amir@vadai.me>
4 * Copyright (c) 2016, Mellanox Technologies. All rights reserved.
5 */
6
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/kernel.h>
10 #include <linux/skbuff.h>
11 #include <linux/rtnetlink.h>
12 #include <net/geneve.h>
13 #include <net/vxlan.h>
14 #include <net/erspan.h>
15 #include <net/netlink.h>
16 #include <net/pkt_sched.h>
17 #include <net/dst.h>
18 #include <net/pkt_cls.h>
19
20 #include <linux/tc_act/tc_tunnel_key.h>
21 #include <net/tc_act/tc_tunnel_key.h>
22
23 static unsigned int tunnel_key_net_id;
24 static struct tc_action_ops act_tunnel_key_ops;
25
26 static int tunnel_key_act(struct sk_buff *skb, const struct tc_action *a,
27 struct tcf_result *res)
28 {
29 struct tcf_tunnel_key *t = to_tunnel_key(a);
30 struct tcf_tunnel_key_params *params;
31 int action;
32
33 params = rcu_dereference_bh(t->params);
34
35 tcf_lastuse_update(&t->tcf_tm);
36 tcf_action_update_bstats(&t->common, skb);
37 action = READ_ONCE(t->tcf_action);
38
39 switch (params->tcft_action) {
40 case TCA_TUNNEL_KEY_ACT_RELEASE:
41 skb_dst_drop(skb);
42 break;
43 case TCA_TUNNEL_KEY_ACT_SET:
44 skb_dst_drop(skb);
45 skb_dst_set(skb, dst_clone(&params->tcft_enc_metadata->dst));
46 break;
47 default:
48 WARN_ONCE(1, "Bad tunnel_key action %d.\n",
49 params->tcft_action);
50 break;
51 }
52
53 return action;
54 }
55
56 static const struct nla_policy
57 enc_opts_policy[TCA_TUNNEL_KEY_ENC_OPTS_MAX + 1] = {
58 [TCA_TUNNEL_KEY_ENC_OPTS_UNSPEC] = {
59 .strict_start_type = TCA_TUNNEL_KEY_ENC_OPTS_VXLAN },
60 [TCA_TUNNEL_KEY_ENC_OPTS_GENEVE] = { .type = NLA_NESTED },
61 [TCA_TUNNEL_KEY_ENC_OPTS_VXLAN] = { .type = NLA_NESTED },
62 [TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN] = { .type = NLA_NESTED },
63 };
64
65 static const struct nla_policy
66 geneve_opt_policy[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX + 1] = {
67 [TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS] = { .type = NLA_U16 },
68 [TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE] = { .type = NLA_U8 },
69 [TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA] = { .type = NLA_BINARY,
70 .len = 128 },
71 };
72
73 static const struct nla_policy
74 vxlan_opt_policy[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX + 1] = {
75 [TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP] = { .type = NLA_U32 },
76 };
77
78 static const struct nla_policy
79 erspan_opt_policy[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX + 1] = {
80 [TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER] = { .type = NLA_U8 },
81 [TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX] = { .type = NLA_U32 },
82 [TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR] = { .type = NLA_U8 },
83 [TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID] = { .type = NLA_U8 },
84 };
85
86 static int
87 tunnel_key_copy_geneve_opt(const struct nlattr *nla, void *dst, int dst_len,
88 struct netlink_ext_ack *extack)
89 {
90 struct nlattr *tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX + 1];
91 int err, data_len, opt_len;
92 u8 *data;
93
94 err = nla_parse_nested_deprecated(tb,
95 TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX,
96 nla, geneve_opt_policy, extack);
97 if (err < 0)
98 return err;
99
100 if (!tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS] ||
101 !tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE] ||
102 !tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]) {
103 NL_SET_ERR_MSG(extack, "Missing tunnel key geneve option class, type or data");
104 return -EINVAL;
105 }
106
107 data = nla_data(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]);
108 data_len = nla_len(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]);
109 if (data_len < 4) {
110 NL_SET_ERR_MSG(extack, "Tunnel key geneve option data is less than 4 bytes long");
111 return -ERANGE;
112 }
113 if (data_len % 4) {
114 NL_SET_ERR_MSG(extack, "Tunnel key geneve option data is not a multiple of 4 bytes long");
115 return -ERANGE;
116 }
117
118 opt_len = sizeof(struct geneve_opt) + data_len;
119 if (dst) {
120 struct geneve_opt *opt = dst;
121
122 WARN_ON(dst_len < opt_len);
123
124 opt->opt_class =
125 nla_get_be16(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS]);
126 opt->type = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE]);
127 opt->length = data_len / 4; /* length is in units of 4 bytes */
128 opt->r1 = 0;
129 opt->r2 = 0;
130 opt->r3 = 0;
131
132 memcpy(opt + 1, data, data_len);
133 }
134
135 return opt_len;
136 }
137
138 static int
139 tunnel_key_copy_vxlan_opt(const struct nlattr *nla, void *dst, int dst_len,
140 struct netlink_ext_ack *extack)
141 {
142 struct nlattr *tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX + 1];
143 int err;
144
145 err = nla_parse_nested(tb, TCA_TUNNEL_KEY_ENC_OPT_VXLAN_MAX, nla,
146 vxlan_opt_policy, extack);
147 if (err < 0)
148 return err;
149
150 if (!tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP]) {
151 NL_SET_ERR_MSG(extack, "Missing tunnel key vxlan option gbp");
152 return -EINVAL;
153 }
154
155 if (dst) {
156 struct vxlan_metadata *md = dst;
157
158 md->gbp = nla_get_u32(tb[TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP]);
159 md->gbp &= VXLAN_GBP_MASK;
160 }
161
162 return sizeof(struct vxlan_metadata);
163 }
164
165 static int
166 tunnel_key_copy_erspan_opt(const struct nlattr *nla, void *dst, int dst_len,
167 struct netlink_ext_ack *extack)
168 {
169 struct nlattr *tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX + 1];
170 int err;
171 u8 ver;
172
173 err = nla_parse_nested(tb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_MAX, nla,
174 erspan_opt_policy, extack);
175 if (err < 0)
176 return err;
177
178 if (!tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER]) {
179 NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option ver");
180 return -EINVAL;
181 }
182
183 ver = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER]);
184 if (ver == 1) {
185 if (!tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX]) {
186 NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option index");
187 return -EINVAL;
188 }
189 } else if (ver == 2) {
190 if (!tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR] ||
191 !tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID]) {
192 NL_SET_ERR_MSG(extack, "Missing tunnel key erspan option dir or hwid");
193 return -EINVAL;
194 }
195 } else {
196 NL_SET_ERR_MSG(extack, "Tunnel key erspan option ver is incorrect");
197 return -EINVAL;
198 }
199
200 if (dst) {
201 struct erspan_metadata *md = dst;
202
203 md->version = ver;
204 if (ver == 1) {
205 nla = tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX];
206 md->u.index = nla_get_be32(nla);
207 } else {
208 nla = tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR];
209 md->u.md2.dir = nla_get_u8(nla);
210 nla = tb[TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID];
211 set_hwid(&md->u.md2, nla_get_u8(nla));
212 }
213 }
214
215 return sizeof(struct erspan_metadata);
216 }
217
218 static int tunnel_key_copy_opts(const struct nlattr *nla, u8 *dst,
219 int dst_len, struct netlink_ext_ack *extack)
220 {
221 int err, rem, opt_len, len = nla_len(nla), opts_len = 0, type = 0;
222 const struct nlattr *attr, *head = nla_data(nla);
223
224 err = nla_validate_deprecated(head, len, TCA_TUNNEL_KEY_ENC_OPTS_MAX,
225 enc_opts_policy, extack);
226 if (err)
227 return err;
228
229 nla_for_each_attr(attr, head, len, rem) {
230 switch (nla_type(attr)) {
231 case TCA_TUNNEL_KEY_ENC_OPTS_GENEVE:
232 if (type && type != TUNNEL_GENEVE_OPT) {
233 NL_SET_ERR_MSG(extack, "Duplicate type for geneve options");
234 return -EINVAL;
235 }
236 opt_len = tunnel_key_copy_geneve_opt(attr, dst,
237 dst_len, extack);
238 if (opt_len < 0)
239 return opt_len;
240 opts_len += opt_len;
241 if (opts_len > IP_TUNNEL_OPTS_MAX) {
242 NL_SET_ERR_MSG(extack, "Tunnel options exceeds max size");
243 return -EINVAL;
244 }
245 if (dst) {
246 dst_len -= opt_len;
247 dst += opt_len;
248 }
249 type = TUNNEL_GENEVE_OPT;
250 break;
251 case TCA_TUNNEL_KEY_ENC_OPTS_VXLAN:
252 if (type) {
253 NL_SET_ERR_MSG(extack, "Duplicate type for vxlan options");
254 return -EINVAL;
255 }
256 opt_len = tunnel_key_copy_vxlan_opt(attr, dst,
257 dst_len, extack);
258 if (opt_len < 0)
259 return opt_len;
260 opts_len += opt_len;
261 type = TUNNEL_VXLAN_OPT;
262 break;
263 case TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN:
264 if (type) {
265 NL_SET_ERR_MSG(extack, "Duplicate type for erspan options");
266 return -EINVAL;
267 }
268 opt_len = tunnel_key_copy_erspan_opt(attr, dst,
269 dst_len, extack);
270 if (opt_len < 0)
271 return opt_len;
272 opts_len += opt_len;
273 type = TUNNEL_ERSPAN_OPT;
274 break;
275 }
276 }
277
278 if (!opts_len) {
279 NL_SET_ERR_MSG(extack, "Empty list of tunnel options");
280 return -EINVAL;
281 }
282
283 if (rem > 0) {
284 NL_SET_ERR_MSG(extack, "Trailing data after parsing tunnel key options attributes");
285 return -EINVAL;
286 }
287
288 return opts_len;
289 }
290
291 static int tunnel_key_get_opts_len(struct nlattr *nla,
292 struct netlink_ext_ack *extack)
293 {
294 return tunnel_key_copy_opts(nla, NULL, 0, extack);
295 }
296
297 static int tunnel_key_opts_set(struct nlattr *nla, struct ip_tunnel_info *info,
298 int opts_len, struct netlink_ext_ack *extack)
299 {
300 info->options_len = opts_len;
301 switch (nla_type(nla_data(nla))) {
302 case TCA_TUNNEL_KEY_ENC_OPTS_GENEVE:
303 #if IS_ENABLED(CONFIG_INET)
304 info->key.tun_flags |= TUNNEL_GENEVE_OPT;
305 return tunnel_key_copy_opts(nla, ip_tunnel_info_opts(info),
306 opts_len, extack);
307 #else
308 return -EAFNOSUPPORT;
309 #endif
310 case TCA_TUNNEL_KEY_ENC_OPTS_VXLAN:
311 #if IS_ENABLED(CONFIG_INET)
312 info->key.tun_flags |= TUNNEL_VXLAN_OPT;
313 return tunnel_key_copy_opts(nla, ip_tunnel_info_opts(info),
314 opts_len, extack);
315 #else
316 return -EAFNOSUPPORT;
317 #endif
318 case TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN:
319 #if IS_ENABLED(CONFIG_INET)
320 info->key.tun_flags |= TUNNEL_ERSPAN_OPT;
321 return tunnel_key_copy_opts(nla, ip_tunnel_info_opts(info),
322 opts_len, extack);
323 #else
324 return -EAFNOSUPPORT;
325 #endif
326 default:
327 NL_SET_ERR_MSG(extack, "Cannot set tunnel options for unknown tunnel type");
328 return -EINVAL;
329 }
330 }
331
332 static const struct nla_policy tunnel_key_policy[TCA_TUNNEL_KEY_MAX + 1] = {
333 [TCA_TUNNEL_KEY_PARMS] = { .len = sizeof(struct tc_tunnel_key) },
334 [TCA_TUNNEL_KEY_ENC_IPV4_SRC] = { .type = NLA_U32 },
335 [TCA_TUNNEL_KEY_ENC_IPV4_DST] = { .type = NLA_U32 },
336 [TCA_TUNNEL_KEY_ENC_IPV6_SRC] = { .len = sizeof(struct in6_addr) },
337 [TCA_TUNNEL_KEY_ENC_IPV6_DST] = { .len = sizeof(struct in6_addr) },
338 [TCA_TUNNEL_KEY_ENC_KEY_ID] = { .type = NLA_U32 },
339 [TCA_TUNNEL_KEY_ENC_DST_PORT] = {.type = NLA_U16},
340 [TCA_TUNNEL_KEY_NO_CSUM] = { .type = NLA_U8 },
341 [TCA_TUNNEL_KEY_ENC_OPTS] = { .type = NLA_NESTED },
342 [TCA_TUNNEL_KEY_ENC_TOS] = { .type = NLA_U8 },
343 [TCA_TUNNEL_KEY_ENC_TTL] = { .type = NLA_U8 },
344 };
345
346 static void tunnel_key_release_params(struct tcf_tunnel_key_params *p)
347 {
348 if (!p)
349 return;
350 if (p->tcft_action == TCA_TUNNEL_KEY_ACT_SET)
351 dst_release(&p->tcft_enc_metadata->dst);
352
353 kfree_rcu(p, rcu);
354 }
355
356 static int tunnel_key_init(struct net *net, struct nlattr *nla,
357 struct nlattr *est, struct tc_action **a,
358 int ovr, int bind, bool rtnl_held,
359 struct tcf_proto *tp, u32 act_flags,
360 struct netlink_ext_ack *extack)
361 {
362 struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
363 struct nlattr *tb[TCA_TUNNEL_KEY_MAX + 1];
364 struct tcf_tunnel_key_params *params_new;
365 struct metadata_dst *metadata = NULL;
366 struct tcf_chain *goto_ch = NULL;
367 struct tc_tunnel_key *parm;
368 struct tcf_tunnel_key *t;
369 bool exists = false;
370 __be16 dst_port = 0;
371 __be64 key_id = 0;
372 int opts_len = 0;
373 __be16 flags = 0;
374 u8 tos, ttl;
375 int ret = 0;
376 u32 index;
377 int err;
378
379 if (!nla) {
380 NL_SET_ERR_MSG(extack, "Tunnel requires attributes to be passed");
381 return -EINVAL;
382 }
383
384 err = nla_parse_nested_deprecated(tb, TCA_TUNNEL_KEY_MAX, nla,
385 tunnel_key_policy, extack);
386 if (err < 0) {
387 NL_SET_ERR_MSG(extack, "Failed to parse nested tunnel key attributes");
388 return err;
389 }
390
391 if (!tb[TCA_TUNNEL_KEY_PARMS]) {
392 NL_SET_ERR_MSG(extack, "Missing tunnel key parameters");
393 return -EINVAL;
394 }
395
396 parm = nla_data(tb[TCA_TUNNEL_KEY_PARMS]);
397 index = parm->index;
398 err = tcf_idr_check_alloc(tn, &index, a, bind);
399 if (err < 0)
400 return err;
401 exists = err;
402 if (exists && bind)
403 return 0;
404
405 switch (parm->t_action) {
406 case TCA_TUNNEL_KEY_ACT_RELEASE:
407 break;
408 case TCA_TUNNEL_KEY_ACT_SET:
409 if (tb[TCA_TUNNEL_KEY_ENC_KEY_ID]) {
410 __be32 key32;
411
412 key32 = nla_get_be32(tb[TCA_TUNNEL_KEY_ENC_KEY_ID]);
413 key_id = key32_to_tunnel_id(key32);
414 flags = TUNNEL_KEY;
415 }
416
417 flags |= TUNNEL_CSUM;
418 if (tb[TCA_TUNNEL_KEY_NO_CSUM] &&
419 nla_get_u8(tb[TCA_TUNNEL_KEY_NO_CSUM]))
420 flags &= ~TUNNEL_CSUM;
421
422 if (tb[TCA_TUNNEL_KEY_ENC_DST_PORT])
423 dst_port = nla_get_be16(tb[TCA_TUNNEL_KEY_ENC_DST_PORT]);
424
425 if (tb[TCA_TUNNEL_KEY_ENC_OPTS]) {
426 opts_len = tunnel_key_get_opts_len(tb[TCA_TUNNEL_KEY_ENC_OPTS],
427 extack);
428 if (opts_len < 0) {
429 ret = opts_len;
430 goto err_out;
431 }
432 }
433
434 tos = 0;
435 if (tb[TCA_TUNNEL_KEY_ENC_TOS])
436 tos = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_TOS]);
437 ttl = 0;
438 if (tb[TCA_TUNNEL_KEY_ENC_TTL])
439 ttl = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_TTL]);
440
441 if (tb[TCA_TUNNEL_KEY_ENC_IPV4_SRC] &&
442 tb[TCA_TUNNEL_KEY_ENC_IPV4_DST]) {
443 __be32 saddr;
444 __be32 daddr;
445
446 saddr = nla_get_in_addr(tb[TCA_TUNNEL_KEY_ENC_IPV4_SRC]);
447 daddr = nla_get_in_addr(tb[TCA_TUNNEL_KEY_ENC_IPV4_DST]);
448
449 metadata = __ip_tun_set_dst(saddr, daddr, tos, ttl,
450 dst_port, flags,
451 key_id, opts_len);
452 } else if (tb[TCA_TUNNEL_KEY_ENC_IPV6_SRC] &&
453 tb[TCA_TUNNEL_KEY_ENC_IPV6_DST]) {
454 struct in6_addr saddr;
455 struct in6_addr daddr;
456
457 saddr = nla_get_in6_addr(tb[TCA_TUNNEL_KEY_ENC_IPV6_SRC]);
458 daddr = nla_get_in6_addr(tb[TCA_TUNNEL_KEY_ENC_IPV6_DST]);
459
460 metadata = __ipv6_tun_set_dst(&saddr, &daddr, tos, ttl, dst_port,
461 0, flags,
462 key_id, opts_len);
463 } else {
464 NL_SET_ERR_MSG(extack, "Missing either ipv4 or ipv6 src and dst");
465 ret = -EINVAL;
466 goto err_out;
467 }
468
469 if (!metadata) {
470 NL_SET_ERR_MSG(extack, "Cannot allocate tunnel metadata dst");
471 ret = -ENOMEM;
472 goto err_out;
473 }
474
475 #ifdef CONFIG_DST_CACHE
476 ret = dst_cache_init(&metadata->u.tun_info.dst_cache, GFP_KERNEL);
477 if (ret)
478 goto release_tun_meta;
479 #endif
480
481 if (opts_len) {
482 ret = tunnel_key_opts_set(tb[TCA_TUNNEL_KEY_ENC_OPTS],
483 &metadata->u.tun_info,
484 opts_len, extack);
485 if (ret < 0)
486 goto release_tun_meta;
487 }
488
489 metadata->u.tun_info.mode |= IP_TUNNEL_INFO_TX;
490 break;
491 default:
492 NL_SET_ERR_MSG(extack, "Unknown tunnel key action");
493 ret = -EINVAL;
494 goto err_out;
495 }
496
497 if (!exists) {
498 ret = tcf_idr_create_from_flags(tn, index, est, a,
499 &act_tunnel_key_ops, bind,
500 act_flags);
501 if (ret) {
502 NL_SET_ERR_MSG(extack, "Cannot create TC IDR");
503 goto release_tun_meta;
504 }
505
506 ret = ACT_P_CREATED;
507 } else if (!ovr) {
508 NL_SET_ERR_MSG(extack, "TC IDR already exists");
509 ret = -EEXIST;
510 goto release_tun_meta;
511 }
512
513 err = tcf_action_check_ctrlact(parm->action, tp, &goto_ch, extack);
514 if (err < 0) {
515 ret = err;
516 exists = true;
517 goto release_tun_meta;
518 }
519 t = to_tunnel_key(*a);
520
521 params_new = kzalloc(sizeof(*params_new), GFP_KERNEL);
522 if (unlikely(!params_new)) {
523 NL_SET_ERR_MSG(extack, "Cannot allocate tunnel key parameters");
524 ret = -ENOMEM;
525 exists = true;
526 goto put_chain;
527 }
528 params_new->tcft_action = parm->t_action;
529 params_new->tcft_enc_metadata = metadata;
530
531 spin_lock_bh(&t->tcf_lock);
532 goto_ch = tcf_action_set_ctrlact(*a, parm->action, goto_ch);
533 params_new = rcu_replace_pointer(t->params, params_new,
534 lockdep_is_held(&t->tcf_lock));
535 spin_unlock_bh(&t->tcf_lock);
536 tunnel_key_release_params(params_new);
537 if (goto_ch)
538 tcf_chain_put_by_act(goto_ch);
539
540 return ret;
541
542 put_chain:
543 if (goto_ch)
544 tcf_chain_put_by_act(goto_ch);
545
546 release_tun_meta:
547 if (metadata)
548 dst_release(&metadata->dst);
549
550 err_out:
551 if (exists)
552 tcf_idr_release(*a, bind);
553 else
554 tcf_idr_cleanup(tn, index);
555 return ret;
556 }
557
558 static void tunnel_key_release(struct tc_action *a)
559 {
560 struct tcf_tunnel_key *t = to_tunnel_key(a);
561 struct tcf_tunnel_key_params *params;
562
563 params = rcu_dereference_protected(t->params, 1);
564 tunnel_key_release_params(params);
565 }
566
567 static int tunnel_key_geneve_opts_dump(struct sk_buff *skb,
568 const struct ip_tunnel_info *info)
569 {
570 int len = info->options_len;
571 u8 *src = (u8 *)(info + 1);
572 struct nlattr *start;
573
574 start = nla_nest_start_noflag(skb, TCA_TUNNEL_KEY_ENC_OPTS_GENEVE);
575 if (!start)
576 return -EMSGSIZE;
577
578 while (len > 0) {
579 struct geneve_opt *opt = (struct geneve_opt *)src;
580
581 if (nla_put_be16(skb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS,
582 opt->opt_class) ||
583 nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE,
584 opt->type) ||
585 nla_put(skb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA,
586 opt->length * 4, opt + 1)) {
587 nla_nest_cancel(skb, start);
588 return -EMSGSIZE;
589 }
590
591 len -= sizeof(struct geneve_opt) + opt->length * 4;
592 src += sizeof(struct geneve_opt) + opt->length * 4;
593 }
594
595 nla_nest_end(skb, start);
596 return 0;
597 }
598
599 static int tunnel_key_vxlan_opts_dump(struct sk_buff *skb,
600 const struct ip_tunnel_info *info)
601 {
602 struct vxlan_metadata *md = (struct vxlan_metadata *)(info + 1);
603 struct nlattr *start;
604
605 start = nla_nest_start_noflag(skb, TCA_TUNNEL_KEY_ENC_OPTS_VXLAN);
606 if (!start)
607 return -EMSGSIZE;
608
609 if (nla_put_u32(skb, TCA_TUNNEL_KEY_ENC_OPT_VXLAN_GBP, md->gbp)) {
610 nla_nest_cancel(skb, start);
611 return -EMSGSIZE;
612 }
613
614 nla_nest_end(skb, start);
615 return 0;
616 }
617
618 static int tunnel_key_erspan_opts_dump(struct sk_buff *skb,
619 const struct ip_tunnel_info *info)
620 {
621 struct erspan_metadata *md = (struct erspan_metadata *)(info + 1);
622 struct nlattr *start;
623
624 start = nla_nest_start_noflag(skb, TCA_TUNNEL_KEY_ENC_OPTS_ERSPAN);
625 if (!start)
626 return -EMSGSIZE;
627
628 if (nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_VER, md->version))
629 goto err;
630
631 if (md->version == 1 &&
632 nla_put_be32(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_INDEX, md->u.index))
633 goto err;
634
635 if (md->version == 2 &&
636 (nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_DIR,
637 md->u.md2.dir) ||
638 nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_ERSPAN_HWID,
639 get_hwid(&md->u.md2))))
640 goto err;
641
642 nla_nest_end(skb, start);
643 return 0;
644 err:
645 nla_nest_cancel(skb, start);
646 return -EMSGSIZE;
647 }
648
649 static int tunnel_key_opts_dump(struct sk_buff *skb,
650 const struct ip_tunnel_info *info)
651 {
652 struct nlattr *start;
653 int err = -EINVAL;
654
655 if (!info->options_len)
656 return 0;
657
658 start = nla_nest_start_noflag(skb, TCA_TUNNEL_KEY_ENC_OPTS);
659 if (!start)
660 return -EMSGSIZE;
661
662 if (info->key.tun_flags & TUNNEL_GENEVE_OPT) {
663 err = tunnel_key_geneve_opts_dump(skb, info);
664 if (err)
665 goto err_out;
666 } else if (info->key.tun_flags & TUNNEL_VXLAN_OPT) {
667 err = tunnel_key_vxlan_opts_dump(skb, info);
668 if (err)
669 goto err_out;
670 } else if (info->key.tun_flags & TUNNEL_ERSPAN_OPT) {
671 err = tunnel_key_erspan_opts_dump(skb, info);
672 if (err)
673 goto err_out;
674 } else {
675 err_out:
676 nla_nest_cancel(skb, start);
677 return err;
678 }
679
680 nla_nest_end(skb, start);
681 return 0;
682 }
683
684 static int tunnel_key_dump_addresses(struct sk_buff *skb,
685 const struct ip_tunnel_info *info)
686 {
687 unsigned short family = ip_tunnel_info_af(info);
688
689 if (family == AF_INET) {
690 __be32 saddr = info->key.u.ipv4.src;
691 __be32 daddr = info->key.u.ipv4.dst;
692
693 if (!nla_put_in_addr(skb, TCA_TUNNEL_KEY_ENC_IPV4_SRC, saddr) &&
694 !nla_put_in_addr(skb, TCA_TUNNEL_KEY_ENC_IPV4_DST, daddr))
695 return 0;
696 }
697
698 if (family == AF_INET6) {
699 const struct in6_addr *saddr6 = &info->key.u.ipv6.src;
700 const struct in6_addr *daddr6 = &info->key.u.ipv6.dst;
701
702 if (!nla_put_in6_addr(skb,
703 TCA_TUNNEL_KEY_ENC_IPV6_SRC, saddr6) &&
704 !nla_put_in6_addr(skb,
705 TCA_TUNNEL_KEY_ENC_IPV6_DST, daddr6))
706 return 0;
707 }
708
709 return -EINVAL;
710 }
711
712 static int tunnel_key_dump(struct sk_buff *skb, struct tc_action *a,
713 int bind, int ref)
714 {
715 unsigned char *b = skb_tail_pointer(skb);
716 struct tcf_tunnel_key *t = to_tunnel_key(a);
717 struct tcf_tunnel_key_params *params;
718 struct tc_tunnel_key opt = {
719 .index = t->tcf_index,
720 .refcnt = refcount_read(&t->tcf_refcnt) - ref,
721 .bindcnt = atomic_read(&t->tcf_bindcnt) - bind,
722 };
723 struct tcf_t tm;
724
725 spin_lock_bh(&t->tcf_lock);
726 params = rcu_dereference_protected(t->params,
727 lockdep_is_held(&t->tcf_lock));
728 opt.action = t->tcf_action;
729 opt.t_action = params->tcft_action;
730
731 if (nla_put(skb, TCA_TUNNEL_KEY_PARMS, sizeof(opt), &opt))
732 goto nla_put_failure;
733
734 if (params->tcft_action == TCA_TUNNEL_KEY_ACT_SET) {
735 struct ip_tunnel_info *info =
736 &params->tcft_enc_metadata->u.tun_info;
737 struct ip_tunnel_key *key = &info->key;
738 __be32 key_id = tunnel_id_to_key32(key->tun_id);
739
740 if (((key->tun_flags & TUNNEL_KEY) &&
741 nla_put_be32(skb, TCA_TUNNEL_KEY_ENC_KEY_ID, key_id)) ||
742 tunnel_key_dump_addresses(skb,
743 &params->tcft_enc_metadata->u.tun_info) ||
744 (key->tp_dst &&
745 nla_put_be16(skb, TCA_TUNNEL_KEY_ENC_DST_PORT,
746 key->tp_dst)) ||
747 nla_put_u8(skb, TCA_TUNNEL_KEY_NO_CSUM,
748 !(key->tun_flags & TUNNEL_CSUM)) ||
749 tunnel_key_opts_dump(skb, info))
750 goto nla_put_failure;
751
752 if (key->tos && nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_TOS, key->tos))
753 goto nla_put_failure;
754
755 if (key->ttl && nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_TTL, key->ttl))
756 goto nla_put_failure;
757 }
758
759 tcf_tm_dump(&tm, &t->tcf_tm);
760 if (nla_put_64bit(skb, TCA_TUNNEL_KEY_TM, sizeof(tm),
761 &tm, TCA_TUNNEL_KEY_PAD))
762 goto nla_put_failure;
763 spin_unlock_bh(&t->tcf_lock);
764
765 return skb->len;
766
767 nla_put_failure:
768 spin_unlock_bh(&t->tcf_lock);
769 nlmsg_trim(skb, b);
770 return -1;
771 }
772
773 static int tunnel_key_walker(struct net *net, struct sk_buff *skb,
774 struct netlink_callback *cb, int type,
775 const struct tc_action_ops *ops,
776 struct netlink_ext_ack *extack)
777 {
778 struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
779
780 return tcf_generic_walker(tn, skb, cb, type, ops, extack);
781 }
782
783 static int tunnel_key_search(struct net *net, struct tc_action **a, u32 index)
784 {
785 struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
786
787 return tcf_idr_search(tn, a, index);
788 }
789
790 static struct tc_action_ops act_tunnel_key_ops = {
791 .kind = "tunnel_key",
792 .id = TCA_ID_TUNNEL_KEY,
793 .owner = THIS_MODULE,
794 .act = tunnel_key_act,
795 .dump = tunnel_key_dump,
796 .init = tunnel_key_init,
797 .cleanup = tunnel_key_release,
798 .walk = tunnel_key_walker,
799 .lookup = tunnel_key_search,
800 .size = sizeof(struct tcf_tunnel_key),
801 };
802
803 static __net_init int tunnel_key_init_net(struct net *net)
804 {
805 struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
806
807 return tc_action_net_init(net, tn, &act_tunnel_key_ops);
808 }
809
810 static void __net_exit tunnel_key_exit_net(struct list_head *net_list)
811 {
812 tc_action_net_exit(net_list, tunnel_key_net_id);
813 }
814
815 static struct pernet_operations tunnel_key_net_ops = {
816 .init = tunnel_key_init_net,
817 .exit_batch = tunnel_key_exit_net,
818 .id = &tunnel_key_net_id,
819 .size = sizeof(struct tc_action_net),
820 };
821
822 static int __init tunnel_key_init_module(void)
823 {
824 return tcf_register_action(&act_tunnel_key_ops, &tunnel_key_net_ops);
825 }
826
827 static void __exit tunnel_key_cleanup_module(void)
828 {
829 tcf_unregister_action(&act_tunnel_key_ops, &tunnel_key_net_ops);
830 }
831
832 module_init(tunnel_key_init_module);
833 module_exit(tunnel_key_cleanup_module);
834
835 MODULE_AUTHOR("Amir Vadai <amir@vadai.me>");
836 MODULE_DESCRIPTION("ip tunnel manipulation actions");
837 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support