1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* GTP according to GSM TS 09.60 / 3GPP TS 29.060 3 * 4 * (C) 2012-2014 by sysmocom - s.f.m.c. GmbH 5 * (C) 2016 by Pablo Neira Ayuso <pablo@netfilter.org> 6 * 7 * Author: Harald Welte <hwelte@sysmocom.de> 8 * Pablo Neira Ayuso <pablo@netfilter.org> 9 * Andreas Schultz <aschultz@travelping.com> 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/module.h> 15 #include <linux/skbuff.h> 16 #include <linux/udp.h> 17 #include <linux/rculist.h> 18 #include <linux/jhash.h> 19 #include <linux/if_tunnel.h> 20 #include <linux/net.h> 21 #include <linux/file.h> 22 #include <linux/gtp.h> 23 24 #include <net/net_namespace.h> 25 #include <net/protocol.h> 26 #include <net/ip.h> 27 #include <net/udp.h> 28 #include <net/udp_tunnel.h> 29 #include <net/icmp.h> 30 #include <net/xfrm.h> 31 #include <net/genetlink.h> 32 #include <net/netns/generic.h> 33 #include <net/gtp.h> 34 35 /* An active session for the subscriber. */ 36 struct pdp_ctx { 37 struct hlist_node hlist_tid; 38 struct hlist_node hlist_addr; 39 40 union { 41 struct { 42 u64 tid; 43 u16 flow; 44 } v0; 45 struct { 46 u32 i_tei; 47 u32 o_tei; 48 } v1; 49 } u; 50 u8 gtp_version; 51 u16 af; 52 53 struct in_addr ms_addr_ip4; 54 struct in_addr peer_addr_ip4; 55 56 struct sock *sk; 57 struct net_device *dev; 58 59 atomic_t tx_seq; 60 struct rcu_head rcu_head; 61 }; 62 63 /* One instance of the GTP device. */ 64 struct gtp_dev { 65 struct list_head list; 66 67 struct sock *sk0; 68 struct sock *sk1u; 69 70 struct net_device *dev; 71 72 unsigned int role; 73 unsigned int hash_size; 74 struct hlist_head *tid_hash; 75 struct hlist_head *addr_hash; 76 }; 77 78 static unsigned int gtp_net_id __read_mostly; 79 80 struct gtp_net { 81 struct list_head gtp_dev_list; 82 }; 83 84 static u32 gtp_h_initval; 85 86 static void pdp_context_delete(struct pdp_ctx *pctx); 87 88 static inline u32 gtp0_hashfn(u64 tid) 89 { 90 u32 *tid32 = (u32 *) &tid; 91 return jhash_2words(tid32[0], tid32[1], gtp_h_initval); 92 } 93 94 static inline u32 gtp1u_hashfn(u32 tid) 95 { 96 return jhash_1word(tid, gtp_h_initval); 97 } 98 99 static inline u32 ipv4_hashfn(__be32 ip) 100 { 101 return jhash_1word((__force u32)ip, gtp_h_initval); 102 } 103 104 /* Resolve a PDP context structure based on the 64bit TID. */ 105 static struct pdp_ctx *gtp0_pdp_find(struct gtp_dev *gtp, u64 tid) 106 { 107 struct hlist_head *head; 108 struct pdp_ctx *pdp; 109 110 head = >p->tid_hash[gtp0_hashfn(tid) % gtp->hash_size]; 111 112 hlist_for_each_entry_rcu(pdp, head, hlist_tid) { 113 if (pdp->gtp_version == GTP_V0 && 114 pdp->u.v0.tid == tid) 115 return pdp; 116 } 117 return NULL; 118 } 119 120 /* Resolve a PDP context structure based on the 32bit TEI. */ 121 static struct pdp_ctx *gtp1_pdp_find(struct gtp_dev *gtp, u32 tid) 122 { 123 struct hlist_head *head; 124 struct pdp_ctx *pdp; 125 126 head = >p->tid_hash[gtp1u_hashfn(tid) % gtp->hash_size]; 127 128 hlist_for_each_entry_rcu(pdp, head, hlist_tid) { 129 if (pdp->gtp_version == GTP_V1 && 130 pdp->u.v1.i_tei == tid) 131 return pdp; 132 } 133 return NULL; 134 } 135 136 /* Resolve a PDP context based on IPv4 address of MS. */ 137 static struct pdp_ctx *ipv4_pdp_find(struct gtp_dev *gtp, __be32 ms_addr) 138 { 139 struct hlist_head *head; 140 struct pdp_ctx *pdp; 141 142 head = >p->addr_hash[ipv4_hashfn(ms_addr) % gtp->hash_size]; 143 144 hlist_for_each_entry_rcu(pdp, head, hlist_addr) { 145 if (pdp->af == AF_INET && 146 pdp->ms_addr_ip4.s_addr == ms_addr) 147 return pdp; 148 } 149 150 return NULL; 151 } 152 153 static bool gtp_check_ms_ipv4(struct sk_buff *skb, struct pdp_ctx *pctx, 154 unsigned int hdrlen, unsigned int role) 155 { 156 struct iphdr *iph; 157 158 if (!pskb_may_pull(skb, hdrlen + sizeof(struct iphdr))) 159 return false; 160 161 iph = (struct iphdr *)(skb->data + hdrlen); 162 163 if (role == GTP_ROLE_SGSN) 164 return iph->daddr == pctx->ms_addr_ip4.s_addr; 165 else 166 return iph->saddr == pctx->ms_addr_ip4.s_addr; 167 } 168 169 /* Check if the inner IP address in this packet is assigned to any 170 * existing mobile subscriber. 171 */ 172 static bool gtp_check_ms(struct sk_buff *skb, struct pdp_ctx *pctx, 173 unsigned int hdrlen, unsigned int role) 174 { 175 switch (ntohs(skb->protocol)) { 176 case ETH_P_IP: 177 return gtp_check_ms_ipv4(skb, pctx, hdrlen, role); 178 } 179 return false; 180 } 181 182 static int gtp_rx(struct pdp_ctx *pctx, struct sk_buff *skb, 183 unsigned int hdrlen, unsigned int role) 184 { 185 if (!gtp_check_ms(skb, pctx, hdrlen, role)) { 186 netdev_dbg(pctx->dev, "No PDP ctx for this MS\n"); 187 return 1; 188 } 189 190 /* Get rid of the GTP + UDP headers. */ 191 if (iptunnel_pull_header(skb, hdrlen, skb->protocol, 192 !net_eq(sock_net(pctx->sk), dev_net(pctx->dev)))) { 193 pctx->dev->stats.rx_length_errors++; 194 goto err; 195 } 196 197 netdev_dbg(pctx->dev, "forwarding packet from GGSN to uplink\n"); 198 199 /* Now that the UDP and the GTP header have been removed, set up the 200 * new network header. This is required by the upper layer to 201 * calculate the transport header. 202 */ 203 skb_reset_network_header(skb); 204 skb_reset_mac_header(skb); 205 206 skb->dev = pctx->dev; 207 208 dev_sw_netstats_rx_add(pctx->dev, skb->len); 209 210 netif_rx(skb); 211 return 0; 212 213 err: 214 pctx->dev->stats.rx_dropped++; 215 return -1; 216 } 217 218 /* 1 means pass up to the stack, -1 means drop and 0 means decapsulated. */ 219 static int gtp0_udp_encap_recv(struct gtp_dev *gtp, struct sk_buff *skb) 220 { 221 unsigned int hdrlen = sizeof(struct udphdr) + 222 sizeof(struct gtp0_header); 223 struct gtp0_header *gtp0; 224 struct pdp_ctx *pctx; 225 226 if (!pskb_may_pull(skb, hdrlen)) 227 return -1; 228 229 gtp0 = (struct gtp0_header *)(skb->data + sizeof(struct udphdr)); 230 231 if ((gtp0->flags >> 5) != GTP_V0) 232 return 1; 233 234 if (gtp0->type != GTP_TPDU) 235 return 1; 236 237 pctx = gtp0_pdp_find(gtp, be64_to_cpu(gtp0->tid)); 238 if (!pctx) { 239 netdev_dbg(gtp->dev, "No PDP ctx to decap skb=%p\n", skb); 240 return 1; 241 } 242 243 return gtp_rx(pctx, skb, hdrlen, gtp->role); 244 } 245 246 static int gtp1u_udp_encap_recv(struct gtp_dev *gtp, struct sk_buff *skb) 247 { 248 unsigned int hdrlen = sizeof(struct udphdr) + 249 sizeof(struct gtp1_header); 250 struct gtp1_header *gtp1; 251 struct pdp_ctx *pctx; 252 253 if (!pskb_may_pull(skb, hdrlen)) 254 return -1; 255 256 gtp1 = (struct gtp1_header *)(skb->data + sizeof(struct udphdr)); 257 258 if ((gtp1->flags >> 5) != GTP_V1) 259 return 1; 260 261 if (gtp1->type != GTP_TPDU) 262 return 1; 263 264 /* From 29.060: "This field shall be present if and only if any one or 265 * more of the S, PN and E flags are set.". 266 * 267 * If any of the bit is set, then the remaining ones also have to be 268 * set. 269 */ 270 if (gtp1->flags & GTP1_F_MASK) 271 hdrlen += 4; 272 273 /* Make sure the header is larger enough, including extensions. */ 274 if (!pskb_may_pull(skb, hdrlen)) 275 return -1; 276 277 gtp1 = (struct gtp1_header *)(skb->data + sizeof(struct udphdr)); 278 279 pctx = gtp1_pdp_find(gtp, ntohl(gtp1->tid)); 280 if (!pctx) { 281 netdev_dbg(gtp->dev, "No PDP ctx to decap skb=%p\n", skb); 282 return 1; 283 } 284 285 return gtp_rx(pctx, skb, hdrlen, gtp->role); 286 } 287 288 static void __gtp_encap_destroy(struct sock *sk) 289 { 290 struct gtp_dev *gtp; 291 292 lock_sock(sk); 293 gtp = sk->sk_user_data; 294 if (gtp) { 295 if (gtp->sk0 == sk) 296 gtp->sk0 = NULL; 297 else 298 gtp->sk1u = NULL; 299 udp_sk(sk)->encap_type = 0; 300 rcu_assign_sk_user_data(sk, NULL); 301 sock_put(sk); 302 } 303 release_sock(sk); 304 } 305 306 static void gtp_encap_destroy(struct sock *sk) 307 { 308 rtnl_lock(); 309 __gtp_encap_destroy(sk); 310 rtnl_unlock(); 311 } 312 313 static void gtp_encap_disable_sock(struct sock *sk) 314 { 315 if (!sk) 316 return; 317 318 __gtp_encap_destroy(sk); 319 } 320 321 static void gtp_encap_disable(struct gtp_dev *gtp) 322 { 323 gtp_encap_disable_sock(gtp->sk0); 324 gtp_encap_disable_sock(gtp->sk1u); 325 } 326 327 /* UDP encapsulation receive handler. See net/ipv4/udp.c. 328 * Return codes: 0: success, <0: error, >0: pass up to userspace UDP socket. 329 */ 330 static int gtp_encap_recv(struct sock *sk, struct sk_buff *skb) 331 { 332 struct gtp_dev *gtp; 333 int ret = 0; 334 335 gtp = rcu_dereference_sk_user_data(sk); 336 if (!gtp) 337 return 1; 338 339 netdev_dbg(gtp->dev, "encap_recv sk=%p\n", sk); 340 341 switch (udp_sk(sk)->encap_type) { 342 case UDP_ENCAP_GTP0: 343 netdev_dbg(gtp->dev, "received GTP0 packet\n"); 344 ret = gtp0_udp_encap_recv(gtp, skb); 345 break; 346 case UDP_ENCAP_GTP1U: 347 netdev_dbg(gtp->dev, "received GTP1U packet\n"); 348 ret = gtp1u_udp_encap_recv(gtp, skb); 349 break; 350 default: 351 ret = -1; /* Shouldn't happen. */ 352 } 353 354 switch (ret) { 355 case 1: 356 netdev_dbg(gtp->dev, "pass up to the process\n"); 357 break; 358 case 0: 359 break; 360 case -1: 361 netdev_dbg(gtp->dev, "GTP packet has been dropped\n"); 362 kfree_skb(skb); 363 ret = 0; 364 break; 365 } 366 367 return ret; 368 } 369 370 static int gtp_dev_init(struct net_device *dev) 371 { 372 struct gtp_dev *gtp = netdev_priv(dev); 373 374 gtp->dev = dev; 375 376 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 377 if (!dev->tstats) 378 return -ENOMEM; 379 380 return 0; 381 } 382 383 static void gtp_dev_uninit(struct net_device *dev) 384 { 385 struct gtp_dev *gtp = netdev_priv(dev); 386 387 gtp_encap_disable(gtp); 388 free_percpu(dev->tstats); 389 } 390 391 static struct rtable *ip4_route_output_gtp(struct flowi4 *fl4, 392 const struct sock *sk, 393 __be32 daddr) 394 { 395 memset(fl4, 0, sizeof(*fl4)); 396 fl4->flowi4_oif = sk->sk_bound_dev_if; 397 fl4->daddr = daddr; 398 fl4->saddr = inet_sk(sk)->inet_saddr; 399 fl4->flowi4_tos = RT_CONN_FLAGS(sk); 400 fl4->flowi4_proto = sk->sk_protocol; 401 402 return ip_route_output_key(sock_net(sk), fl4); 403 } 404 405 static inline void gtp0_push_header(struct sk_buff *skb, struct pdp_ctx *pctx) 406 { 407 int payload_len = skb->len; 408 struct gtp0_header *gtp0; 409 410 gtp0 = skb_push(skb, sizeof(*gtp0)); 411 412 gtp0->flags = 0x1e; /* v0, GTP-non-prime. */ 413 gtp0->type = GTP_TPDU; 414 gtp0->length = htons(payload_len); 415 gtp0->seq = htons((atomic_inc_return(&pctx->tx_seq) - 1) % 0xffff); 416 gtp0->flow = htons(pctx->u.v0.flow); 417 gtp0->number = 0xff; 418 gtp0->spare[0] = gtp0->spare[1] = gtp0->spare[2] = 0xff; 419 gtp0->tid = cpu_to_be64(pctx->u.v0.tid); 420 } 421 422 static inline void gtp1_push_header(struct sk_buff *skb, struct pdp_ctx *pctx) 423 { 424 int payload_len = skb->len; 425 struct gtp1_header *gtp1; 426 427 gtp1 = skb_push(skb, sizeof(*gtp1)); 428 429 /* Bits 8 7 6 5 4 3 2 1 430 * +--+--+--+--+--+--+--+--+ 431 * |version |PT| 0| E| S|PN| 432 * +--+--+--+--+--+--+--+--+ 433 * 0 0 1 1 1 0 0 0 434 */ 435 gtp1->flags = 0x30; /* v1, GTP-non-prime. */ 436 gtp1->type = GTP_TPDU; 437 gtp1->length = htons(payload_len); 438 gtp1->tid = htonl(pctx->u.v1.o_tei); 439 440 /* TODO: Support for extension header, sequence number and N-PDU. 441 * Update the length field if any of them is available. 442 */ 443 } 444 445 struct gtp_pktinfo { 446 struct sock *sk; 447 struct iphdr *iph; 448 struct flowi4 fl4; 449 struct rtable *rt; 450 struct pdp_ctx *pctx; 451 struct net_device *dev; 452 __be16 gtph_port; 453 }; 454 455 static void gtp_push_header(struct sk_buff *skb, struct gtp_pktinfo *pktinfo) 456 { 457 switch (pktinfo->pctx->gtp_version) { 458 case GTP_V0: 459 pktinfo->gtph_port = htons(GTP0_PORT); 460 gtp0_push_header(skb, pktinfo->pctx); 461 break; 462 case GTP_V1: 463 pktinfo->gtph_port = htons(GTP1U_PORT); 464 gtp1_push_header(skb, pktinfo->pctx); 465 break; 466 } 467 } 468 469 static inline void gtp_set_pktinfo_ipv4(struct gtp_pktinfo *pktinfo, 470 struct sock *sk, struct iphdr *iph, 471 struct pdp_ctx *pctx, struct rtable *rt, 472 struct flowi4 *fl4, 473 struct net_device *dev) 474 { 475 pktinfo->sk = sk; 476 pktinfo->iph = iph; 477 pktinfo->pctx = pctx; 478 pktinfo->rt = rt; 479 pktinfo->fl4 = *fl4; 480 pktinfo->dev = dev; 481 } 482 483 static int gtp_build_skb_ip4(struct sk_buff *skb, struct net_device *dev, 484 struct gtp_pktinfo *pktinfo) 485 { 486 struct gtp_dev *gtp = netdev_priv(dev); 487 struct pdp_ctx *pctx; 488 struct rtable *rt; 489 struct flowi4 fl4; 490 struct iphdr *iph; 491 __be16 df; 492 int mtu; 493 494 /* Read the IP destination address and resolve the PDP context. 495 * Prepend PDP header with TEI/TID from PDP ctx. 496 */ 497 iph = ip_hdr(skb); 498 if (gtp->role == GTP_ROLE_SGSN) 499 pctx = ipv4_pdp_find(gtp, iph->saddr); 500 else 501 pctx = ipv4_pdp_find(gtp, iph->daddr); 502 503 if (!pctx) { 504 netdev_dbg(dev, "no PDP ctx found for %pI4, skip\n", 505 &iph->daddr); 506 return -ENOENT; 507 } 508 netdev_dbg(dev, "found PDP context %p\n", pctx); 509 510 rt = ip4_route_output_gtp(&fl4, pctx->sk, pctx->peer_addr_ip4.s_addr); 511 if (IS_ERR(rt)) { 512 netdev_dbg(dev, "no route to SSGN %pI4\n", 513 &pctx->peer_addr_ip4.s_addr); 514 dev->stats.tx_carrier_errors++; 515 goto err; 516 } 517 518 if (rt->dst.dev == dev) { 519 netdev_dbg(dev, "circular route to SSGN %pI4\n", 520 &pctx->peer_addr_ip4.s_addr); 521 dev->stats.collisions++; 522 goto err_rt; 523 } 524 525 /* This is similar to tnl_update_pmtu(). */ 526 df = iph->frag_off; 527 if (df) { 528 mtu = dst_mtu(&rt->dst) - dev->hard_header_len - 529 sizeof(struct iphdr) - sizeof(struct udphdr); 530 switch (pctx->gtp_version) { 531 case GTP_V0: 532 mtu -= sizeof(struct gtp0_header); 533 break; 534 case GTP_V1: 535 mtu -= sizeof(struct gtp1_header); 536 break; 537 } 538 } else { 539 mtu = dst_mtu(&rt->dst); 540 } 541 542 skb_dst_update_pmtu_no_confirm(skb, mtu); 543 544 if (!skb_is_gso(skb) && (iph->frag_off & htons(IP_DF)) && 545 mtu < ntohs(iph->tot_len)) { 546 netdev_dbg(dev, "packet too big, fragmentation needed\n"); 547 icmp_ndo_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, 548 htonl(mtu)); 549 goto err_rt; 550 } 551 552 gtp_set_pktinfo_ipv4(pktinfo, pctx->sk, iph, pctx, rt, &fl4, dev); 553 gtp_push_header(skb, pktinfo); 554 555 return 0; 556 err_rt: 557 ip_rt_put(rt); 558 err: 559 return -EBADMSG; 560 } 561 562 static netdev_tx_t gtp_dev_xmit(struct sk_buff *skb, struct net_device *dev) 563 { 564 unsigned int proto = ntohs(skb->protocol); 565 struct gtp_pktinfo pktinfo; 566 int err; 567 568 /* Ensure there is sufficient headroom. */ 569 if (skb_cow_head(skb, dev->needed_headroom)) 570 goto tx_err; 571 572 skb_reset_inner_headers(skb); 573 574 /* PDP context lookups in gtp_build_skb_*() need rcu read-side lock. */ 575 rcu_read_lock(); 576 switch (proto) { 577 case ETH_P_IP: 578 err = gtp_build_skb_ip4(skb, dev, &pktinfo); 579 break; 580 default: 581 err = -EOPNOTSUPP; 582 break; 583 } 584 rcu_read_unlock(); 585 586 if (err < 0) 587 goto tx_err; 588 589 switch (proto) { 590 case ETH_P_IP: 591 netdev_dbg(pktinfo.dev, "gtp -> IP src: %pI4 dst: %pI4\n", 592 &pktinfo.iph->saddr, &pktinfo.iph->daddr); 593 udp_tunnel_xmit_skb(pktinfo.rt, pktinfo.sk, skb, 594 pktinfo.fl4.saddr, pktinfo.fl4.daddr, 595 pktinfo.iph->tos, 596 ip4_dst_hoplimit(&pktinfo.rt->dst), 597 0, 598 pktinfo.gtph_port, pktinfo.gtph_port, 599 !net_eq(sock_net(pktinfo.pctx->sk), 600 dev_net(dev)), 601 false); 602 break; 603 } 604 605 return NETDEV_TX_OK; 606 tx_err: 607 dev->stats.tx_errors++; 608 dev_kfree_skb(skb); 609 return NETDEV_TX_OK; 610 } 611 612 static const struct net_device_ops gtp_netdev_ops = { 613 .ndo_init = gtp_dev_init, 614 .ndo_uninit = gtp_dev_uninit, 615 .ndo_start_xmit = gtp_dev_xmit, 616 .ndo_get_stats64 = dev_get_tstats64, 617 }; 618 619 static const struct device_type gtp_type = { 620 .name = "gtp", 621 }; 622 623 static void gtp_link_setup(struct net_device *dev) 624 { 625 unsigned int max_gtp_header_len = sizeof(struct iphdr) + 626 sizeof(struct udphdr) + 627 sizeof(struct gtp0_header); 628 629 dev->netdev_ops = >p_netdev_ops; 630 dev->needs_free_netdev = true; 631 SET_NETDEV_DEVTYPE(dev, >p_type); 632 633 dev->hard_header_len = 0; 634 dev->addr_len = 0; 635 dev->mtu = ETH_DATA_LEN - max_gtp_header_len; 636 637 /* Zero header length. */ 638 dev->type = ARPHRD_NONE; 639 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 640 641 dev->priv_flags |= IFF_NO_QUEUE; 642 dev->features |= NETIF_F_LLTX; 643 netif_keep_dst(dev); 644 645 dev->needed_headroom = LL_MAX_HEADER + max_gtp_header_len; 646 } 647 648 static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize); 649 static int gtp_encap_enable(struct gtp_dev *gtp, struct nlattr *data[]); 650 651 static void gtp_destructor(struct net_device *dev) 652 { 653 struct gtp_dev *gtp = netdev_priv(dev); 654 655 kfree(gtp->addr_hash); 656 kfree(gtp->tid_hash); 657 } 658 659 static int gtp_newlink(struct net *src_net, struct net_device *dev, 660 struct nlattr *tb[], struct nlattr *data[], 661 struct netlink_ext_ack *extack) 662 { 663 struct gtp_dev *gtp; 664 struct gtp_net *gn; 665 int hashsize, err; 666 667 if (!data[IFLA_GTP_FD0] && !data[IFLA_GTP_FD1]) 668 return -EINVAL; 669 670 gtp = netdev_priv(dev); 671 672 if (!data[IFLA_GTP_PDP_HASHSIZE]) { 673 hashsize = 1024; 674 } else { 675 hashsize = nla_get_u32(data[IFLA_GTP_PDP_HASHSIZE]); 676 if (!hashsize) 677 hashsize = 1024; 678 } 679 680 err = gtp_hashtable_new(gtp, hashsize); 681 if (err < 0) 682 return err; 683 684 err = gtp_encap_enable(gtp, data); 685 if (err < 0) 686 goto out_hashtable; 687 688 err = register_netdevice(dev); 689 if (err < 0) { 690 netdev_dbg(dev, "failed to register new netdev %d\n", err); 691 goto out_encap; 692 } 693 694 gn = net_generic(dev_net(dev), gtp_net_id); 695 list_add_rcu(>p->list, &gn->gtp_dev_list); 696 dev->priv_destructor = gtp_destructor; 697 698 netdev_dbg(dev, "registered new GTP interface\n"); 699 700 return 0; 701 702 out_encap: 703 gtp_encap_disable(gtp); 704 out_hashtable: 705 kfree(gtp->addr_hash); 706 kfree(gtp->tid_hash); 707 return err; 708 } 709 710 static void gtp_dellink(struct net_device *dev, struct list_head *head) 711 { 712 struct gtp_dev *gtp = netdev_priv(dev); 713 struct pdp_ctx *pctx; 714 int i; 715 716 for (i = 0; i < gtp->hash_size; i++) 717 hlist_for_each_entry_rcu(pctx, >p->tid_hash[i], hlist_tid) 718 pdp_context_delete(pctx); 719 720 list_del_rcu(>p->list); 721 unregister_netdevice_queue(dev, head); 722 } 723 724 static const struct nla_policy gtp_policy[IFLA_GTP_MAX + 1] = { 725 [IFLA_GTP_FD0] = { .type = NLA_U32 }, 726 [IFLA_GTP_FD1] = { .type = NLA_U32 }, 727 [IFLA_GTP_PDP_HASHSIZE] = { .type = NLA_U32 }, 728 [IFLA_GTP_ROLE] = { .type = NLA_U32 }, 729 }; 730 731 static int gtp_validate(struct nlattr *tb[], struct nlattr *data[], 732 struct netlink_ext_ack *extack) 733 { 734 if (!data) 735 return -EINVAL; 736 737 return 0; 738 } 739 740 static size_t gtp_get_size(const struct net_device *dev) 741 { 742 return nla_total_size(sizeof(__u32)) + /* IFLA_GTP_PDP_HASHSIZE */ 743 nla_total_size(sizeof(__u32)); /* IFLA_GTP_ROLE */ 744 } 745 746 static int gtp_fill_info(struct sk_buff *skb, const struct net_device *dev) 747 { 748 struct gtp_dev *gtp = netdev_priv(dev); 749 750 if (nla_put_u32(skb, IFLA_GTP_PDP_HASHSIZE, gtp->hash_size)) 751 goto nla_put_failure; 752 if (nla_put_u32(skb, IFLA_GTP_ROLE, gtp->role)) 753 goto nla_put_failure; 754 755 return 0; 756 757 nla_put_failure: 758 return -EMSGSIZE; 759 } 760 761 static struct rtnl_link_ops gtp_link_ops __read_mostly = { 762 .kind = "gtp", 763 .maxtype = IFLA_GTP_MAX, 764 .policy = gtp_policy, 765 .priv_size = sizeof(struct gtp_dev), 766 .setup = gtp_link_setup, 767 .validate = gtp_validate, 768 .newlink = gtp_newlink, 769 .dellink = gtp_dellink, 770 .get_size = gtp_get_size, 771 .fill_info = gtp_fill_info, 772 }; 773 774 static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize) 775 { 776 int i; 777 778 gtp->addr_hash = kmalloc_array(hsize, sizeof(struct hlist_head), 779 GFP_KERNEL | __GFP_NOWARN); 780 if (gtp->addr_hash == NULL) 781 return -ENOMEM; 782 783 gtp->tid_hash = kmalloc_array(hsize, sizeof(struct hlist_head), 784 GFP_KERNEL | __GFP_NOWARN); 785 if (gtp->tid_hash == NULL) 786 goto err1; 787 788 gtp->hash_size = hsize; 789 790 for (i = 0; i < hsize; i++) { 791 INIT_HLIST_HEAD(>p->addr_hash[i]); 792 INIT_HLIST_HEAD(>p->tid_hash[i]); 793 } 794 return 0; 795 err1: 796 kfree(gtp->addr_hash); 797 return -ENOMEM; 798 } 799 800 static struct sock *gtp_encap_enable_socket(int fd, int type, 801 struct gtp_dev *gtp) 802 { 803 struct udp_tunnel_sock_cfg tuncfg = {NULL}; 804 struct socket *sock; 805 struct sock *sk; 806 int err; 807 808 pr_debug("enable gtp on %d, %d\n", fd, type); 809 810 sock = sockfd_lookup(fd, &err); 811 if (!sock) { 812 pr_debug("gtp socket fd=%d not found\n", fd); 813 return NULL; 814 } 815 816 sk = sock->sk; 817 if (sk->sk_protocol != IPPROTO_UDP || 818 sk->sk_type != SOCK_DGRAM || 819 (sk->sk_family != AF_INET && sk->sk_family != AF_INET6)) { 820 pr_debug("socket fd=%d not UDP\n", fd); 821 sk = ERR_PTR(-EINVAL); 822 goto out_sock; 823 } 824 825 lock_sock(sk); 826 if (sk->sk_user_data) { 827 sk = ERR_PTR(-EBUSY); 828 goto out_rel_sock; 829 } 830 831 sock_hold(sk); 832 833 tuncfg.sk_user_data = gtp; 834 tuncfg.encap_type = type; 835 tuncfg.encap_rcv = gtp_encap_recv; 836 tuncfg.encap_destroy = gtp_encap_destroy; 837 838 setup_udp_tunnel_sock(sock_net(sock->sk), sock, &tuncfg); 839 840 out_rel_sock: 841 release_sock(sock->sk); 842 out_sock: 843 sockfd_put(sock); 844 return sk; 845 } 846 847 static int gtp_encap_enable(struct gtp_dev *gtp, struct nlattr *data[]) 848 { 849 struct sock *sk1u = NULL; 850 struct sock *sk0 = NULL; 851 unsigned int role = GTP_ROLE_GGSN; 852 853 if (data[IFLA_GTP_FD0]) { 854 u32 fd0 = nla_get_u32(data[IFLA_GTP_FD0]); 855 856 sk0 = gtp_encap_enable_socket(fd0, UDP_ENCAP_GTP0, gtp); 857 if (IS_ERR(sk0)) 858 return PTR_ERR(sk0); 859 } 860 861 if (data[IFLA_GTP_FD1]) { 862 u32 fd1 = nla_get_u32(data[IFLA_GTP_FD1]); 863 864 sk1u = gtp_encap_enable_socket(fd1, UDP_ENCAP_GTP1U, gtp); 865 if (IS_ERR(sk1u)) { 866 gtp_encap_disable_sock(sk0); 867 return PTR_ERR(sk1u); 868 } 869 } 870 871 if (data[IFLA_GTP_ROLE]) { 872 role = nla_get_u32(data[IFLA_GTP_ROLE]); 873 if (role > GTP_ROLE_SGSN) { 874 gtp_encap_disable_sock(sk0); 875 gtp_encap_disable_sock(sk1u); 876 return -EINVAL; 877 } 878 } 879 880 gtp->sk0 = sk0; 881 gtp->sk1u = sk1u; 882 gtp->role = role; 883 884 return 0; 885 } 886 887 static struct gtp_dev *gtp_find_dev(struct net *src_net, struct nlattr *nla[]) 888 { 889 struct gtp_dev *gtp = NULL; 890 struct net_device *dev; 891 struct net *net; 892 893 /* Examine the link attributes and figure out which network namespace 894 * we are talking about. 895 */ 896 if (nla[GTPA_NET_NS_FD]) 897 net = get_net_ns_by_fd(nla_get_u32(nla[GTPA_NET_NS_FD])); 898 else 899 net = get_net(src_net); 900 901 if (IS_ERR(net)) 902 return NULL; 903 904 /* Check if there's an existing gtpX device to configure */ 905 dev = dev_get_by_index_rcu(net, nla_get_u32(nla[GTPA_LINK])); 906 if (dev && dev->netdev_ops == >p_netdev_ops) 907 gtp = netdev_priv(dev); 908 909 put_net(net); 910 return gtp; 911 } 912 913 static void ipv4_pdp_fill(struct pdp_ctx *pctx, struct genl_info *info) 914 { 915 pctx->gtp_version = nla_get_u32(info->attrs[GTPA_VERSION]); 916 pctx->af = AF_INET; 917 pctx->peer_addr_ip4.s_addr = 918 nla_get_be32(info->attrs[GTPA_PEER_ADDRESS]); 919 pctx->ms_addr_ip4.s_addr = 920 nla_get_be32(info->attrs[GTPA_MS_ADDRESS]); 921 922 switch (pctx->gtp_version) { 923 case GTP_V0: 924 /* According to TS 09.60, sections 7.5.1 and 7.5.2, the flow 925 * label needs to be the same for uplink and downlink packets, 926 * so let's annotate this. 927 */ 928 pctx->u.v0.tid = nla_get_u64(info->attrs[GTPA_TID]); 929 pctx->u.v0.flow = nla_get_u16(info->attrs[GTPA_FLOW]); 930 break; 931 case GTP_V1: 932 pctx->u.v1.i_tei = nla_get_u32(info->attrs[GTPA_I_TEI]); 933 pctx->u.v1.o_tei = nla_get_u32(info->attrs[GTPA_O_TEI]); 934 break; 935 default: 936 break; 937 } 938 } 939 940 static struct pdp_ctx *gtp_pdp_add(struct gtp_dev *gtp, struct sock *sk, 941 struct genl_info *info) 942 { 943 struct pdp_ctx *pctx, *pctx_tid = NULL; 944 struct net_device *dev = gtp->dev; 945 u32 hash_ms, hash_tid = 0; 946 unsigned int version; 947 bool found = false; 948 __be32 ms_addr; 949 950 ms_addr = nla_get_be32(info->attrs[GTPA_MS_ADDRESS]); 951 hash_ms = ipv4_hashfn(ms_addr) % gtp->hash_size; 952 version = nla_get_u32(info->attrs[GTPA_VERSION]); 953 954 pctx = ipv4_pdp_find(gtp, ms_addr); 955 if (pctx) 956 found = true; 957 if (version == GTP_V0) 958 pctx_tid = gtp0_pdp_find(gtp, 959 nla_get_u64(info->attrs[GTPA_TID])); 960 else if (version == GTP_V1) 961 pctx_tid = gtp1_pdp_find(gtp, 962 nla_get_u32(info->attrs[GTPA_I_TEI])); 963 if (pctx_tid) 964 found = true; 965 966 if (found) { 967 if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) 968 return ERR_PTR(-EEXIST); 969 if (info->nlhdr->nlmsg_flags & NLM_F_REPLACE) 970 return ERR_PTR(-EOPNOTSUPP); 971 972 if (pctx && pctx_tid) 973 return ERR_PTR(-EEXIST); 974 if (!pctx) 975 pctx = pctx_tid; 976 977 ipv4_pdp_fill(pctx, info); 978 979 if (pctx->gtp_version == GTP_V0) 980 netdev_dbg(dev, "GTPv0-U: update tunnel id = %llx (pdp %p)\n", 981 pctx->u.v0.tid, pctx); 982 else if (pctx->gtp_version == GTP_V1) 983 netdev_dbg(dev, "GTPv1-U: update tunnel id = %x/%x (pdp %p)\n", 984 pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx); 985 986 return pctx; 987 988 } 989 990 pctx = kmalloc(sizeof(*pctx), GFP_ATOMIC); 991 if (pctx == NULL) 992 return ERR_PTR(-ENOMEM); 993 994 sock_hold(sk); 995 pctx->sk = sk; 996 pctx->dev = gtp->dev; 997 ipv4_pdp_fill(pctx, info); 998 atomic_set(&pctx->tx_seq, 0); 999 1000 switch (pctx->gtp_version) { 1001 case GTP_V0: 1002 /* TS 09.60: "The flow label identifies unambiguously a GTP 1003 * flow.". We use the tid for this instead, I cannot find a 1004 * situation in which this doesn't unambiguosly identify the 1005 * PDP context. 1006 */ 1007 hash_tid = gtp0_hashfn(pctx->u.v0.tid) % gtp->hash_size; 1008 break; 1009 case GTP_V1: 1010 hash_tid = gtp1u_hashfn(pctx->u.v1.i_tei) % gtp->hash_size; 1011 break; 1012 } 1013 1014 hlist_add_head_rcu(&pctx->hlist_addr, >p->addr_hash[hash_ms]); 1015 hlist_add_head_rcu(&pctx->hlist_tid, >p->tid_hash[hash_tid]); 1016 1017 switch (pctx->gtp_version) { 1018 case GTP_V0: 1019 netdev_dbg(dev, "GTPv0-U: new PDP ctx id=%llx ssgn=%pI4 ms=%pI4 (pdp=%p)\n", 1020 pctx->u.v0.tid, &pctx->peer_addr_ip4, 1021 &pctx->ms_addr_ip4, pctx); 1022 break; 1023 case GTP_V1: 1024 netdev_dbg(dev, "GTPv1-U: new PDP ctx id=%x/%x ssgn=%pI4 ms=%pI4 (pdp=%p)\n", 1025 pctx->u.v1.i_tei, pctx->u.v1.o_tei, 1026 &pctx->peer_addr_ip4, &pctx->ms_addr_ip4, pctx); 1027 break; 1028 } 1029 1030 return pctx; 1031 } 1032 1033 static void pdp_context_free(struct rcu_head *head) 1034 { 1035 struct pdp_ctx *pctx = container_of(head, struct pdp_ctx, rcu_head); 1036 1037 sock_put(pctx->sk); 1038 kfree(pctx); 1039 } 1040 1041 static void pdp_context_delete(struct pdp_ctx *pctx) 1042 { 1043 hlist_del_rcu(&pctx->hlist_tid); 1044 hlist_del_rcu(&pctx->hlist_addr); 1045 call_rcu(&pctx->rcu_head, pdp_context_free); 1046 } 1047 1048 static int gtp_tunnel_notify(struct pdp_ctx *pctx, u8 cmd, gfp_t allocation); 1049 1050 static int gtp_genl_new_pdp(struct sk_buff *skb, struct genl_info *info) 1051 { 1052 unsigned int version; 1053 struct pdp_ctx *pctx; 1054 struct gtp_dev *gtp; 1055 struct sock *sk; 1056 int err; 1057 1058 if (!info->attrs[GTPA_VERSION] || 1059 !info->attrs[GTPA_LINK] || 1060 !info->attrs[GTPA_PEER_ADDRESS] || 1061 !info->attrs[GTPA_MS_ADDRESS]) 1062 return -EINVAL; 1063 1064 version = nla_get_u32(info->attrs[GTPA_VERSION]); 1065 1066 switch (version) { 1067 case GTP_V0: 1068 if (!info->attrs[GTPA_TID] || 1069 !info->attrs[GTPA_FLOW]) 1070 return -EINVAL; 1071 break; 1072 case GTP_V1: 1073 if (!info->attrs[GTPA_I_TEI] || 1074 !info->attrs[GTPA_O_TEI]) 1075 return -EINVAL; 1076 break; 1077 1078 default: 1079 return -EINVAL; 1080 } 1081 1082 rtnl_lock(); 1083 1084 gtp = gtp_find_dev(sock_net(skb->sk), info->attrs); 1085 if (!gtp) { 1086 err = -ENODEV; 1087 goto out_unlock; 1088 } 1089 1090 if (version == GTP_V0) 1091 sk = gtp->sk0; 1092 else if (version == GTP_V1) 1093 sk = gtp->sk1u; 1094 else 1095 sk = NULL; 1096 1097 if (!sk) { 1098 err = -ENODEV; 1099 goto out_unlock; 1100 } 1101 1102 pctx = gtp_pdp_add(gtp, sk, info); 1103 if (IS_ERR(pctx)) { 1104 err = PTR_ERR(pctx); 1105 } else { 1106 gtp_tunnel_notify(pctx, GTP_CMD_NEWPDP, GFP_KERNEL); 1107 err = 0; 1108 } 1109 1110 out_unlock: 1111 rtnl_unlock(); 1112 return err; 1113 } 1114 1115 static struct pdp_ctx *gtp_find_pdp_by_link(struct net *net, 1116 struct nlattr *nla[]) 1117 { 1118 struct gtp_dev *gtp; 1119 1120 gtp = gtp_find_dev(net, nla); 1121 if (!gtp) 1122 return ERR_PTR(-ENODEV); 1123 1124 if (nla[GTPA_MS_ADDRESS]) { 1125 __be32 ip = nla_get_be32(nla[GTPA_MS_ADDRESS]); 1126 1127 return ipv4_pdp_find(gtp, ip); 1128 } else if (nla[GTPA_VERSION]) { 1129 u32 gtp_version = nla_get_u32(nla[GTPA_VERSION]); 1130 1131 if (gtp_version == GTP_V0 && nla[GTPA_TID]) 1132 return gtp0_pdp_find(gtp, nla_get_u64(nla[GTPA_TID])); 1133 else if (gtp_version == GTP_V1 && nla[GTPA_I_TEI]) 1134 return gtp1_pdp_find(gtp, nla_get_u32(nla[GTPA_I_TEI])); 1135 } 1136 1137 return ERR_PTR(-EINVAL); 1138 } 1139 1140 static struct pdp_ctx *gtp_find_pdp(struct net *net, struct nlattr *nla[]) 1141 { 1142 struct pdp_ctx *pctx; 1143 1144 if (nla[GTPA_LINK]) 1145 pctx = gtp_find_pdp_by_link(net, nla); 1146 else 1147 pctx = ERR_PTR(-EINVAL); 1148 1149 if (!pctx) 1150 pctx = ERR_PTR(-ENOENT); 1151 1152 return pctx; 1153 } 1154 1155 static int gtp_genl_del_pdp(struct sk_buff *skb, struct genl_info *info) 1156 { 1157 struct pdp_ctx *pctx; 1158 int err = 0; 1159 1160 if (!info->attrs[GTPA_VERSION]) 1161 return -EINVAL; 1162 1163 rcu_read_lock(); 1164 1165 pctx = gtp_find_pdp(sock_net(skb->sk), info->attrs); 1166 if (IS_ERR(pctx)) { 1167 err = PTR_ERR(pctx); 1168 goto out_unlock; 1169 } 1170 1171 if (pctx->gtp_version == GTP_V0) 1172 netdev_dbg(pctx->dev, "GTPv0-U: deleting tunnel id = %llx (pdp %p)\n", 1173 pctx->u.v0.tid, pctx); 1174 else if (pctx->gtp_version == GTP_V1) 1175 netdev_dbg(pctx->dev, "GTPv1-U: deleting tunnel id = %x/%x (pdp %p)\n", 1176 pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx); 1177 1178 gtp_tunnel_notify(pctx, GTP_CMD_DELPDP, GFP_ATOMIC); 1179 pdp_context_delete(pctx); 1180 1181 out_unlock: 1182 rcu_read_unlock(); 1183 return err; 1184 } 1185 1186 static struct genl_family gtp_genl_family; 1187 1188 enum gtp_multicast_groups { 1189 GTP_GENL_MCGRP, 1190 }; 1191 1192 static const struct genl_multicast_group gtp_genl_mcgrps[] = { 1193 [GTP_GENL_MCGRP] = { .name = GTP_GENL_MCGRP_NAME }, 1194 }; 1195 1196 static int gtp_genl_fill_info(struct sk_buff *skb, u32 snd_portid, u32 snd_seq, 1197 int flags, u32 type, struct pdp_ctx *pctx) 1198 { 1199 void *genlh; 1200 1201 genlh = genlmsg_put(skb, snd_portid, snd_seq, >p_genl_family, flags, 1202 type); 1203 if (genlh == NULL) 1204 goto nlmsg_failure; 1205 1206 if (nla_put_u32(skb, GTPA_VERSION, pctx->gtp_version) || 1207 nla_put_u32(skb, GTPA_LINK, pctx->dev->ifindex) || 1208 nla_put_be32(skb, GTPA_PEER_ADDRESS, pctx->peer_addr_ip4.s_addr) || 1209 nla_put_be32(skb, GTPA_MS_ADDRESS, pctx->ms_addr_ip4.s_addr)) 1210 goto nla_put_failure; 1211 1212 switch (pctx->gtp_version) { 1213 case GTP_V0: 1214 if (nla_put_u64_64bit(skb, GTPA_TID, pctx->u.v0.tid, GTPA_PAD) || 1215 nla_put_u16(skb, GTPA_FLOW, pctx->u.v0.flow)) 1216 goto nla_put_failure; 1217 break; 1218 case GTP_V1: 1219 if (nla_put_u32(skb, GTPA_I_TEI, pctx->u.v1.i_tei) || 1220 nla_put_u32(skb, GTPA_O_TEI, pctx->u.v1.o_tei)) 1221 goto nla_put_failure; 1222 break; 1223 } 1224 genlmsg_end(skb, genlh); 1225 return 0; 1226 1227 nlmsg_failure: 1228 nla_put_failure: 1229 genlmsg_cancel(skb, genlh); 1230 return -EMSGSIZE; 1231 } 1232 1233 static int gtp_tunnel_notify(struct pdp_ctx *pctx, u8 cmd, gfp_t allocation) 1234 { 1235 struct sk_buff *msg; 1236 int ret; 1237 1238 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, allocation); 1239 if (!msg) 1240 return -ENOMEM; 1241 1242 ret = gtp_genl_fill_info(msg, 0, 0, 0, cmd, pctx); 1243 if (ret < 0) { 1244 nlmsg_free(msg); 1245 return ret; 1246 } 1247 1248 ret = genlmsg_multicast_netns(>p_genl_family, dev_net(pctx->dev), msg, 1249 0, GTP_GENL_MCGRP, GFP_ATOMIC); 1250 return ret; 1251 } 1252 1253 static int gtp_genl_get_pdp(struct sk_buff *skb, struct genl_info *info) 1254 { 1255 struct pdp_ctx *pctx = NULL; 1256 struct sk_buff *skb2; 1257 int err; 1258 1259 if (!info->attrs[GTPA_VERSION]) 1260 return -EINVAL; 1261 1262 rcu_read_lock(); 1263 1264 pctx = gtp_find_pdp(sock_net(skb->sk), info->attrs); 1265 if (IS_ERR(pctx)) { 1266 err = PTR_ERR(pctx); 1267 goto err_unlock; 1268 } 1269 1270 skb2 = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC); 1271 if (skb2 == NULL) { 1272 err = -ENOMEM; 1273 goto err_unlock; 1274 } 1275 1276 err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid, info->snd_seq, 1277 0, info->nlhdr->nlmsg_type, pctx); 1278 if (err < 0) 1279 goto err_unlock_free; 1280 1281 rcu_read_unlock(); 1282 return genlmsg_unicast(genl_info_net(info), skb2, info->snd_portid); 1283 1284 err_unlock_free: 1285 kfree_skb(skb2); 1286 err_unlock: 1287 rcu_read_unlock(); 1288 return err; 1289 } 1290 1291 static int gtp_genl_dump_pdp(struct sk_buff *skb, 1292 struct netlink_callback *cb) 1293 { 1294 struct gtp_dev *last_gtp = (struct gtp_dev *)cb->args[2], *gtp; 1295 int i, j, bucket = cb->args[0], skip = cb->args[1]; 1296 struct net *net = sock_net(skb->sk); 1297 struct pdp_ctx *pctx; 1298 struct gtp_net *gn; 1299 1300 gn = net_generic(net, gtp_net_id); 1301 1302 if (cb->args[4]) 1303 return 0; 1304 1305 rcu_read_lock(); 1306 list_for_each_entry_rcu(gtp, &gn->gtp_dev_list, list) { 1307 if (last_gtp && last_gtp != gtp) 1308 continue; 1309 else 1310 last_gtp = NULL; 1311 1312 for (i = bucket; i < gtp->hash_size; i++) { 1313 j = 0; 1314 hlist_for_each_entry_rcu(pctx, >p->tid_hash[i], 1315 hlist_tid) { 1316 if (j >= skip && 1317 gtp_genl_fill_info(skb, 1318 NETLINK_CB(cb->skb).portid, 1319 cb->nlh->nlmsg_seq, 1320 NLM_F_MULTI, 1321 cb->nlh->nlmsg_type, pctx)) { 1322 cb->args[0] = i; 1323 cb->args[1] = j; 1324 cb->args[2] = (unsigned long)gtp; 1325 goto out; 1326 } 1327 j++; 1328 } 1329 skip = 0; 1330 } 1331 bucket = 0; 1332 } 1333 cb->args[4] = 1; 1334 out: 1335 rcu_read_unlock(); 1336 return skb->len; 1337 } 1338 1339 static const struct nla_policy gtp_genl_policy[GTPA_MAX + 1] = { 1340 [GTPA_LINK] = { .type = NLA_U32, }, 1341 [GTPA_VERSION] = { .type = NLA_U32, }, 1342 [GTPA_TID] = { .type = NLA_U64, }, 1343 [GTPA_PEER_ADDRESS] = { .type = NLA_U32, }, 1344 [GTPA_MS_ADDRESS] = { .type = NLA_U32, }, 1345 [GTPA_FLOW] = { .type = NLA_U16, }, 1346 [GTPA_NET_NS_FD] = { .type = NLA_U32, }, 1347 [GTPA_I_TEI] = { .type = NLA_U32, }, 1348 [GTPA_O_TEI] = { .type = NLA_U32, }, 1349 }; 1350 1351 static const struct genl_small_ops gtp_genl_ops[] = { 1352 { 1353 .cmd = GTP_CMD_NEWPDP, 1354 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1355 .doit = gtp_genl_new_pdp, 1356 .flags = GENL_ADMIN_PERM, 1357 }, 1358 { 1359 .cmd = GTP_CMD_DELPDP, 1360 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1361 .doit = gtp_genl_del_pdp, 1362 .flags = GENL_ADMIN_PERM, 1363 }, 1364 { 1365 .cmd = GTP_CMD_GETPDP, 1366 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1367 .doit = gtp_genl_get_pdp, 1368 .dumpit = gtp_genl_dump_pdp, 1369 .flags = GENL_ADMIN_PERM, 1370 }, 1371 }; 1372 1373 static struct genl_family gtp_genl_family __ro_after_init = { 1374 .name = "gtp", 1375 .version = 0, 1376 .hdrsize = 0, 1377 .maxattr = GTPA_MAX, 1378 .policy = gtp_genl_policy, 1379 .netnsok = true, 1380 .module = THIS_MODULE, 1381 .small_ops = gtp_genl_ops, 1382 .n_small_ops = ARRAY_SIZE(gtp_genl_ops), 1383 .mcgrps = gtp_genl_mcgrps, 1384 .n_mcgrps = ARRAY_SIZE(gtp_genl_mcgrps), 1385 }; 1386 1387 static int __net_init gtp_net_init(struct net *net) 1388 { 1389 struct gtp_net *gn = net_generic(net, gtp_net_id); 1390 1391 INIT_LIST_HEAD(&gn->gtp_dev_list); 1392 return 0; 1393 } 1394 1395 static void __net_exit gtp_net_exit(struct net *net) 1396 { 1397 struct gtp_net *gn = net_generic(net, gtp_net_id); 1398 struct gtp_dev *gtp; 1399 LIST_HEAD(list); 1400 1401 rtnl_lock(); 1402 list_for_each_entry(gtp, &gn->gtp_dev_list, list) 1403 gtp_dellink(gtp->dev, &list); 1404 1405 unregister_netdevice_many(&list); 1406 rtnl_unlock(); 1407 } 1408 1409 static struct pernet_operations gtp_net_ops = { 1410 .init = gtp_net_init, 1411 .exit = gtp_net_exit, 1412 .id = >p_net_id, 1413 .size = sizeof(struct gtp_net), 1414 }; 1415 1416 static int __init gtp_init(void) 1417 { 1418 int err; 1419 1420 get_random_bytes(>p_h_initval, sizeof(gtp_h_initval)); 1421 1422 err = rtnl_link_register(>p_link_ops); 1423 if (err < 0) 1424 goto error_out; 1425 1426 err = genl_register_family(>p_genl_family); 1427 if (err < 0) 1428 goto unreg_rtnl_link; 1429 1430 err = register_pernet_subsys(>p_net_ops); 1431 if (err < 0) 1432 goto unreg_genl_family; 1433 1434 pr_info("GTP module loaded (pdp ctx size %zd bytes)\n", 1435 sizeof(struct pdp_ctx)); 1436 return 0; 1437 1438 unreg_genl_family: 1439 genl_unregister_family(>p_genl_family); 1440 unreg_rtnl_link: 1441 rtnl_link_unregister(>p_link_ops); 1442 error_out: 1443 pr_err("error loading GTP module loaded\n"); 1444 return err; 1445 } 1446 late_initcall(gtp_init); 1447 1448 static void __exit gtp_fini(void) 1449 { 1450 genl_unregister_family(>p_genl_family); 1451 rtnl_link_unregister(>p_link_ops); 1452 unregister_pernet_subsys(>p_net_ops); 1453 1454 pr_info("GTP module unloaded\n"); 1455 } 1456 module_exit(gtp_fini); 1457 1458 MODULE_LICENSE("GPL"); 1459 MODULE_AUTHOR("Harald Welte <hwelte@sysmocom.de>"); 1460 MODULE_DESCRIPTION("Interface driver for GTP encapsulated traffic"); 1461 MODULE_ALIAS_RTNL_LINK("gtp"); 1462 MODULE_ALIAS_GENL_FAMILY("gtp"); 1463