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