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)) 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)) 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)) 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