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

TOMOYO Linux Cross Reference
Linux/net/ipv6/seg6_local.c

Version: ~ [ linux-5.12 ] ~ [ linux-5.11.16 ] ~ [ linux-5.10.32 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.114 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.188 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.231 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.267 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.267 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  *  SR-IPv6 implementation
  4  *
  5  *  Authors:
  6  *  David Lebrun <david.lebrun@uclouvain.be>
  7  *  eBPF support: Mathieu Xhonneux <m.xhonneux@gmail.com>
  8  */
  9 
 10 #include <linux/types.h>
 11 #include <linux/skbuff.h>
 12 #include <linux/net.h>
 13 #include <linux/module.h>
 14 #include <net/ip.h>
 15 #include <net/lwtunnel.h>
 16 #include <net/netevent.h>
 17 #include <net/netns/generic.h>
 18 #include <net/ip6_fib.h>
 19 #include <net/route.h>
 20 #include <net/seg6.h>
 21 #include <linux/seg6.h>
 22 #include <linux/seg6_local.h>
 23 #include <net/addrconf.h>
 24 #include <net/ip6_route.h>
 25 #include <net/dst_cache.h>
 26 #include <net/ip_tunnels.h>
 27 #ifdef CONFIG_IPV6_SEG6_HMAC
 28 #include <net/seg6_hmac.h>
 29 #endif
 30 #include <net/seg6_local.h>
 31 #include <linux/etherdevice.h>
 32 #include <linux/bpf.h>
 33 
 34 struct seg6_local_lwt;
 35 
 36 struct seg6_action_desc {
 37         int action;
 38         unsigned long attrs;
 39         int (*input)(struct sk_buff *skb, struct seg6_local_lwt *slwt);
 40         int static_headroom;
 41 };
 42 
 43 struct bpf_lwt_prog {
 44         struct bpf_prog *prog;
 45         char *name;
 46 };
 47 
 48 struct seg6_local_lwt {
 49         int action;
 50         struct ipv6_sr_hdr *srh;
 51         int table;
 52         struct in_addr nh4;
 53         struct in6_addr nh6;
 54         int iif;
 55         int oif;
 56         struct bpf_lwt_prog bpf;
 57 
 58         int headroom;
 59         struct seg6_action_desc *desc;
 60 };
 61 
 62 static struct seg6_local_lwt *seg6_local_lwtunnel(struct lwtunnel_state *lwt)
 63 {
 64         return (struct seg6_local_lwt *)lwt->data;
 65 }
 66 
 67 static struct ipv6_sr_hdr *get_srh(struct sk_buff *skb)
 68 {
 69         struct ipv6_sr_hdr *srh;
 70         int len, srhoff = 0;
 71 
 72         if (ipv6_find_hdr(skb, &srhoff, IPPROTO_ROUTING, NULL, NULL) < 0)
 73                 return NULL;
 74 
 75         if (!pskb_may_pull(skb, srhoff + sizeof(*srh)))
 76                 return NULL;
 77 
 78         srh = (struct ipv6_sr_hdr *)(skb->data + srhoff);
 79 
 80         len = (srh->hdrlen + 1) << 3;
 81 
 82         if (!pskb_may_pull(skb, srhoff + len))
 83                 return NULL;
 84 
 85         /* note that pskb_may_pull may change pointers in header;
 86          * for this reason it is necessary to reload them when needed.
 87          */
 88         srh = (struct ipv6_sr_hdr *)(skb->data + srhoff);
 89 
 90         if (!seg6_validate_srh(srh, len, true))
 91                 return NULL;
 92 
 93         return srh;
 94 }
 95 
 96 static struct ipv6_sr_hdr *get_and_validate_srh(struct sk_buff *skb)
 97 {
 98         struct ipv6_sr_hdr *srh;
 99 
100         srh = get_srh(skb);
101         if (!srh)
102                 return NULL;
103 
104         if (srh->segments_left == 0)
105                 return NULL;
106 
107 #ifdef CONFIG_IPV6_SEG6_HMAC
108         if (!seg6_hmac_validate_skb(skb))
109                 return NULL;
110 #endif
111 
112         return srh;
113 }
114 
115 static bool decap_and_validate(struct sk_buff *skb, int proto)
116 {
117         struct ipv6_sr_hdr *srh;
118         unsigned int off = 0;
119 
120         srh = get_srh(skb);
121         if (srh && srh->segments_left > 0)
122                 return false;
123 
124 #ifdef CONFIG_IPV6_SEG6_HMAC
125         if (srh && !seg6_hmac_validate_skb(skb))
126                 return false;
127 #endif
128 
129         if (ipv6_find_hdr(skb, &off, proto, NULL, NULL) < 0)
130                 return false;
131 
132         if (!pskb_pull(skb, off))
133                 return false;
134 
135         skb_postpull_rcsum(skb, skb_network_header(skb), off);
136 
137         skb_reset_network_header(skb);
138         skb_reset_transport_header(skb);
139         if (iptunnel_pull_offloads(skb))
140                 return false;
141 
142         return true;
143 }
144 
145 static void advance_nextseg(struct ipv6_sr_hdr *srh, struct in6_addr *daddr)
146 {
147         struct in6_addr *addr;
148 
149         srh->segments_left--;
150         addr = srh->segments + srh->segments_left;
151         *daddr = *addr;
152 }
153 
154 static int
155 seg6_lookup_any_nexthop(struct sk_buff *skb, struct in6_addr *nhaddr,
156                         u32 tbl_id, bool local_delivery)
157 {
158         struct net *net = dev_net(skb->dev);
159         struct ipv6hdr *hdr = ipv6_hdr(skb);
160         int flags = RT6_LOOKUP_F_HAS_SADDR;
161         struct dst_entry *dst = NULL;
162         struct rt6_info *rt;
163         struct flowi6 fl6;
164         int dev_flags = 0;
165 
166         fl6.flowi6_iif = skb->dev->ifindex;
167         fl6.daddr = nhaddr ? *nhaddr : hdr->daddr;
168         fl6.saddr = hdr->saddr;
169         fl6.flowlabel = ip6_flowinfo(hdr);
170         fl6.flowi6_mark = skb->mark;
171         fl6.flowi6_proto = hdr->nexthdr;
172 
173         if (nhaddr)
174                 fl6.flowi6_flags = FLOWI_FLAG_KNOWN_NH;
175 
176         if (!tbl_id) {
177                 dst = ip6_route_input_lookup(net, skb->dev, &fl6, skb, flags);
178         } else {
179                 struct fib6_table *table;
180 
181                 table = fib6_get_table(net, tbl_id);
182                 if (!table)
183                         goto out;
184 
185                 rt = ip6_pol_route(net, table, 0, &fl6, skb, flags);
186                 dst = &rt->dst;
187         }
188 
189         /* we want to discard traffic destined for local packet processing,
190          * if @local_delivery is set to false.
191          */
192         if (!local_delivery)
193                 dev_flags |= IFF_LOOPBACK;
194 
195         if (dst && (dst->dev->flags & dev_flags) && !dst->error) {
196                 dst_release(dst);
197                 dst = NULL;
198         }
199 
200 out:
201         if (!dst) {
202                 rt = net->ipv6.ip6_blk_hole_entry;
203                 dst = &rt->dst;
204                 dst_hold(dst);
205         }
206 
207         skb_dst_drop(skb);
208         skb_dst_set(skb, dst);
209         return dst->error;
210 }
211 
212 int seg6_lookup_nexthop(struct sk_buff *skb,
213                         struct in6_addr *nhaddr, u32 tbl_id)
214 {
215         return seg6_lookup_any_nexthop(skb, nhaddr, tbl_id, false);
216 }
217 
218 /* regular endpoint function */
219 static int input_action_end(struct sk_buff *skb, struct seg6_local_lwt *slwt)
220 {
221         struct ipv6_sr_hdr *srh;
222 
223         srh = get_and_validate_srh(skb);
224         if (!srh)
225                 goto drop;
226 
227         advance_nextseg(srh, &ipv6_hdr(skb)->daddr);
228 
229         seg6_lookup_nexthop(skb, NULL, 0);
230 
231         return dst_input(skb);
232 
233 drop:
234         kfree_skb(skb);
235         return -EINVAL;
236 }
237 
238 /* regular endpoint, and forward to specified nexthop */
239 static int input_action_end_x(struct sk_buff *skb, struct seg6_local_lwt *slwt)
240 {
241         struct ipv6_sr_hdr *srh;
242 
243         srh = get_and_validate_srh(skb);
244         if (!srh)
245                 goto drop;
246 
247         advance_nextseg(srh, &ipv6_hdr(skb)->daddr);
248 
249         seg6_lookup_nexthop(skb, &slwt->nh6, 0);
250 
251         return dst_input(skb);
252 
253 drop:
254         kfree_skb(skb);
255         return -EINVAL;
256 }
257 
258 static int input_action_end_t(struct sk_buff *skb, struct seg6_local_lwt *slwt)
259 {
260         struct ipv6_sr_hdr *srh;
261 
262         srh = get_and_validate_srh(skb);
263         if (!srh)
264                 goto drop;
265 
266         advance_nextseg(srh, &ipv6_hdr(skb)->daddr);
267 
268         seg6_lookup_nexthop(skb, NULL, slwt->table);
269 
270         return dst_input(skb);
271 
272 drop:
273         kfree_skb(skb);
274         return -EINVAL;
275 }
276 
277 /* decapsulate and forward inner L2 frame on specified interface */
278 static int input_action_end_dx2(struct sk_buff *skb,
279                                 struct seg6_local_lwt *slwt)
280 {
281         struct net *net = dev_net(skb->dev);
282         struct net_device *odev;
283         struct ethhdr *eth;
284 
285         if (!decap_and_validate(skb, IPPROTO_ETHERNET))
286                 goto drop;
287 
288         if (!pskb_may_pull(skb, ETH_HLEN))
289                 goto drop;
290 
291         skb_reset_mac_header(skb);
292         eth = (struct ethhdr *)skb->data;
293 
294         /* To determine the frame's protocol, we assume it is 802.3. This avoids
295          * a call to eth_type_trans(), which is not really relevant for our
296          * use case.
297          */
298         if (!eth_proto_is_802_3(eth->h_proto))
299                 goto drop;
300 
301         odev = dev_get_by_index_rcu(net, slwt->oif);
302         if (!odev)
303                 goto drop;
304 
305         /* As we accept Ethernet frames, make sure the egress device is of
306          * the correct type.
307          */
308         if (odev->type != ARPHRD_ETHER)
309                 goto drop;
310 
311         if (!(odev->flags & IFF_UP) || !netif_carrier_ok(odev))
312                 goto drop;
313 
314         skb_orphan(skb);
315 
316         if (skb_warn_if_lro(skb))
317                 goto drop;
318 
319         skb_forward_csum(skb);
320 
321         if (skb->len - ETH_HLEN > odev->mtu)
322                 goto drop;
323 
324         skb->dev = odev;
325         skb->protocol = eth->h_proto;
326 
327         return dev_queue_xmit(skb);
328 
329 drop:
330         kfree_skb(skb);
331         return -EINVAL;
332 }
333 
334 /* decapsulate and forward to specified nexthop */
335 static int input_action_end_dx6(struct sk_buff *skb,
336                                 struct seg6_local_lwt *slwt)
337 {
338         struct in6_addr *nhaddr = NULL;
339 
340         /* this function accepts IPv6 encapsulated packets, with either
341          * an SRH with SL=0, or no SRH.
342          */
343 
344         if (!decap_and_validate(skb, IPPROTO_IPV6))
345                 goto drop;
346 
347         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
348                 goto drop;
349 
350         /* The inner packet is not associated to any local interface,
351          * so we do not call netif_rx().
352          *
353          * If slwt->nh6 is set to ::, then lookup the nexthop for the
354          * inner packet's DA. Otherwise, use the specified nexthop.
355          */
356 
357         if (!ipv6_addr_any(&slwt->nh6))
358                 nhaddr = &slwt->nh6;
359 
360         skb_set_transport_header(skb, sizeof(struct ipv6hdr));
361 
362         seg6_lookup_nexthop(skb, nhaddr, 0);
363 
364         return dst_input(skb);
365 drop:
366         kfree_skb(skb);
367         return -EINVAL;
368 }
369 
370 static int input_action_end_dx4(struct sk_buff *skb,
371                                 struct seg6_local_lwt *slwt)
372 {
373         struct iphdr *iph;
374         __be32 nhaddr;
375         int err;
376 
377         if (!decap_and_validate(skb, IPPROTO_IPIP))
378                 goto drop;
379 
380         if (!pskb_may_pull(skb, sizeof(struct iphdr)))
381                 goto drop;
382 
383         skb->protocol = htons(ETH_P_IP);
384 
385         iph = ip_hdr(skb);
386 
387         nhaddr = slwt->nh4.s_addr ?: iph->daddr;
388 
389         skb_dst_drop(skb);
390 
391         skb_set_transport_header(skb, sizeof(struct iphdr));
392 
393         err = ip_route_input(skb, nhaddr, iph->saddr, 0, skb->dev);
394         if (err)
395                 goto drop;
396 
397         return dst_input(skb);
398 
399 drop:
400         kfree_skb(skb);
401         return -EINVAL;
402 }
403 
404 static int input_action_end_dt6(struct sk_buff *skb,
405                                 struct seg6_local_lwt *slwt)
406 {
407         if (!decap_and_validate(skb, IPPROTO_IPV6))
408                 goto drop;
409 
410         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
411                 goto drop;
412 
413         skb_set_transport_header(skb, sizeof(struct ipv6hdr));
414 
415         seg6_lookup_any_nexthop(skb, NULL, slwt->table, true);
416 
417         return dst_input(skb);
418 
419 drop:
420         kfree_skb(skb);
421         return -EINVAL;
422 }
423 
424 /* push an SRH on top of the current one */
425 static int input_action_end_b6(struct sk_buff *skb, struct seg6_local_lwt *slwt)
426 {
427         struct ipv6_sr_hdr *srh;
428         int err = -EINVAL;
429 
430         srh = get_and_validate_srh(skb);
431         if (!srh)
432                 goto drop;
433 
434         err = seg6_do_srh_inline(skb, slwt->srh);
435         if (err)
436                 goto drop;
437 
438         ipv6_hdr(skb)->payload_len = htons(skb->len - sizeof(struct ipv6hdr));
439         skb_set_transport_header(skb, sizeof(struct ipv6hdr));
440 
441         seg6_lookup_nexthop(skb, NULL, 0);
442 
443         return dst_input(skb);
444 
445 drop:
446         kfree_skb(skb);
447         return err;
448 }
449 
450 /* encapsulate within an outer IPv6 header and a specified SRH */
451 static int input_action_end_b6_encap(struct sk_buff *skb,
452                                      struct seg6_local_lwt *slwt)
453 {
454         struct ipv6_sr_hdr *srh;
455         int err = -EINVAL;
456 
457         srh = get_and_validate_srh(skb);
458         if (!srh)
459                 goto drop;
460 
461         advance_nextseg(srh, &ipv6_hdr(skb)->daddr);
462 
463         skb_reset_inner_headers(skb);
464         skb->encapsulation = 1;
465 
466         err = seg6_do_srh_encap(skb, slwt->srh, IPPROTO_IPV6);
467         if (err)
468                 goto drop;
469 
470         ipv6_hdr(skb)->payload_len = htons(skb->len - sizeof(struct ipv6hdr));
471         skb_set_transport_header(skb, sizeof(struct ipv6hdr));
472 
473         seg6_lookup_nexthop(skb, NULL, 0);
474 
475         return dst_input(skb);
476 
477 drop:
478         kfree_skb(skb);
479         return err;
480 }
481 
482 DEFINE_PER_CPU(struct seg6_bpf_srh_state, seg6_bpf_srh_states);
483 
484 bool seg6_bpf_has_valid_srh(struct sk_buff *skb)
485 {
486         struct seg6_bpf_srh_state *srh_state =
487                 this_cpu_ptr(&seg6_bpf_srh_states);
488         struct ipv6_sr_hdr *srh = srh_state->srh;
489 
490         if (unlikely(srh == NULL))
491                 return false;
492 
493         if (unlikely(!srh_state->valid)) {
494                 if ((srh_state->hdrlen & 7) != 0)
495                         return false;
496 
497                 srh->hdrlen = (u8)(srh_state->hdrlen >> 3);
498                 if (!seg6_validate_srh(srh, (srh->hdrlen + 1) << 3, true))
499                         return false;
500 
501                 srh_state->valid = true;
502         }
503 
504         return true;
505 }
506 
507 static int input_action_end_bpf(struct sk_buff *skb,
508                                 struct seg6_local_lwt *slwt)
509 {
510         struct seg6_bpf_srh_state *srh_state =
511                 this_cpu_ptr(&seg6_bpf_srh_states);
512         struct ipv6_sr_hdr *srh;
513         int ret;
514 
515         srh = get_and_validate_srh(skb);
516         if (!srh) {
517                 kfree_skb(skb);
518                 return -EINVAL;
519         }
520         advance_nextseg(srh, &ipv6_hdr(skb)->daddr);
521 
522         /* preempt_disable is needed to protect the per-CPU buffer srh_state,
523          * which is also accessed by the bpf_lwt_seg6_* helpers
524          */
525         preempt_disable();
526         srh_state->srh = srh;
527         srh_state->hdrlen = srh->hdrlen << 3;
528         srh_state->valid = true;
529 
530         rcu_read_lock();
531         bpf_compute_data_pointers(skb);
532         ret = bpf_prog_run_save_cb(slwt->bpf.prog, skb);
533         rcu_read_unlock();
534 
535         switch (ret) {
536         case BPF_OK:
537         case BPF_REDIRECT:
538                 break;
539         case BPF_DROP:
540                 goto drop;
541         default:
542                 pr_warn_once("bpf-seg6local: Illegal return value %u\n", ret);
543                 goto drop;
544         }
545 
546         if (srh_state->srh && !seg6_bpf_has_valid_srh(skb))
547                 goto drop;
548 
549         preempt_enable();
550         if (ret != BPF_REDIRECT)
551                 seg6_lookup_nexthop(skb, NULL, 0);
552 
553         return dst_input(skb);
554 
555 drop:
556         preempt_enable();
557         kfree_skb(skb);
558         return -EINVAL;
559 }
560 
561 static struct seg6_action_desc seg6_action_table[] = {
562         {
563                 .action         = SEG6_LOCAL_ACTION_END,
564                 .attrs          = 0,
565                 .input          = input_action_end,
566         },
567         {
568                 .action         = SEG6_LOCAL_ACTION_END_X,
569                 .attrs          = (1 << SEG6_LOCAL_NH6),
570                 .input          = input_action_end_x,
571         },
572         {
573                 .action         = SEG6_LOCAL_ACTION_END_T,
574                 .attrs          = (1 << SEG6_LOCAL_TABLE),
575                 .input          = input_action_end_t,
576         },
577         {
578                 .action         = SEG6_LOCAL_ACTION_END_DX2,
579                 .attrs          = (1 << SEG6_LOCAL_OIF),
580                 .input          = input_action_end_dx2,
581         },
582         {
583                 .action         = SEG6_LOCAL_ACTION_END_DX6,
584                 .attrs          = (1 << SEG6_LOCAL_NH6),
585                 .input          = input_action_end_dx6,
586         },
587         {
588                 .action         = SEG6_LOCAL_ACTION_END_DX4,
589                 .attrs          = (1 << SEG6_LOCAL_NH4),
590                 .input          = input_action_end_dx4,
591         },
592         {
593                 .action         = SEG6_LOCAL_ACTION_END_DT6,
594                 .attrs          = (1 << SEG6_LOCAL_TABLE),
595                 .input          = input_action_end_dt6,
596         },
597         {
598                 .action         = SEG6_LOCAL_ACTION_END_B6,
599                 .attrs          = (1 << SEG6_LOCAL_SRH),
600                 .input          = input_action_end_b6,
601         },
602         {
603                 .action         = SEG6_LOCAL_ACTION_END_B6_ENCAP,
604                 .attrs          = (1 << SEG6_LOCAL_SRH),
605                 .input          = input_action_end_b6_encap,
606                 .static_headroom        = sizeof(struct ipv6hdr),
607         },
608         {
609                 .action         = SEG6_LOCAL_ACTION_END_BPF,
610                 .attrs          = (1 << SEG6_LOCAL_BPF),
611                 .input          = input_action_end_bpf,
612         },
613 
614 };
615 
616 static struct seg6_action_desc *__get_action_desc(int action)
617 {
618         struct seg6_action_desc *desc;
619         int i, count;
620 
621         count = ARRAY_SIZE(seg6_action_table);
622         for (i = 0; i < count; i++) {
623                 desc = &seg6_action_table[i];
624                 if (desc->action == action)
625                         return desc;
626         }
627 
628         return NULL;
629 }
630 
631 static int seg6_local_input(struct sk_buff *skb)
632 {
633         struct dst_entry *orig_dst = skb_dst(skb);
634         struct seg6_action_desc *desc;
635         struct seg6_local_lwt *slwt;
636 
637         if (skb->protocol != htons(ETH_P_IPV6)) {
638                 kfree_skb(skb);
639                 return -EINVAL;
640         }
641 
642         slwt = seg6_local_lwtunnel(orig_dst->lwtstate);
643         desc = slwt->desc;
644 
645         return desc->input(skb, slwt);
646 }
647 
648 static const struct nla_policy seg6_local_policy[SEG6_LOCAL_MAX + 1] = {
649         [SEG6_LOCAL_ACTION]     = { .type = NLA_U32 },
650         [SEG6_LOCAL_SRH]        = { .type = NLA_BINARY },
651         [SEG6_LOCAL_TABLE]      = { .type = NLA_U32 },
652         [SEG6_LOCAL_NH4]        = { .type = NLA_BINARY,
653                                     .len = sizeof(struct in_addr) },
654         [SEG6_LOCAL_NH6]        = { .type = NLA_BINARY,
655                                     .len = sizeof(struct in6_addr) },
656         [SEG6_LOCAL_IIF]        = { .type = NLA_U32 },
657         [SEG6_LOCAL_OIF]        = { .type = NLA_U32 },
658         [SEG6_LOCAL_BPF]        = { .type = NLA_NESTED },
659 };
660 
661 static int parse_nla_srh(struct nlattr **attrs, struct seg6_local_lwt *slwt)
662 {
663         struct ipv6_sr_hdr *srh;
664         int len;
665 
666         srh = nla_data(attrs[SEG6_LOCAL_SRH]);
667         len = nla_len(attrs[SEG6_LOCAL_SRH]);
668 
669         /* SRH must contain at least one segment */
670         if (len < sizeof(*srh) + sizeof(struct in6_addr))
671                 return -EINVAL;
672 
673         if (!seg6_validate_srh(srh, len, false))
674                 return -EINVAL;
675 
676         slwt->srh = kmemdup(srh, len, GFP_KERNEL);
677         if (!slwt->srh)
678                 return -ENOMEM;
679 
680         slwt->headroom += len;
681 
682         return 0;
683 }
684 
685 static int put_nla_srh(struct sk_buff *skb, struct seg6_local_lwt *slwt)
686 {
687         struct ipv6_sr_hdr *srh;
688         struct nlattr *nla;
689         int len;
690 
691         srh = slwt->srh;
692         len = (srh->hdrlen + 1) << 3;
693 
694         nla = nla_reserve(skb, SEG6_LOCAL_SRH, len);
695         if (!nla)
696                 return -EMSGSIZE;
697 
698         memcpy(nla_data(nla), srh, len);
699 
700         return 0;
701 }
702 
703 static int cmp_nla_srh(struct seg6_local_lwt *a, struct seg6_local_lwt *b)
704 {
705         int len = (a->srh->hdrlen + 1) << 3;
706 
707         if (len != ((b->srh->hdrlen + 1) << 3))
708                 return 1;
709 
710         return memcmp(a->srh, b->srh, len);
711 }
712 
713 static int parse_nla_table(struct nlattr **attrs, struct seg6_local_lwt *slwt)
714 {
715         slwt->table = nla_get_u32(attrs[SEG6_LOCAL_TABLE]);
716 
717         return 0;
718 }
719 
720 static int put_nla_table(struct sk_buff *skb, struct seg6_local_lwt *slwt)
721 {
722         if (nla_put_u32(skb, SEG6_LOCAL_TABLE, slwt->table))
723                 return -EMSGSIZE;
724 
725         return 0;
726 }
727 
728 static int cmp_nla_table(struct seg6_local_lwt *a, struct seg6_local_lwt *b)
729 {
730         if (a->table != b->table)
731                 return 1;
732 
733         return 0;
734 }
735 
736 static int parse_nla_nh4(struct nlattr **attrs, struct seg6_local_lwt *slwt)
737 {
738         memcpy(&slwt->nh4, nla_data(attrs[SEG6_LOCAL_NH4]),
739                sizeof(struct in_addr));
740 
741         return 0;
742 }
743 
744 static int put_nla_nh4(struct sk_buff *skb, struct seg6_local_lwt *slwt)
745 {
746         struct nlattr *nla;
747 
748         nla = nla_reserve(skb, SEG6_LOCAL_NH4, sizeof(struct in_addr));
749         if (!nla)
750                 return -EMSGSIZE;
751 
752         memcpy(nla_data(nla), &slwt->nh4, sizeof(struct in_addr));
753 
754         return 0;
755 }
756 
757 static int cmp_nla_nh4(struct seg6_local_lwt *a, struct seg6_local_lwt *b)
758 {
759         return memcmp(&a->nh4, &b->nh4, sizeof(struct in_addr));
760 }
761 
762 static int parse_nla_nh6(struct nlattr **attrs, struct seg6_local_lwt *slwt)
763 {
764         memcpy(&slwt->nh6, nla_data(attrs[SEG6_LOCAL_NH6]),
765                sizeof(struct in6_addr));
766 
767         return 0;
768 }
769 
770 static int put_nla_nh6(struct sk_buff *skb, struct seg6_local_lwt *slwt)
771 {
772         struct nlattr *nla;
773 
774         nla = nla_reserve(skb, SEG6_LOCAL_NH6, sizeof(struct in6_addr));
775         if (!nla)
776                 return -EMSGSIZE;
777 
778         memcpy(nla_data(nla), &slwt->nh6, sizeof(struct in6_addr));
779 
780         return 0;
781 }
782 
783 static int cmp_nla_nh6(struct seg6_local_lwt *a, struct seg6_local_lwt *b)
784 {
785         return memcmp(&a->nh6, &b->nh6, sizeof(struct in6_addr));
786 }
787 
788 static int parse_nla_iif(struct nlattr **attrs, struct seg6_local_lwt *slwt)
789 {
790         slwt->iif = nla_get_u32(attrs[SEG6_LOCAL_IIF]);
791 
792         return 0;
793 }
794 
795 static int put_nla_iif(struct sk_buff *skb, struct seg6_local_lwt *slwt)
796 {
797         if (nla_put_u32(skb, SEG6_LOCAL_IIF, slwt->iif))
798                 return -EMSGSIZE;
799 
800         return 0;
801 }
802 
803 static int cmp_nla_iif(struct seg6_local_lwt *a, struct seg6_local_lwt *b)
804 {
805         if (a->iif != b->iif)
806                 return 1;
807 
808         return 0;
809 }
810 
811 static int parse_nla_oif(struct nlattr **attrs, struct seg6_local_lwt *slwt)
812 {
813         slwt->oif = nla_get_u32(attrs[SEG6_LOCAL_OIF]);
814 
815         return 0;
816 }
817 
818 static int put_nla_oif(struct sk_buff *skb, struct seg6_local_lwt *slwt)
819 {
820         if (nla_put_u32(skb, SEG6_LOCAL_OIF, slwt->oif))
821                 return -EMSGSIZE;
822 
823         return 0;
824 }
825 
826 static int cmp_nla_oif(struct seg6_local_lwt *a, struct seg6_local_lwt *b)
827 {
828         if (a->oif != b->oif)
829                 return 1;
830 
831         return 0;
832 }
833 
834 #define MAX_PROG_NAME 256
835 static const struct nla_policy bpf_prog_policy[SEG6_LOCAL_BPF_PROG_MAX + 1] = {
836         [SEG6_LOCAL_BPF_PROG]      = { .type = NLA_U32, },
837         [SEG6_LOCAL_BPF_PROG_NAME] = { .type = NLA_NUL_STRING,
838                                        .len = MAX_PROG_NAME },
839 };
840 
841 static int parse_nla_bpf(struct nlattr **attrs, struct seg6_local_lwt *slwt)
842 {
843         struct nlattr *tb[SEG6_LOCAL_BPF_PROG_MAX + 1];
844         struct bpf_prog *p;
845         int ret;
846         u32 fd;
847 
848         ret = nla_parse_nested_deprecated(tb, SEG6_LOCAL_BPF_PROG_MAX,
849                                           attrs[SEG6_LOCAL_BPF],
850                                           bpf_prog_policy, NULL);
851         if (ret < 0)
852                 return ret;
853 
854         if (!tb[SEG6_LOCAL_BPF_PROG] || !tb[SEG6_LOCAL_BPF_PROG_NAME])
855                 return -EINVAL;
856 
857         slwt->bpf.name = nla_memdup(tb[SEG6_LOCAL_BPF_PROG_NAME], GFP_KERNEL);
858         if (!slwt->bpf.name)
859                 return -ENOMEM;
860 
861         fd = nla_get_u32(tb[SEG6_LOCAL_BPF_PROG]);
862         p = bpf_prog_get_type(fd, BPF_PROG_TYPE_LWT_SEG6LOCAL);
863         if (IS_ERR(p)) {
864                 kfree(slwt->bpf.name);
865                 return PTR_ERR(p);
866         }
867 
868         slwt->bpf.prog = p;
869         return 0;
870 }
871 
872 static int put_nla_bpf(struct sk_buff *skb, struct seg6_local_lwt *slwt)
873 {
874         struct nlattr *nest;
875 
876         if (!slwt->bpf.prog)
877                 return 0;
878 
879         nest = nla_nest_start_noflag(skb, SEG6_LOCAL_BPF);
880         if (!nest)
881                 return -EMSGSIZE;
882 
883         if (nla_put_u32(skb, SEG6_LOCAL_BPF_PROG, slwt->bpf.prog->aux->id))
884                 return -EMSGSIZE;
885 
886         if (slwt->bpf.name &&
887             nla_put_string(skb, SEG6_LOCAL_BPF_PROG_NAME, slwt->bpf.name))
888                 return -EMSGSIZE;
889 
890         return nla_nest_end(skb, nest);
891 }
892 
893 static int cmp_nla_bpf(struct seg6_local_lwt *a, struct seg6_local_lwt *b)
894 {
895         if (!a->bpf.name && !b->bpf.name)
896                 return 0;
897 
898         if (!a->bpf.name || !b->bpf.name)
899                 return 1;
900 
901         return strcmp(a->bpf.name, b->bpf.name);
902 }
903 
904 struct seg6_action_param {
905         int (*parse)(struct nlattr **attrs, struct seg6_local_lwt *slwt);
906         int (*put)(struct sk_buff *skb, struct seg6_local_lwt *slwt);
907         int (*cmp)(struct seg6_local_lwt *a, struct seg6_local_lwt *b);
908 };
909 
910 static struct seg6_action_param seg6_action_params[SEG6_LOCAL_MAX + 1] = {
911         [SEG6_LOCAL_SRH]        = { .parse = parse_nla_srh,
912                                     .put = put_nla_srh,
913                                     .cmp = cmp_nla_srh },
914 
915         [SEG6_LOCAL_TABLE]      = { .parse = parse_nla_table,
916                                     .put = put_nla_table,
917                                     .cmp = cmp_nla_table },
918 
919         [SEG6_LOCAL_NH4]        = { .parse = parse_nla_nh4,
920                                     .put = put_nla_nh4,
921                                     .cmp = cmp_nla_nh4 },
922 
923         [SEG6_LOCAL_NH6]        = { .parse = parse_nla_nh6,
924                                     .put = put_nla_nh6,
925                                     .cmp = cmp_nla_nh6 },
926 
927         [SEG6_LOCAL_IIF]        = { .parse = parse_nla_iif,
928                                     .put = put_nla_iif,
929                                     .cmp = cmp_nla_iif },
930 
931         [SEG6_LOCAL_OIF]        = { .parse = parse_nla_oif,
932                                     .put = put_nla_oif,
933                                     .cmp = cmp_nla_oif },
934 
935         [SEG6_LOCAL_BPF]        = { .parse = parse_nla_bpf,
936                                     .put = put_nla_bpf,
937                                     .cmp = cmp_nla_bpf },
938 
939 };
940 
941 static int parse_nla_action(struct nlattr **attrs, struct seg6_local_lwt *slwt)
942 {
943         struct seg6_action_param *param;
944         struct seg6_action_desc *desc;
945         int i, err;
946 
947         desc = __get_action_desc(slwt->action);
948         if (!desc)
949                 return -EINVAL;
950 
951         if (!desc->input)
952                 return -EOPNOTSUPP;
953 
954         slwt->desc = desc;
955         slwt->headroom += desc->static_headroom;
956 
957         for (i = 0; i < SEG6_LOCAL_MAX + 1; i++) {
958                 if (desc->attrs & (1 << i)) {
959                         if (!attrs[i])
960                                 return -EINVAL;
961 
962                         param = &seg6_action_params[i];
963 
964                         err = param->parse(attrs, slwt);
965                         if (err < 0)
966                                 return err;
967                 }
968         }
969 
970         return 0;
971 }
972 
973 static int seg6_local_build_state(struct net *net, struct nlattr *nla,
974                                   unsigned int family, const void *cfg,
975                                   struct lwtunnel_state **ts,
976                                   struct netlink_ext_ack *extack)
977 {
978         struct nlattr *tb[SEG6_LOCAL_MAX + 1];
979         struct lwtunnel_state *newts;
980         struct seg6_local_lwt *slwt;
981         int err;
982 
983         if (family != AF_INET6)
984                 return -EINVAL;
985 
986         err = nla_parse_nested_deprecated(tb, SEG6_LOCAL_MAX, nla,
987                                           seg6_local_policy, extack);
988 
989         if (err < 0)
990                 return err;
991 
992         if (!tb[SEG6_LOCAL_ACTION])
993                 return -EINVAL;
994 
995         newts = lwtunnel_state_alloc(sizeof(*slwt));
996         if (!newts)
997                 return -ENOMEM;
998 
999         slwt = seg6_local_lwtunnel(newts);
1000         slwt->action = nla_get_u32(tb[SEG6_LOCAL_ACTION]);
1001 
1002         err = parse_nla_action(tb, slwt);
1003         if (err < 0)
1004                 goto out_free;
1005 
1006         newts->type = LWTUNNEL_ENCAP_SEG6_LOCAL;
1007         newts->flags = LWTUNNEL_STATE_INPUT_REDIRECT;
1008         newts->headroom = slwt->headroom;
1009 
1010         *ts = newts;
1011 
1012         return 0;
1013 
1014 out_free:
1015         kfree(slwt->srh);
1016         kfree(newts);
1017         return err;
1018 }
1019 
1020 static void seg6_local_destroy_state(struct lwtunnel_state *lwt)
1021 {
1022         struct seg6_local_lwt *slwt = seg6_local_lwtunnel(lwt);
1023 
1024         kfree(slwt->srh);
1025 
1026         if (slwt->desc->attrs & (1 << SEG6_LOCAL_BPF)) {
1027                 kfree(slwt->bpf.name);
1028                 bpf_prog_put(slwt->bpf.prog);
1029         }
1030 
1031         return;
1032 }
1033 
1034 static int seg6_local_fill_encap(struct sk_buff *skb,
1035                                  struct lwtunnel_state *lwt)
1036 {
1037         struct seg6_local_lwt *slwt = seg6_local_lwtunnel(lwt);
1038         struct seg6_action_param *param;
1039         int i, err;
1040 
1041         if (nla_put_u32(skb, SEG6_LOCAL_ACTION, slwt->action))
1042                 return -EMSGSIZE;
1043 
1044         for (i = 0; i < SEG6_LOCAL_MAX + 1; i++) {
1045                 if (slwt->desc->attrs & (1 << i)) {
1046                         param = &seg6_action_params[i];
1047                         err = param->put(skb, slwt);
1048                         if (err < 0)
1049                                 return err;
1050                 }
1051         }
1052 
1053         return 0;
1054 }
1055 
1056 static int seg6_local_get_encap_size(struct lwtunnel_state *lwt)
1057 {
1058         struct seg6_local_lwt *slwt = seg6_local_lwtunnel(lwt);
1059         unsigned long attrs;
1060         int nlsize;
1061 
1062         nlsize = nla_total_size(4); /* action */
1063 
1064         attrs = slwt->desc->attrs;
1065 
1066         if (attrs & (1 << SEG6_LOCAL_SRH))
1067                 nlsize += nla_total_size((slwt->srh->hdrlen + 1) << 3);
1068 
1069         if (attrs & (1 << SEG6_LOCAL_TABLE))
1070                 nlsize += nla_total_size(4);
1071 
1072         if (attrs & (1 << SEG6_LOCAL_NH4))
1073                 nlsize += nla_total_size(4);
1074 
1075         if (attrs & (1 << SEG6_LOCAL_NH6))
1076                 nlsize += nla_total_size(16);
1077 
1078         if (attrs & (1 << SEG6_LOCAL_IIF))
1079                 nlsize += nla_total_size(4);
1080 
1081         if (attrs & (1 << SEG6_LOCAL_OIF))
1082                 nlsize += nla_total_size(4);
1083 
1084         if (attrs & (1 << SEG6_LOCAL_BPF))
1085                 nlsize += nla_total_size(sizeof(struct nlattr)) +
1086                        nla_total_size(MAX_PROG_NAME) +
1087                        nla_total_size(4);
1088 
1089         return nlsize;
1090 }
1091 
1092 static int seg6_local_cmp_encap(struct lwtunnel_state *a,
1093                                 struct lwtunnel_state *b)
1094 {
1095         struct seg6_local_lwt *slwt_a, *slwt_b;
1096         struct seg6_action_param *param;
1097         int i;
1098 
1099         slwt_a = seg6_local_lwtunnel(a);
1100         slwt_b = seg6_local_lwtunnel(b);
1101 
1102         if (slwt_a->action != slwt_b->action)
1103                 return 1;
1104 
1105         if (slwt_a->desc->attrs != slwt_b->desc->attrs)
1106                 return 1;
1107 
1108         for (i = 0; i < SEG6_LOCAL_MAX + 1; i++) {
1109                 if (slwt_a->desc->attrs & (1 << i)) {
1110                         param = &seg6_action_params[i];
1111                         if (param->cmp(slwt_a, slwt_b))
1112                                 return 1;
1113                 }
1114         }
1115 
1116         return 0;
1117 }
1118 
1119 static const struct lwtunnel_encap_ops seg6_local_ops = {
1120         .build_state    = seg6_local_build_state,
1121         .destroy_state  = seg6_local_destroy_state,
1122         .input          = seg6_local_input,
1123         .fill_encap     = seg6_local_fill_encap,
1124         .get_encap_size = seg6_local_get_encap_size,
1125         .cmp_encap      = seg6_local_cmp_encap,
1126         .owner          = THIS_MODULE,
1127 };
1128 
1129 int __init seg6_local_init(void)
1130 {
1131         return lwtunnel_encap_add_ops(&seg6_local_ops,
1132                                       LWTUNNEL_ENCAP_SEG6_LOCAL);
1133 }
1134 
1135 void seg6_local_exit(void)
1136 {
1137         lwtunnel_encap_del_ops(&seg6_local_ops, LWTUNNEL_ENCAP_SEG6_LOCAL);
1138 }
1139 

~ [ 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