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