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 struct pcpu_sw_netstats *stats; 186 187 if (!gtp_check_ms(skb, pctx, hdrlen, role)) { 188 netdev_dbg(pctx->dev, "No PDP ctx for this MS\n"); 189 return 1; 190 } 191 192 /* Get rid of the GTP + UDP headers. */ 193 if (iptunnel_pull_header(skb, hdrlen, skb->protocol, 194 !net_eq(sock_net(pctx->sk), dev_net(pctx->dev)))) 195 return -1; 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 stats = this_cpu_ptr(pctx->dev->tstats); 208 u64_stats_update_begin(&stats->syncp); 209 stats->rx_packets++; 210 stats->rx_bytes += skb->len; 211 u64_stats_update_end(&stats->syncp); 212 213 netif_rx(skb); 214 return 0; 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 skb_dst_drop(skb); 525 526 /* This is similar to tnl_update_pmtu(). */ 527 df = iph->frag_off; 528 if (df) { 529 mtu = dst_mtu(&rt->dst) - dev->hard_header_len - 530 sizeof(struct iphdr) - sizeof(struct udphdr); 531 switch (pctx->gtp_version) { 532 case GTP_V0: 533 mtu -= sizeof(struct gtp0_header); 534 break; 535 case GTP_V1: 536 mtu -= sizeof(struct gtp1_header); 537 break; 538 } 539 } else { 540 mtu = dst_mtu(&rt->dst); 541 } 542 543 rt->dst.ops->update_pmtu(&rt->dst, NULL, skb, mtu, false); 544 545 if (!skb_is_gso(skb) && (iph->frag_off & htons(IP_DF)) && 546 mtu < ntohs(iph->tot_len)) { 547 netdev_dbg(dev, "packet too big, fragmentation needed\n"); 548 memset(IPCB(skb), 0, sizeof(*IPCB(skb))); 549 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, 550 htonl(mtu)); 551 goto err_rt; 552 } 553 554 gtp_set_pktinfo_ipv4(pktinfo, pctx->sk, iph, pctx, rt, &fl4, dev); 555 gtp_push_header(skb, pktinfo); 556 557 return 0; 558 err_rt: 559 ip_rt_put(rt); 560 err: 561 return -EBADMSG; 562 } 563 564 static netdev_tx_t gtp_dev_xmit(struct sk_buff *skb, struct net_device *dev) 565 { 566 unsigned int proto = ntohs(skb->protocol); 567 struct gtp_pktinfo pktinfo; 568 int err; 569 570 /* Ensure there is sufficient headroom. */ 571 if (skb_cow_head(skb, dev->needed_headroom)) 572 goto tx_err; 573 574 skb_reset_inner_headers(skb); 575 576 /* PDP context lookups in gtp_build_skb_*() need rcu read-side lock. */ 577 rcu_read_lock(); 578 switch (proto) { 579 case ETH_P_IP: 580 err = gtp_build_skb_ip4(skb, dev, &pktinfo); 581 break; 582 default: 583 err = -EOPNOTSUPP; 584 break; 585 } 586 rcu_read_unlock(); 587 588 if (err < 0) 589 goto tx_err; 590 591 switch (proto) { 592 case ETH_P_IP: 593 netdev_dbg(pktinfo.dev, "gtp -> IP src: %pI4 dst: %pI4\n", 594 &pktinfo.iph->saddr, &pktinfo.iph->daddr); 595 udp_tunnel_xmit_skb(pktinfo.rt, pktinfo.sk, skb, 596 pktinfo.fl4.saddr, pktinfo.fl4.daddr, 597 pktinfo.iph->tos, 598 ip4_dst_hoplimit(&pktinfo.rt->dst), 599 0, 600 pktinfo.gtph_port, pktinfo.gtph_port, 601 true, 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 = ip_tunnel_get_stats64, 617 }; 618 619 static void gtp_link_setup(struct net_device *dev) 620 { 621 dev->netdev_ops = >p_netdev_ops; 622 dev->needs_free_netdev = true; 623 624 dev->hard_header_len = 0; 625 dev->addr_len = 0; 626 627 /* Zero header length. */ 628 dev->type = ARPHRD_NONE; 629 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 630 631 dev->priv_flags |= IFF_NO_QUEUE; 632 dev->features |= NETIF_F_LLTX; 633 netif_keep_dst(dev); 634 635 /* Assume largest header, ie. GTPv0. */ 636 dev->needed_headroom = LL_MAX_HEADER + 637 sizeof(struct iphdr) + 638 sizeof(struct udphdr) + 639 sizeof(struct gtp0_header); 640 } 641 642 static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize); 643 static int gtp_encap_enable(struct gtp_dev *gtp, struct nlattr *data[]); 644 645 static void gtp_destructor(struct net_device *dev) 646 { 647 struct gtp_dev *gtp = netdev_priv(dev); 648 649 kfree(gtp->addr_hash); 650 kfree(gtp->tid_hash); 651 } 652 653 static int gtp_newlink(struct net *src_net, struct net_device *dev, 654 struct nlattr *tb[], struct nlattr *data[], 655 struct netlink_ext_ack *extack) 656 { 657 struct gtp_dev *gtp; 658 struct gtp_net *gn; 659 int hashsize, err; 660 661 if (!data[IFLA_GTP_FD0] && !data[IFLA_GTP_FD1]) 662 return -EINVAL; 663 664 gtp = netdev_priv(dev); 665 666 err = gtp_encap_enable(gtp, data); 667 if (err < 0) 668 return err; 669 670 if (!data[IFLA_GTP_PDP_HASHSIZE]) { 671 hashsize = 1024; 672 } else { 673 hashsize = nla_get_u32(data[IFLA_GTP_PDP_HASHSIZE]); 674 if (!hashsize) 675 hashsize = 1024; 676 } 677 678 err = gtp_hashtable_new(gtp, hashsize); 679 if (err < 0) 680 goto out_encap; 681 682 err = register_netdevice(dev); 683 if (err < 0) { 684 netdev_dbg(dev, "failed to register new netdev %d\n", err); 685 goto out_hashtable; 686 } 687 688 gn = net_generic(dev_net(dev), gtp_net_id); 689 list_add_rcu(>p->list, &gn->gtp_dev_list); 690 dev->priv_destructor = gtp_destructor; 691 692 netdev_dbg(dev, "registered new GTP interface\n"); 693 694 return 0; 695 696 out_hashtable: 697 kfree(gtp->addr_hash); 698 kfree(gtp->tid_hash); 699 out_encap: 700 gtp_encap_disable(gtp); 701 return err; 702 } 703 704 static void gtp_dellink(struct net_device *dev, struct list_head *head) 705 { 706 struct gtp_dev *gtp = netdev_priv(dev); 707 struct pdp_ctx *pctx; 708 int i; 709 710 for (i = 0; i < gtp->hash_size; i++) 711 hlist_for_each_entry_rcu(pctx, >p->tid_hash[i], hlist_tid) 712 pdp_context_delete(pctx); 713 714 list_del_rcu(>p->list); 715 unregister_netdevice_queue(dev, head); 716 } 717 718 static const struct nla_policy gtp_policy[IFLA_GTP_MAX + 1] = { 719 [IFLA_GTP_FD0] = { .type = NLA_U32 }, 720 [IFLA_GTP_FD1] = { .type = NLA_U32 }, 721 [IFLA_GTP_PDP_HASHSIZE] = { .type = NLA_U32 }, 722 [IFLA_GTP_ROLE] = { .type = NLA_U32 }, 723 }; 724 725 static int gtp_validate(struct nlattr *tb[], struct nlattr *data[], 726 struct netlink_ext_ack *extack) 727 { 728 if (!data) 729 return -EINVAL; 730 731 return 0; 732 } 733 734 static size_t gtp_get_size(const struct net_device *dev) 735 { 736 return nla_total_size(sizeof(__u32)); /* IFLA_GTP_PDP_HASHSIZE */ 737 } 738 739 static int gtp_fill_info(struct sk_buff *skb, const struct net_device *dev) 740 { 741 struct gtp_dev *gtp = netdev_priv(dev); 742 743 if (nla_put_u32(skb, IFLA_GTP_PDP_HASHSIZE, gtp->hash_size)) 744 goto nla_put_failure; 745 746 return 0; 747 748 nla_put_failure: 749 return -EMSGSIZE; 750 } 751 752 static struct rtnl_link_ops gtp_link_ops __read_mostly = { 753 .kind = "gtp", 754 .maxtype = IFLA_GTP_MAX, 755 .policy = gtp_policy, 756 .priv_size = sizeof(struct gtp_dev), 757 .setup = gtp_link_setup, 758 .validate = gtp_validate, 759 .newlink = gtp_newlink, 760 .dellink = gtp_dellink, 761 .get_size = gtp_get_size, 762 .fill_info = gtp_fill_info, 763 }; 764 765 static int gtp_hashtable_new(struct gtp_dev *gtp, int hsize) 766 { 767 int i; 768 769 gtp->addr_hash = kmalloc_array(hsize, sizeof(struct hlist_head), 770 GFP_KERNEL | __GFP_NOWARN); 771 if (gtp->addr_hash == NULL) 772 return -ENOMEM; 773 774 gtp->tid_hash = kmalloc_array(hsize, sizeof(struct hlist_head), 775 GFP_KERNEL | __GFP_NOWARN); 776 if (gtp->tid_hash == NULL) 777 goto err1; 778 779 gtp->hash_size = hsize; 780 781 for (i = 0; i < hsize; i++) { 782 INIT_HLIST_HEAD(>p->addr_hash[i]); 783 INIT_HLIST_HEAD(>p->tid_hash[i]); 784 } 785 return 0; 786 err1: 787 kfree(gtp->addr_hash); 788 return -ENOMEM; 789 } 790 791 static struct sock *gtp_encap_enable_socket(int fd, int type, 792 struct gtp_dev *gtp) 793 { 794 struct udp_tunnel_sock_cfg tuncfg = {NULL}; 795 struct socket *sock; 796 struct sock *sk; 797 int err; 798 799 pr_debug("enable gtp on %d, %d\n", fd, type); 800 801 sock = sockfd_lookup(fd, &err); 802 if (!sock) { 803 pr_debug("gtp socket fd=%d not found\n", fd); 804 return NULL; 805 } 806 807 sk = sock->sk; 808 if (sk->sk_protocol != IPPROTO_UDP || 809 sk->sk_type != SOCK_DGRAM || 810 (sk->sk_family != AF_INET && sk->sk_family != AF_INET6)) { 811 pr_debug("socket fd=%d not UDP\n", fd); 812 sk = ERR_PTR(-EINVAL); 813 goto out_sock; 814 } 815 816 lock_sock(sk); 817 if (sk->sk_user_data) { 818 sk = ERR_PTR(-EBUSY); 819 goto out_rel_sock; 820 } 821 822 sock_hold(sk); 823 824 tuncfg.sk_user_data = gtp; 825 tuncfg.encap_type = type; 826 tuncfg.encap_rcv = gtp_encap_recv; 827 tuncfg.encap_destroy = gtp_encap_destroy; 828 829 setup_udp_tunnel_sock(sock_net(sock->sk), sock, &tuncfg); 830 831 out_rel_sock: 832 release_sock(sock->sk); 833 out_sock: 834 sockfd_put(sock); 835 return sk; 836 } 837 838 static int gtp_encap_enable(struct gtp_dev *gtp, struct nlattr *data[]) 839 { 840 struct sock *sk1u = NULL; 841 struct sock *sk0 = NULL; 842 unsigned int role = GTP_ROLE_GGSN; 843 844 if (data[IFLA_GTP_FD0]) { 845 u32 fd0 = nla_get_u32(data[IFLA_GTP_FD0]); 846 847 sk0 = gtp_encap_enable_socket(fd0, UDP_ENCAP_GTP0, gtp); 848 if (IS_ERR(sk0)) 849 return PTR_ERR(sk0); 850 } 851 852 if (data[IFLA_GTP_FD1]) { 853 u32 fd1 = nla_get_u32(data[IFLA_GTP_FD1]); 854 855 sk1u = gtp_encap_enable_socket(fd1, UDP_ENCAP_GTP1U, gtp); 856 if (IS_ERR(sk1u)) { 857 gtp_encap_disable_sock(sk0); 858 return PTR_ERR(sk1u); 859 } 860 } 861 862 if (data[IFLA_GTP_ROLE]) { 863 role = nla_get_u32(data[IFLA_GTP_ROLE]); 864 if (role > GTP_ROLE_SGSN) { 865 gtp_encap_disable_sock(sk0); 866 gtp_encap_disable_sock(sk1u); 867 return -EINVAL; 868 } 869 } 870 871 gtp->sk0 = sk0; 872 gtp->sk1u = sk1u; 873 gtp->role = role; 874 875 return 0; 876 } 877 878 static struct gtp_dev *gtp_find_dev(struct net *src_net, struct nlattr *nla[]) 879 { 880 struct gtp_dev *gtp = NULL; 881 struct net_device *dev; 882 struct net *net; 883 884 /* Examine the link attributes and figure out which network namespace 885 * we are talking about. 886 */ 887 if (nla[GTPA_NET_NS_FD]) 888 net = get_net_ns_by_fd(nla_get_u32(nla[GTPA_NET_NS_FD])); 889 else 890 net = get_net(src_net); 891 892 if (IS_ERR(net)) 893 return NULL; 894 895 /* Check if there's an existing gtpX device to configure */ 896 dev = dev_get_by_index_rcu(net, nla_get_u32(nla[GTPA_LINK])); 897 if (dev && dev->netdev_ops == >p_netdev_ops) 898 gtp = netdev_priv(dev); 899 900 put_net(net); 901 return gtp; 902 } 903 904 static void ipv4_pdp_fill(struct pdp_ctx *pctx, struct genl_info *info) 905 { 906 pctx->gtp_version = nla_get_u32(info->attrs[GTPA_VERSION]); 907 pctx->af = AF_INET; 908 pctx->peer_addr_ip4.s_addr = 909 nla_get_be32(info->attrs[GTPA_PEER_ADDRESS]); 910 pctx->ms_addr_ip4.s_addr = 911 nla_get_be32(info->attrs[GTPA_MS_ADDRESS]); 912 913 switch (pctx->gtp_version) { 914 case GTP_V0: 915 /* According to TS 09.60, sections 7.5.1 and 7.5.2, the flow 916 * label needs to be the same for uplink and downlink packets, 917 * so let's annotate this. 918 */ 919 pctx->u.v0.tid = nla_get_u64(info->attrs[GTPA_TID]); 920 pctx->u.v0.flow = nla_get_u16(info->attrs[GTPA_FLOW]); 921 break; 922 case GTP_V1: 923 pctx->u.v1.i_tei = nla_get_u32(info->attrs[GTPA_I_TEI]); 924 pctx->u.v1.o_tei = nla_get_u32(info->attrs[GTPA_O_TEI]); 925 break; 926 default: 927 break; 928 } 929 } 930 931 static int gtp_pdp_add(struct gtp_dev *gtp, struct sock *sk, 932 struct genl_info *info) 933 { 934 struct pdp_ctx *pctx, *pctx_tid = NULL; 935 struct net_device *dev = gtp->dev; 936 u32 hash_ms, hash_tid = 0; 937 unsigned int version; 938 bool found = false; 939 __be32 ms_addr; 940 941 ms_addr = nla_get_be32(info->attrs[GTPA_MS_ADDRESS]); 942 hash_ms = ipv4_hashfn(ms_addr) % gtp->hash_size; 943 version = nla_get_u32(info->attrs[GTPA_VERSION]); 944 945 pctx = ipv4_pdp_find(gtp, ms_addr); 946 if (pctx) 947 found = true; 948 if (version == GTP_V0) 949 pctx_tid = gtp0_pdp_find(gtp, 950 nla_get_u64(info->attrs[GTPA_TID])); 951 else if (version == GTP_V1) 952 pctx_tid = gtp1_pdp_find(gtp, 953 nla_get_u32(info->attrs[GTPA_I_TEI])); 954 if (pctx_tid) 955 found = true; 956 957 if (found) { 958 if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) 959 return -EEXIST; 960 if (info->nlhdr->nlmsg_flags & NLM_F_REPLACE) 961 return -EOPNOTSUPP; 962 963 if (pctx && pctx_tid) 964 return -EEXIST; 965 if (!pctx) 966 pctx = pctx_tid; 967 968 ipv4_pdp_fill(pctx, info); 969 970 if (pctx->gtp_version == GTP_V0) 971 netdev_dbg(dev, "GTPv0-U: update tunnel id = %llx (pdp %p)\n", 972 pctx->u.v0.tid, pctx); 973 else if (pctx->gtp_version == GTP_V1) 974 netdev_dbg(dev, "GTPv1-U: update tunnel id = %x/%x (pdp %p)\n", 975 pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx); 976 977 return 0; 978 979 } 980 981 pctx = kmalloc(sizeof(*pctx), GFP_ATOMIC); 982 if (pctx == NULL) 983 return -ENOMEM; 984 985 sock_hold(sk); 986 pctx->sk = sk; 987 pctx->dev = gtp->dev; 988 ipv4_pdp_fill(pctx, info); 989 atomic_set(&pctx->tx_seq, 0); 990 991 switch (pctx->gtp_version) { 992 case GTP_V0: 993 /* TS 09.60: "The flow label identifies unambiguously a GTP 994 * flow.". We use the tid for this instead, I cannot find a 995 * situation in which this doesn't unambiguosly identify the 996 * PDP context. 997 */ 998 hash_tid = gtp0_hashfn(pctx->u.v0.tid) % gtp->hash_size; 999 break; 1000 case GTP_V1: 1001 hash_tid = gtp1u_hashfn(pctx->u.v1.i_tei) % gtp->hash_size; 1002 break; 1003 } 1004 1005 hlist_add_head_rcu(&pctx->hlist_addr, >p->addr_hash[hash_ms]); 1006 hlist_add_head_rcu(&pctx->hlist_tid, >p->tid_hash[hash_tid]); 1007 1008 switch (pctx->gtp_version) { 1009 case GTP_V0: 1010 netdev_dbg(dev, "GTPv0-U: new PDP ctx id=%llx ssgn=%pI4 ms=%pI4 (pdp=%p)\n", 1011 pctx->u.v0.tid, &pctx->peer_addr_ip4, 1012 &pctx->ms_addr_ip4, pctx); 1013 break; 1014 case GTP_V1: 1015 netdev_dbg(dev, "GTPv1-U: new PDP ctx id=%x/%x ssgn=%pI4 ms=%pI4 (pdp=%p)\n", 1016 pctx->u.v1.i_tei, pctx->u.v1.o_tei, 1017 &pctx->peer_addr_ip4, &pctx->ms_addr_ip4, pctx); 1018 break; 1019 } 1020 1021 return 0; 1022 } 1023 1024 static void pdp_context_free(struct rcu_head *head) 1025 { 1026 struct pdp_ctx *pctx = container_of(head, struct pdp_ctx, rcu_head); 1027 1028 sock_put(pctx->sk); 1029 kfree(pctx); 1030 } 1031 1032 static void pdp_context_delete(struct pdp_ctx *pctx) 1033 { 1034 hlist_del_rcu(&pctx->hlist_tid); 1035 hlist_del_rcu(&pctx->hlist_addr); 1036 call_rcu(&pctx->rcu_head, pdp_context_free); 1037 } 1038 1039 static int gtp_genl_new_pdp(struct sk_buff *skb, struct genl_info *info) 1040 { 1041 unsigned int version; 1042 struct gtp_dev *gtp; 1043 struct sock *sk; 1044 int err; 1045 1046 if (!info->attrs[GTPA_VERSION] || 1047 !info->attrs[GTPA_LINK] || 1048 !info->attrs[GTPA_PEER_ADDRESS] || 1049 !info->attrs[GTPA_MS_ADDRESS]) 1050 return -EINVAL; 1051 1052 version = nla_get_u32(info->attrs[GTPA_VERSION]); 1053 1054 switch (version) { 1055 case GTP_V0: 1056 if (!info->attrs[GTPA_TID] || 1057 !info->attrs[GTPA_FLOW]) 1058 return -EINVAL; 1059 break; 1060 case GTP_V1: 1061 if (!info->attrs[GTPA_I_TEI] || 1062 !info->attrs[GTPA_O_TEI]) 1063 return -EINVAL; 1064 break; 1065 1066 default: 1067 return -EINVAL; 1068 } 1069 1070 rtnl_lock(); 1071 rcu_read_lock(); 1072 1073 gtp = gtp_find_dev(sock_net(skb->sk), info->attrs); 1074 if (!gtp) { 1075 err = -ENODEV; 1076 goto out_unlock; 1077 } 1078 1079 if (version == GTP_V0) 1080 sk = gtp->sk0; 1081 else if (version == GTP_V1) 1082 sk = gtp->sk1u; 1083 else 1084 sk = NULL; 1085 1086 if (!sk) { 1087 err = -ENODEV; 1088 goto out_unlock; 1089 } 1090 1091 err = gtp_pdp_add(gtp, sk, info); 1092 1093 out_unlock: 1094 rcu_read_unlock(); 1095 rtnl_unlock(); 1096 return err; 1097 } 1098 1099 static struct pdp_ctx *gtp_find_pdp_by_link(struct net *net, 1100 struct nlattr *nla[]) 1101 { 1102 struct gtp_dev *gtp; 1103 1104 gtp = gtp_find_dev(net, nla); 1105 if (!gtp) 1106 return ERR_PTR(-ENODEV); 1107 1108 if (nla[GTPA_MS_ADDRESS]) { 1109 __be32 ip = nla_get_be32(nla[GTPA_MS_ADDRESS]); 1110 1111 return ipv4_pdp_find(gtp, ip); 1112 } else if (nla[GTPA_VERSION]) { 1113 u32 gtp_version = nla_get_u32(nla[GTPA_VERSION]); 1114 1115 if (gtp_version == GTP_V0 && nla[GTPA_TID]) 1116 return gtp0_pdp_find(gtp, nla_get_u64(nla[GTPA_TID])); 1117 else if (gtp_version == GTP_V1 && nla[GTPA_I_TEI]) 1118 return gtp1_pdp_find(gtp, nla_get_u32(nla[GTPA_I_TEI])); 1119 } 1120 1121 return ERR_PTR(-EINVAL); 1122 } 1123 1124 static struct pdp_ctx *gtp_find_pdp(struct net *net, struct nlattr *nla[]) 1125 { 1126 struct pdp_ctx *pctx; 1127 1128 if (nla[GTPA_LINK]) 1129 pctx = gtp_find_pdp_by_link(net, nla); 1130 else 1131 pctx = ERR_PTR(-EINVAL); 1132 1133 if (!pctx) 1134 pctx = ERR_PTR(-ENOENT); 1135 1136 return pctx; 1137 } 1138 1139 static int gtp_genl_del_pdp(struct sk_buff *skb, struct genl_info *info) 1140 { 1141 struct pdp_ctx *pctx; 1142 int err = 0; 1143 1144 if (!info->attrs[GTPA_VERSION]) 1145 return -EINVAL; 1146 1147 rcu_read_lock(); 1148 1149 pctx = gtp_find_pdp(sock_net(skb->sk), info->attrs); 1150 if (IS_ERR(pctx)) { 1151 err = PTR_ERR(pctx); 1152 goto out_unlock; 1153 } 1154 1155 if (pctx->gtp_version == GTP_V0) 1156 netdev_dbg(pctx->dev, "GTPv0-U: deleting tunnel id = %llx (pdp %p)\n", 1157 pctx->u.v0.tid, pctx); 1158 else if (pctx->gtp_version == GTP_V1) 1159 netdev_dbg(pctx->dev, "GTPv1-U: deleting tunnel id = %x/%x (pdp %p)\n", 1160 pctx->u.v1.i_tei, pctx->u.v1.o_tei, pctx); 1161 1162 pdp_context_delete(pctx); 1163 1164 out_unlock: 1165 rcu_read_unlock(); 1166 return err; 1167 } 1168 1169 static struct genl_family gtp_genl_family; 1170 1171 static int gtp_genl_fill_info(struct sk_buff *skb, u32 snd_portid, u32 snd_seq, 1172 u32 type, struct pdp_ctx *pctx) 1173 { 1174 void *genlh; 1175 1176 genlh = genlmsg_put(skb, snd_portid, snd_seq, >p_genl_family, 0, 1177 type); 1178 if (genlh == NULL) 1179 goto nlmsg_failure; 1180 1181 if (nla_put_u32(skb, GTPA_VERSION, pctx->gtp_version) || 1182 nla_put_be32(skb, GTPA_PEER_ADDRESS, pctx->peer_addr_ip4.s_addr) || 1183 nla_put_be32(skb, GTPA_MS_ADDRESS, pctx->ms_addr_ip4.s_addr)) 1184 goto nla_put_failure; 1185 1186 switch (pctx->gtp_version) { 1187 case GTP_V0: 1188 if (nla_put_u64_64bit(skb, GTPA_TID, pctx->u.v0.tid, GTPA_PAD) || 1189 nla_put_u16(skb, GTPA_FLOW, pctx->u.v0.flow)) 1190 goto nla_put_failure; 1191 break; 1192 case GTP_V1: 1193 if (nla_put_u32(skb, GTPA_I_TEI, pctx->u.v1.i_tei) || 1194 nla_put_u32(skb, GTPA_O_TEI, pctx->u.v1.o_tei)) 1195 goto nla_put_failure; 1196 break; 1197 } 1198 genlmsg_end(skb, genlh); 1199 return 0; 1200 1201 nlmsg_failure: 1202 nla_put_failure: 1203 genlmsg_cancel(skb, genlh); 1204 return -EMSGSIZE; 1205 } 1206 1207 static int gtp_genl_get_pdp(struct sk_buff *skb, struct genl_info *info) 1208 { 1209 struct pdp_ctx *pctx = NULL; 1210 struct sk_buff *skb2; 1211 int err; 1212 1213 if (!info->attrs[GTPA_VERSION]) 1214 return -EINVAL; 1215 1216 rcu_read_lock(); 1217 1218 pctx = gtp_find_pdp(sock_net(skb->sk), info->attrs); 1219 if (IS_ERR(pctx)) { 1220 err = PTR_ERR(pctx); 1221 goto err_unlock; 1222 } 1223 1224 skb2 = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC); 1225 if (skb2 == NULL) { 1226 err = -ENOMEM; 1227 goto err_unlock; 1228 } 1229 1230 err = gtp_genl_fill_info(skb2, NETLINK_CB(skb).portid, 1231 info->snd_seq, info->nlhdr->nlmsg_type, pctx); 1232 if (err < 0) 1233 goto err_unlock_free; 1234 1235 rcu_read_unlock(); 1236 return genlmsg_unicast(genl_info_net(info), skb2, info->snd_portid); 1237 1238 err_unlock_free: 1239 kfree_skb(skb2); 1240 err_unlock: 1241 rcu_read_unlock(); 1242 return err; 1243 } 1244 1245 static int gtp_genl_dump_pdp(struct sk_buff *skb, 1246 struct netlink_callback *cb) 1247 { 1248 struct gtp_dev *last_gtp = (struct gtp_dev *)cb->args[2], *gtp; 1249 int i, j, bucket = cb->args[0], skip = cb->args[1]; 1250 struct net *net = sock_net(skb->sk); 1251 struct pdp_ctx *pctx; 1252 struct gtp_net *gn; 1253 1254 gn = net_generic(net, gtp_net_id); 1255 1256 if (cb->args[4]) 1257 return 0; 1258 1259 rcu_read_lock(); 1260 list_for_each_entry_rcu(gtp, &gn->gtp_dev_list, list) { 1261 if (last_gtp && last_gtp != gtp) 1262 continue; 1263 else 1264 last_gtp = NULL; 1265 1266 for (i = bucket; i < gtp->hash_size; i++) { 1267 j = 0; 1268 hlist_for_each_entry_rcu(pctx, >p->tid_hash[i], 1269 hlist_tid) { 1270 if (j >= skip && 1271 gtp_genl_fill_info(skb, 1272 NETLINK_CB(cb->skb).portid, 1273 cb->nlh->nlmsg_seq, 1274 cb->nlh->nlmsg_type, pctx)) { 1275 cb->args[0] = i; 1276 cb->args[1] = j; 1277 cb->args[2] = (unsigned long)gtp; 1278 goto out; 1279 } 1280 j++; 1281 } 1282 skip = 0; 1283 } 1284 bucket = 0; 1285 } 1286 cb->args[4] = 1; 1287 out: 1288 rcu_read_unlock(); 1289 return skb->len; 1290 } 1291 1292 static const struct nla_policy gtp_genl_policy[GTPA_MAX + 1] = { 1293 [GTPA_LINK] = { .type = NLA_U32, }, 1294 [GTPA_VERSION] = { .type = NLA_U32, }, 1295 [GTPA_TID] = { .type = NLA_U64, }, 1296 [GTPA_PEER_ADDRESS] = { .type = NLA_U32, }, 1297 [GTPA_MS_ADDRESS] = { .type = NLA_U32, }, 1298 [GTPA_FLOW] = { .type = NLA_U16, }, 1299 [GTPA_NET_NS_FD] = { .type = NLA_U32, }, 1300 [GTPA_I_TEI] = { .type = NLA_U32, }, 1301 [GTPA_O_TEI] = { .type = NLA_U32, }, 1302 }; 1303 1304 static const struct genl_ops gtp_genl_ops[] = { 1305 { 1306 .cmd = GTP_CMD_NEWPDP, 1307 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1308 .doit = gtp_genl_new_pdp, 1309 .flags = GENL_ADMIN_PERM, 1310 }, 1311 { 1312 .cmd = GTP_CMD_DELPDP, 1313 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1314 .doit = gtp_genl_del_pdp, 1315 .flags = GENL_ADMIN_PERM, 1316 }, 1317 { 1318 .cmd = GTP_CMD_GETPDP, 1319 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 1320 .doit = gtp_genl_get_pdp, 1321 .dumpit = gtp_genl_dump_pdp, 1322 .flags = GENL_ADMIN_PERM, 1323 }, 1324 }; 1325 1326 static struct genl_family gtp_genl_family __ro_after_init = { 1327 .name = "gtp", 1328 .version = 0, 1329 .hdrsize = 0, 1330 .maxattr = GTPA_MAX, 1331 .policy = gtp_genl_policy, 1332 .netnsok = true, 1333 .module = THIS_MODULE, 1334 .ops = gtp_genl_ops, 1335 .n_ops = ARRAY_SIZE(gtp_genl_ops), 1336 }; 1337 1338 static int __net_init gtp_net_init(struct net *net) 1339 { 1340 struct gtp_net *gn = net_generic(net, gtp_net_id); 1341 1342 INIT_LIST_HEAD(&gn->gtp_dev_list); 1343 return 0; 1344 } 1345 1346 static void __net_exit gtp_net_exit(struct net *net) 1347 { 1348 struct gtp_net *gn = net_generic(net, gtp_net_id); 1349 struct gtp_dev *gtp; 1350 LIST_HEAD(list); 1351 1352 rtnl_lock(); 1353 list_for_each_entry(gtp, &gn->gtp_dev_list, list) 1354 gtp_dellink(gtp->dev, &list); 1355 1356 unregister_netdevice_many(&list); 1357 rtnl_unlock(); 1358 } 1359 1360 static struct pernet_operations gtp_net_ops = { 1361 .init = gtp_net_init, 1362 .exit = gtp_net_exit, 1363 .id = >p_net_id, 1364 .size = sizeof(struct gtp_net), 1365 }; 1366 1367 static int __init gtp_init(void) 1368 { 1369 int err; 1370 1371 get_random_bytes(>p_h_initval, sizeof(gtp_h_initval)); 1372 1373 err = rtnl_link_register(>p_link_ops); 1374 if (err < 0) 1375 goto error_out; 1376 1377 err = genl_register_family(>p_genl_family); 1378 if (err < 0) 1379 goto unreg_rtnl_link; 1380 1381 err = register_pernet_subsys(>p_net_ops); 1382 if (err < 0) 1383 goto unreg_genl_family; 1384 1385 pr_info("GTP module loaded (pdp ctx size %zd bytes)\n", 1386 sizeof(struct pdp_ctx)); 1387 return 0; 1388 1389 unreg_genl_family: 1390 genl_unregister_family(>p_genl_family); 1391 unreg_rtnl_link: 1392 rtnl_link_unregister(>p_link_ops); 1393 error_out: 1394 pr_err("error loading GTP module loaded\n"); 1395 return err; 1396 } 1397 late_initcall(gtp_init); 1398 1399 static void __exit gtp_fini(void) 1400 { 1401 genl_unregister_family(>p_genl_family); 1402 rtnl_link_unregister(>p_link_ops); 1403 unregister_pernet_subsys(>p_net_ops); 1404 1405 pr_info("GTP module unloaded\n"); 1406 } 1407 module_exit(gtp_fini); 1408 1409 MODULE_LICENSE("GPL"); 1410 MODULE_AUTHOR("Harald Welte <hwelte@sysmocom.de>"); 1411 MODULE_DESCRIPTION("Interface driver for GTP encapsulated traffic"); 1412 MODULE_ALIAS_RTNL_LINK("gtp"); 1413 MODULE_ALIAS_GENL_FAMILY("gtp"); 1414