~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/sched/act_tunnel_key.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2016, Amir Vadai <amir@vadai.me>
  3  * Copyright (c) 2016, Mellanox Technologies. All rights reserved.
  4  *
  5  * This program is free software; you can redistribute it and/or modify
  6  * it under the terms of the GNU General Public License as published by
  7  * the Free Software Foundation; either version 2 of the License, or
  8  * (at your option) any later version.
  9  */
 10 
 11 #include <linux/module.h>
 12 #include <linux/init.h>
 13 #include <linux/kernel.h>
 14 #include <linux/skbuff.h>
 15 #include <linux/rtnetlink.h>
 16 #include <net/geneve.h>
 17 #include <net/netlink.h>
 18 #include <net/pkt_sched.h>
 19 #include <net/dst.h>
 20 
 21 #include <linux/tc_act/tc_tunnel_key.h>
 22 #include <net/tc_act/tc_tunnel_key.h>
 23 
 24 static unsigned int tunnel_key_net_id;
 25 static struct tc_action_ops act_tunnel_key_ops;
 26 
 27 static int tunnel_key_act(struct sk_buff *skb, const struct tc_action *a,
 28                           struct tcf_result *res)
 29 {
 30         struct tcf_tunnel_key *t = to_tunnel_key(a);
 31         struct tcf_tunnel_key_params *params;
 32         int action;
 33 
 34         params = rcu_dereference_bh(t->params);
 35 
 36         tcf_lastuse_update(&t->tcf_tm);
 37         bstats_cpu_update(this_cpu_ptr(t->common.cpu_bstats), skb);
 38         action = READ_ONCE(t->tcf_action);
 39 
 40         switch (params->tcft_action) {
 41         case TCA_TUNNEL_KEY_ACT_RELEASE:
 42                 skb_dst_drop(skb);
 43                 break;
 44         case TCA_TUNNEL_KEY_ACT_SET:
 45                 skb_dst_drop(skb);
 46                 skb_dst_set(skb, dst_clone(&params->tcft_enc_metadata->dst));
 47                 break;
 48         default:
 49                 WARN_ONCE(1, "Bad tunnel_key action %d.\n",
 50                           params->tcft_action);
 51                 break;
 52         }
 53 
 54         return action;
 55 }
 56 
 57 static const struct nla_policy
 58 enc_opts_policy[TCA_TUNNEL_KEY_ENC_OPTS_MAX + 1] = {
 59         [TCA_TUNNEL_KEY_ENC_OPTS_GENEVE]        = { .type = NLA_NESTED },
 60 };
 61 
 62 static const struct nla_policy
 63 geneve_opt_policy[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX + 1] = {
 64         [TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS]      = { .type = NLA_U16 },
 65         [TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE]       = { .type = NLA_U8 },
 66         [TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]       = { .type = NLA_BINARY,
 67                                                        .len = 128 },
 68 };
 69 
 70 static int
 71 tunnel_key_copy_geneve_opt(const struct nlattr *nla, void *dst, int dst_len,
 72                            struct netlink_ext_ack *extack)
 73 {
 74         struct nlattr *tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX + 1];
 75         int err, data_len, opt_len;
 76         u8 *data;
 77 
 78         err = nla_parse_nested(tb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_MAX,
 79                                nla, geneve_opt_policy, extack);
 80         if (err < 0)
 81                 return err;
 82 
 83         if (!tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS] ||
 84             !tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE] ||
 85             !tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]) {
 86                 NL_SET_ERR_MSG(extack, "Missing tunnel key geneve option class, type or data");
 87                 return -EINVAL;
 88         }
 89 
 90         data = nla_data(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]);
 91         data_len = nla_len(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA]);
 92         if (data_len < 4) {
 93                 NL_SET_ERR_MSG(extack, "Tunnel key geneve option data is less than 4 bytes long");
 94                 return -ERANGE;
 95         }
 96         if (data_len % 4) {
 97                 NL_SET_ERR_MSG(extack, "Tunnel key geneve option data is not a multiple of 4 bytes long");
 98                 return -ERANGE;
 99         }
100 
101         opt_len = sizeof(struct geneve_opt) + data_len;
102         if (dst) {
103                 struct geneve_opt *opt = dst;
104 
105                 WARN_ON(dst_len < opt_len);
106 
107                 opt->opt_class =
108                         nla_get_be16(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS]);
109                 opt->type = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE]);
110                 opt->length = data_len / 4; /* length is in units of 4 bytes */
111                 opt->r1 = 0;
112                 opt->r2 = 0;
113                 opt->r3 = 0;
114 
115                 memcpy(opt + 1, data, data_len);
116         }
117 
118         return opt_len;
119 }
120 
121 static int tunnel_key_copy_opts(const struct nlattr *nla, u8 *dst,
122                                 int dst_len, struct netlink_ext_ack *extack)
123 {
124         int err, rem, opt_len, len = nla_len(nla), opts_len = 0;
125         const struct nlattr *attr, *head = nla_data(nla);
126 
127         err = nla_validate(head, len, TCA_TUNNEL_KEY_ENC_OPTS_MAX,
128                            enc_opts_policy, extack);
129         if (err)
130                 return err;
131 
132         nla_for_each_attr(attr, head, len, rem) {
133                 switch (nla_type(attr)) {
134                 case TCA_TUNNEL_KEY_ENC_OPTS_GENEVE:
135                         opt_len = tunnel_key_copy_geneve_opt(attr, dst,
136                                                              dst_len, extack);
137                         if (opt_len < 0)
138                                 return opt_len;
139                         opts_len += opt_len;
140                         if (dst) {
141                                 dst_len -= opt_len;
142                                 dst += opt_len;
143                         }
144                         break;
145                 }
146         }
147 
148         if (!opts_len) {
149                 NL_SET_ERR_MSG(extack, "Empty list of tunnel options");
150                 return -EINVAL;
151         }
152 
153         if (rem > 0) {
154                 NL_SET_ERR_MSG(extack, "Trailing data after parsing tunnel key options attributes");
155                 return -EINVAL;
156         }
157 
158         return opts_len;
159 }
160 
161 static int tunnel_key_get_opts_len(struct nlattr *nla,
162                                    struct netlink_ext_ack *extack)
163 {
164         return tunnel_key_copy_opts(nla, NULL, 0, extack);
165 }
166 
167 static int tunnel_key_opts_set(struct nlattr *nla, struct ip_tunnel_info *info,
168                                int opts_len, struct netlink_ext_ack *extack)
169 {
170         info->options_len = opts_len;
171         switch (nla_type(nla_data(nla))) {
172         case TCA_TUNNEL_KEY_ENC_OPTS_GENEVE:
173 #if IS_ENABLED(CONFIG_INET)
174                 info->key.tun_flags |= TUNNEL_GENEVE_OPT;
175                 return tunnel_key_copy_opts(nla, ip_tunnel_info_opts(info),
176                                             opts_len, extack);
177 #else
178                 return -EAFNOSUPPORT;
179 #endif
180         default:
181                 NL_SET_ERR_MSG(extack, "Cannot set tunnel options for unknown tunnel type");
182                 return -EINVAL;
183         }
184 }
185 
186 static const struct nla_policy tunnel_key_policy[TCA_TUNNEL_KEY_MAX + 1] = {
187         [TCA_TUNNEL_KEY_PARMS]      = { .len = sizeof(struct tc_tunnel_key) },
188         [TCA_TUNNEL_KEY_ENC_IPV4_SRC] = { .type = NLA_U32 },
189         [TCA_TUNNEL_KEY_ENC_IPV4_DST] = { .type = NLA_U32 },
190         [TCA_TUNNEL_KEY_ENC_IPV6_SRC] = { .len = sizeof(struct in6_addr) },
191         [TCA_TUNNEL_KEY_ENC_IPV6_DST] = { .len = sizeof(struct in6_addr) },
192         [TCA_TUNNEL_KEY_ENC_KEY_ID]   = { .type = NLA_U32 },
193         [TCA_TUNNEL_KEY_ENC_DST_PORT] = {.type = NLA_U16},
194         [TCA_TUNNEL_KEY_NO_CSUM]      = { .type = NLA_U8 },
195         [TCA_TUNNEL_KEY_ENC_OPTS]     = { .type = NLA_NESTED },
196         [TCA_TUNNEL_KEY_ENC_TOS]      = { .type = NLA_U8 },
197         [TCA_TUNNEL_KEY_ENC_TTL]      = { .type = NLA_U8 },
198 };
199 
200 static void tunnel_key_release_params(struct tcf_tunnel_key_params *p)
201 {
202         if (!p)
203                 return;
204         if (p->tcft_action == TCA_TUNNEL_KEY_ACT_SET)
205                 dst_release(&p->tcft_enc_metadata->dst);
206         kfree_rcu(p, rcu);
207 }
208 
209 static int tunnel_key_init(struct net *net, struct nlattr *nla,
210                            struct nlattr *est, struct tc_action **a,
211                            int ovr, int bind, bool rtnl_held,
212                            struct netlink_ext_ack *extack)
213 {
214         struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
215         struct nlattr *tb[TCA_TUNNEL_KEY_MAX + 1];
216         struct tcf_tunnel_key_params *params_new;
217         struct metadata_dst *metadata = NULL;
218         struct tc_tunnel_key *parm;
219         struct tcf_tunnel_key *t;
220         bool exists = false;
221         __be16 dst_port = 0;
222         __be64 key_id = 0;
223         int opts_len = 0;
224         __be16 flags = 0;
225         u8 tos, ttl;
226         int ret = 0;
227         int err;
228 
229         if (!nla) {
230                 NL_SET_ERR_MSG(extack, "Tunnel requires attributes to be passed");
231                 return -EINVAL;
232         }
233 
234         err = nla_parse_nested(tb, TCA_TUNNEL_KEY_MAX, nla, tunnel_key_policy,
235                                extack);
236         if (err < 0) {
237                 NL_SET_ERR_MSG(extack, "Failed to parse nested tunnel key attributes");
238                 return err;
239         }
240 
241         if (!tb[TCA_TUNNEL_KEY_PARMS]) {
242                 NL_SET_ERR_MSG(extack, "Missing tunnel key parameters");
243                 return -EINVAL;
244         }
245 
246         parm = nla_data(tb[TCA_TUNNEL_KEY_PARMS]);
247         err = tcf_idr_check_alloc(tn, &parm->index, a, bind);
248         if (err < 0)
249                 return err;
250         exists = err;
251         if (exists && bind)
252                 return 0;
253 
254         switch (parm->t_action) {
255         case TCA_TUNNEL_KEY_ACT_RELEASE:
256                 break;
257         case TCA_TUNNEL_KEY_ACT_SET:
258                 if (tb[TCA_TUNNEL_KEY_ENC_KEY_ID]) {
259                         __be32 key32;
260 
261                         key32 = nla_get_be32(tb[TCA_TUNNEL_KEY_ENC_KEY_ID]);
262                         key_id = key32_to_tunnel_id(key32);
263                         flags = TUNNEL_KEY;
264                 }
265 
266                 flags |= TUNNEL_CSUM;
267                 if (tb[TCA_TUNNEL_KEY_NO_CSUM] &&
268                     nla_get_u8(tb[TCA_TUNNEL_KEY_NO_CSUM]))
269                         flags &= ~TUNNEL_CSUM;
270 
271                 if (tb[TCA_TUNNEL_KEY_ENC_DST_PORT])
272                         dst_port = nla_get_be16(tb[TCA_TUNNEL_KEY_ENC_DST_PORT]);
273 
274                 if (tb[TCA_TUNNEL_KEY_ENC_OPTS]) {
275                         opts_len = tunnel_key_get_opts_len(tb[TCA_TUNNEL_KEY_ENC_OPTS],
276                                                            extack);
277                         if (opts_len < 0) {
278                                 ret = opts_len;
279                                 goto err_out;
280                         }
281                 }
282 
283                 tos = 0;
284                 if (tb[TCA_TUNNEL_KEY_ENC_TOS])
285                         tos = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_TOS]);
286                 ttl = 0;
287                 if (tb[TCA_TUNNEL_KEY_ENC_TTL])
288                         ttl = nla_get_u8(tb[TCA_TUNNEL_KEY_ENC_TTL]);
289 
290                 if (tb[TCA_TUNNEL_KEY_ENC_IPV4_SRC] &&
291                     tb[TCA_TUNNEL_KEY_ENC_IPV4_DST]) {
292                         __be32 saddr;
293                         __be32 daddr;
294 
295                         saddr = nla_get_in_addr(tb[TCA_TUNNEL_KEY_ENC_IPV4_SRC]);
296                         daddr = nla_get_in_addr(tb[TCA_TUNNEL_KEY_ENC_IPV4_DST]);
297 
298                         metadata = __ip_tun_set_dst(saddr, daddr, tos, ttl,
299                                                     dst_port, flags,
300                                                     key_id, opts_len);
301                 } else if (tb[TCA_TUNNEL_KEY_ENC_IPV6_SRC] &&
302                            tb[TCA_TUNNEL_KEY_ENC_IPV6_DST]) {
303                         struct in6_addr saddr;
304                         struct in6_addr daddr;
305 
306                         saddr = nla_get_in6_addr(tb[TCA_TUNNEL_KEY_ENC_IPV6_SRC]);
307                         daddr = nla_get_in6_addr(tb[TCA_TUNNEL_KEY_ENC_IPV6_DST]);
308 
309                         metadata = __ipv6_tun_set_dst(&saddr, &daddr, tos, ttl, dst_port,
310                                                       0, flags,
311                                                       key_id, 0);
312                 } else {
313                         NL_SET_ERR_MSG(extack, "Missing either ipv4 or ipv6 src and dst");
314                         ret = -EINVAL;
315                         goto err_out;
316                 }
317 
318                 if (!metadata) {
319                         NL_SET_ERR_MSG(extack, "Cannot allocate tunnel metadata dst");
320                         ret = -ENOMEM;
321                         goto err_out;
322                 }
323 
324                 if (opts_len) {
325                         ret = tunnel_key_opts_set(tb[TCA_TUNNEL_KEY_ENC_OPTS],
326                                                   &metadata->u.tun_info,
327                                                   opts_len, extack);
328                         if (ret < 0)
329                                 goto release_tun_meta;
330                 }
331 
332                 metadata->u.tun_info.mode |= IP_TUNNEL_INFO_TX;
333                 break;
334         default:
335                 NL_SET_ERR_MSG(extack, "Unknown tunnel key action");
336                 ret = -EINVAL;
337                 goto err_out;
338         }
339 
340         if (!exists) {
341                 ret = tcf_idr_create(tn, parm->index, est, a,
342                                      &act_tunnel_key_ops, bind, true);
343                 if (ret) {
344                         NL_SET_ERR_MSG(extack, "Cannot create TC IDR");
345                         goto release_tun_meta;
346                 }
347 
348                 ret = ACT_P_CREATED;
349         } else if (!ovr) {
350                 NL_SET_ERR_MSG(extack, "TC IDR already exists");
351                 ret = -EEXIST;
352                 goto release_tun_meta;
353         }
354 
355         t = to_tunnel_key(*a);
356 
357         params_new = kzalloc(sizeof(*params_new), GFP_KERNEL);
358         if (unlikely(!params_new)) {
359                 NL_SET_ERR_MSG(extack, "Cannot allocate tunnel key parameters");
360                 ret = -ENOMEM;
361                 exists = true;
362                 goto release_tun_meta;
363         }
364         params_new->tcft_action = parm->t_action;
365         params_new->tcft_enc_metadata = metadata;
366 
367         spin_lock_bh(&t->tcf_lock);
368         t->tcf_action = parm->action;
369         rcu_swap_protected(t->params, params_new,
370                            lockdep_is_held(&t->tcf_lock));
371         spin_unlock_bh(&t->tcf_lock);
372         tunnel_key_release_params(params_new);
373 
374         if (ret == ACT_P_CREATED)
375                 tcf_idr_insert(tn, *a);
376 
377         return ret;
378 
379 release_tun_meta:
380         if (metadata)
381                 dst_release(&metadata->dst);
382 
383 err_out:
384         if (exists)
385                 tcf_idr_release(*a, bind);
386         else
387                 tcf_idr_cleanup(tn, parm->index);
388         return ret;
389 }
390 
391 static void tunnel_key_release(struct tc_action *a)
392 {
393         struct tcf_tunnel_key *t = to_tunnel_key(a);
394         struct tcf_tunnel_key_params *params;
395 
396         params = rcu_dereference_protected(t->params, 1);
397         tunnel_key_release_params(params);
398 }
399 
400 static int tunnel_key_geneve_opts_dump(struct sk_buff *skb,
401                                        const struct ip_tunnel_info *info)
402 {
403         int len = info->options_len;
404         u8 *src = (u8 *)(info + 1);
405         struct nlattr *start;
406 
407         start = nla_nest_start(skb, TCA_TUNNEL_KEY_ENC_OPTS_GENEVE);
408         if (!start)
409                 return -EMSGSIZE;
410 
411         while (len > 0) {
412                 struct geneve_opt *opt = (struct geneve_opt *)src;
413 
414                 if (nla_put_be16(skb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_CLASS,
415                                  opt->opt_class) ||
416                     nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_TYPE,
417                                opt->type) ||
418                     nla_put(skb, TCA_TUNNEL_KEY_ENC_OPT_GENEVE_DATA,
419                             opt->length * 4, opt + 1)) {
420                         nla_nest_cancel(skb, start);
421                         return -EMSGSIZE;
422                 }
423 
424                 len -= sizeof(struct geneve_opt) + opt->length * 4;
425                 src += sizeof(struct geneve_opt) + opt->length * 4;
426         }
427 
428         nla_nest_end(skb, start);
429         return 0;
430 }
431 
432 static int tunnel_key_opts_dump(struct sk_buff *skb,
433                                 const struct ip_tunnel_info *info)
434 {
435         struct nlattr *start;
436         int err = -EINVAL;
437 
438         if (!info->options_len)
439                 return 0;
440 
441         start = nla_nest_start(skb, TCA_TUNNEL_KEY_ENC_OPTS);
442         if (!start)
443                 return -EMSGSIZE;
444 
445         if (info->key.tun_flags & TUNNEL_GENEVE_OPT) {
446                 err = tunnel_key_geneve_opts_dump(skb, info);
447                 if (err)
448                         goto err_out;
449         } else {
450 err_out:
451                 nla_nest_cancel(skb, start);
452                 return err;
453         }
454 
455         nla_nest_end(skb, start);
456         return 0;
457 }
458 
459 static int tunnel_key_dump_addresses(struct sk_buff *skb,
460                                      const struct ip_tunnel_info *info)
461 {
462         unsigned short family = ip_tunnel_info_af(info);
463 
464         if (family == AF_INET) {
465                 __be32 saddr = info->key.u.ipv4.src;
466                 __be32 daddr = info->key.u.ipv4.dst;
467 
468                 if (!nla_put_in_addr(skb, TCA_TUNNEL_KEY_ENC_IPV4_SRC, saddr) &&
469                     !nla_put_in_addr(skb, TCA_TUNNEL_KEY_ENC_IPV4_DST, daddr))
470                         return 0;
471         }
472 
473         if (family == AF_INET6) {
474                 const struct in6_addr *saddr6 = &info->key.u.ipv6.src;
475                 const struct in6_addr *daddr6 = &info->key.u.ipv6.dst;
476 
477                 if (!nla_put_in6_addr(skb,
478                                       TCA_TUNNEL_KEY_ENC_IPV6_SRC, saddr6) &&
479                     !nla_put_in6_addr(skb,
480                                       TCA_TUNNEL_KEY_ENC_IPV6_DST, daddr6))
481                         return 0;
482         }
483 
484         return -EINVAL;
485 }
486 
487 static int tunnel_key_dump(struct sk_buff *skb, struct tc_action *a,
488                            int bind, int ref)
489 {
490         unsigned char *b = skb_tail_pointer(skb);
491         struct tcf_tunnel_key *t = to_tunnel_key(a);
492         struct tcf_tunnel_key_params *params;
493         struct tc_tunnel_key opt = {
494                 .index    = t->tcf_index,
495                 .refcnt   = refcount_read(&t->tcf_refcnt) - ref,
496                 .bindcnt  = atomic_read(&t->tcf_bindcnt) - bind,
497         };
498         struct tcf_t tm;
499 
500         spin_lock_bh(&t->tcf_lock);
501         params = rcu_dereference_protected(t->params,
502                                            lockdep_is_held(&t->tcf_lock));
503         opt.action   = t->tcf_action;
504         opt.t_action = params->tcft_action;
505 
506         if (nla_put(skb, TCA_TUNNEL_KEY_PARMS, sizeof(opt), &opt))
507                 goto nla_put_failure;
508 
509         if (params->tcft_action == TCA_TUNNEL_KEY_ACT_SET) {
510                 struct ip_tunnel_info *info =
511                         &params->tcft_enc_metadata->u.tun_info;
512                 struct ip_tunnel_key *key = &info->key;
513                 __be32 key_id = tunnel_id_to_key32(key->tun_id);
514 
515                 if (((key->tun_flags & TUNNEL_KEY) &&
516                      nla_put_be32(skb, TCA_TUNNEL_KEY_ENC_KEY_ID, key_id)) ||
517                     tunnel_key_dump_addresses(skb,
518                                               &params->tcft_enc_metadata->u.tun_info) ||
519                     (key->tp_dst &&
520                       nla_put_be16(skb, TCA_TUNNEL_KEY_ENC_DST_PORT,
521                                    key->tp_dst)) ||
522                     nla_put_u8(skb, TCA_TUNNEL_KEY_NO_CSUM,
523                                !(key->tun_flags & TUNNEL_CSUM)) ||
524                     tunnel_key_opts_dump(skb, info))
525                         goto nla_put_failure;
526 
527                 if (key->tos && nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_TOS, key->tos))
528                         goto nla_put_failure;
529 
530                 if (key->ttl && nla_put_u8(skb, TCA_TUNNEL_KEY_ENC_TTL, key->ttl))
531                         goto nla_put_failure;
532         }
533 
534         tcf_tm_dump(&tm, &t->tcf_tm);
535         if (nla_put_64bit(skb, TCA_TUNNEL_KEY_TM, sizeof(tm),
536                           &tm, TCA_TUNNEL_KEY_PAD))
537                 goto nla_put_failure;
538         spin_unlock_bh(&t->tcf_lock);
539 
540         return skb->len;
541 
542 nla_put_failure:
543         spin_unlock_bh(&t->tcf_lock);
544         nlmsg_trim(skb, b);
545         return -1;
546 }
547 
548 static int tunnel_key_walker(struct net *net, struct sk_buff *skb,
549                              struct netlink_callback *cb, int type,
550                              const struct tc_action_ops *ops,
551                              struct netlink_ext_ack *extack)
552 {
553         struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
554 
555         return tcf_generic_walker(tn, skb, cb, type, ops, extack);
556 }
557 
558 static int tunnel_key_search(struct net *net, struct tc_action **a, u32 index)
559 {
560         struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
561 
562         return tcf_idr_search(tn, a, index);
563 }
564 
565 static struct tc_action_ops act_tunnel_key_ops = {
566         .kind           =       "tunnel_key",
567         .type           =       TCA_ACT_TUNNEL_KEY,
568         .owner          =       THIS_MODULE,
569         .act            =       tunnel_key_act,
570         .dump           =       tunnel_key_dump,
571         .init           =       tunnel_key_init,
572         .cleanup        =       tunnel_key_release,
573         .walk           =       tunnel_key_walker,
574         .lookup         =       tunnel_key_search,
575         .size           =       sizeof(struct tcf_tunnel_key),
576 };
577 
578 static __net_init int tunnel_key_init_net(struct net *net)
579 {
580         struct tc_action_net *tn = net_generic(net, tunnel_key_net_id);
581 
582         return tc_action_net_init(tn, &act_tunnel_key_ops);
583 }
584 
585 static void __net_exit tunnel_key_exit_net(struct list_head *net_list)
586 {
587         tc_action_net_exit(net_list, tunnel_key_net_id);
588 }
589 
590 static struct pernet_operations tunnel_key_net_ops = {
591         .init = tunnel_key_init_net,
592         .exit_batch = tunnel_key_exit_net,
593         .id   = &tunnel_key_net_id,
594         .size = sizeof(struct tc_action_net),
595 };
596 
597 static int __init tunnel_key_init_module(void)
598 {
599         return tcf_register_action(&act_tunnel_key_ops, &tunnel_key_net_ops);
600 }
601 
602 static void __exit tunnel_key_cleanup_module(void)
603 {
604         tcf_unregister_action(&act_tunnel_key_ops, &tunnel_key_net_ops);
605 }
606 
607 module_init(tunnel_key_init_module);
608 module_exit(tunnel_key_cleanup_module);
609 
610 MODULE_AUTHOR("Amir Vadai <amir@vadai.me>");
611 MODULE_DESCRIPTION("ip tunnel manipulation actions");
612 MODULE_LICENSE("GPL v2");
613 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp