net/ipv4/ip_gre.c

   1 /*
   2  *      Linux NET3:     GRE over IP protocol decoder.
   3  *
   4  *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License
   8  *      as published by the Free Software Foundation; either version
   9  *      2 of the License, or (at your option) any later version.
  10  *
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/capability.h>
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/slab.h>
  20 #include <asm/uaccess.h>
  21 #include <linux/skbuff.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/in.h>
  24 #include <linux/tcp.h>
  25 #include <linux/udp.h>
  26 #include <linux/if_arp.h>
  27 #include <linux/if_vlan.h>
  28 #include <linux/init.h>
  29 #include <linux/in6.h>
  30 #include <linux/inetdevice.h>
  31 #include <linux/igmp.h>
  32 #include <linux/netfilter_ipv4.h>
  33 #include <linux/etherdevice.h>
  34 #include <linux/if_ether.h>
  35
  36 #include <net/sock.h>
  37 #include <net/ip.h>
  38 #include <net/icmp.h>
  39 #include <net/protocol.h>
  40 #include <net/ip_tunnels.h>
  41 #include <net/arp.h>
  42 #include <net/checksum.h>
  43 #include <net/dsfield.h>
  44 #include <net/inet_ecn.h>
  45 #include <net/xfrm.h>
  46 #include <net/net_namespace.h>
  47 #include <net/netns/generic.h>
  48 #include <net/rtnetlink.h>
  49 #include <net/gre.h>
  50 #include <net/dst_metadata.h>
  51
  52 /*
  53    Problems & solutions
  54    --------------------
  55
  56    1. The most important issue is detecting local dead loops.
  57    They would cause complete host lockup in transmit, which
  58    would be "resolved" by stack overflow or, if queueing is enabled,
  59    with infinite looping in net_bh.
  60
  61    We cannot track such dead loops during route installation,
  62    it is infeasible task. The most general solutions would be
  63    to keep skb->encapsulation counter (sort of local ttl),
  64    and silently drop packet when it expires. It is a good
  65    solution, but it supposes maintaining new variable in ALL
  66    skb, even if no tunneling is used.
  67
  68    Current solution: xmit_recursion breaks dead loops. This is a percpu
  69    counter, since when we enter the first ndo_xmit(), cpu migration is
  70    forbidden. We force an exit if this counter reaches RECURSION_LIMIT
  71
  72    2. Networking dead loops would not kill routers, but would really
  73    kill network. IP hop limit plays role of "t->recursion" in this case,
  74    if we copy it from packet being encapsulated to upper header.
  75    It is very good solution, but it introduces two problems:
  76
  77    - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
  78      do not work over tunnels.
  79    - traceroute does not work. I planned to relay ICMP from tunnel,
  80      so that this problem would be solved and traceroute output
  81      would even more informative. This idea appeared to be wrong:
  82      only Linux complies to rfc1812 now (yes, guys, Linux is the only
  83      true router now :-)), all routers (at least, in neighbourhood of mine)
  84      return only 8 bytes of payload. It is the end.
  85
  86    Hence, if we want that OSPF worked or traceroute said something reasonable,
  87    we should search for another solution.
  88
  89    One of them is to parse packet trying to detect inner encapsulation
  90    made by our node. It is difficult or even impossible, especially,
  91    taking into account fragmentation. TO be short, ttl is not solution at all.
  92
  93    Current solution: The solution was UNEXPECTEDLY SIMPLE.
  94    We force DF flag on tunnels with preconfigured hop limit,
  95    that is ALL. :-) Well, it does not remove the problem completely,
  96    but exponential growth of network traffic is changed to linear
  97    (branches, that exceed pmtu are pruned) and tunnel mtu
  98    rapidly degrades to value <68, where looping stops.
  99    Yes, it is not good if there exists a router in the loop,
 100    which does not force DF, even when encapsulating packets have DF set.
 101    But it is not our problem! Nobody could accuse us, we made
 102    all that we could make. Even if it is your gated who injected
 103    fatal route to network, even if it were you who configured
 104    fatal static route: you are innocent. :-)
 105
 106    Alexey Kuznetsov.
 107  */
 108
 109 static bool log_ecn_error = true;
 110 module_param(log_ecn_error, bool, 0644);
 111 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 112
 113 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
 114 static int ipgre_tunnel_init(struct net_device *dev);
 115
 116 static int ipgre_net_id __read_mostly;
 117 static int gre_tap_net_id __read_mostly;
 118
 119 static void ipgre_err(struct sk_buff *skb, u32 info,
 120                       const struct tnl_ptk_info *tpi)
 121 {
 122
 123         /* All the routers (except for Linux) return only
 124            8 bytes of packet payload. It means, that precise relaying of
 125            ICMP in the real Internet is absolutely infeasible.
 126
 127            Moreover, Cisco "wise men" put GRE key to the third word
 128            in GRE header. It makes impossible maintaining even soft
 129            state for keyed GRE tunnels with enabled checksum. Tell
 130            them "thank you".
 131
 132            Well, I wonder, rfc1812 was written by Cisco employee,
 133            what the hell these idiots break standards established
 134            by themselves???
 135            */
 136         struct net *net = dev_net(skb->dev);
 137         struct ip_tunnel_net *itn;
 138         const struct iphdr *iph;
 139         const int type = icmp_hdr(skb)->type;
 140         const int code = icmp_hdr(skb)->code;
 141         unsigned int data_len = 0;
 142         struct ip_tunnel *t;
 143
 144         switch (type) {
 145         default:
 146         case ICMP_PARAMETERPROB:
 147                 return;
 148
 149         case ICMP_DEST_UNREACH:
 150                 switch (code) {
 151                 case ICMP_SR_FAILED:
 152                 case ICMP_PORT_UNREACH:
 153                         /* Impossible event. */
 154                         return;
 155                 default:
 156                         /* All others are translated to HOST_UNREACH.
 157                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 158                            I believe they are just ether pollution. --ANK
 159                          */
 160                         break;
 161                 }
 162                 break;
 163
 164         case ICMP_TIME_EXCEEDED:
 165                 if (code != ICMP_EXC_TTL)
 166                         return;
 167                 data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
 168                 break;
 169
 170         case ICMP_REDIRECT:
 171                 break;
 172         }
 173
 174         if (tpi->proto == htons(ETH_P_TEB))
 175                 itn = net_generic(net, gre_tap_net_id);
 176         else
 177                 itn = net_generic(net, ipgre_net_id);
 178
 179         iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
 180         t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 181                              iph->daddr, iph->saddr, tpi->key);
 182
 183         if (!t)
 184                 return;
 185
 186 #if IS_ENABLED(CONFIG_IPV6)
 187        if (tpi->proto == htons(ETH_P_IPV6) &&
 188            !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len,
 189                                        type, data_len))
 190                return;
 191 #endif
 192
 193         if (t->parms.iph.daddr == 0 ||
 194             ipv4_is_multicast(t->parms.iph.daddr))
 195                 return;
 196
 197         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 198                 return;
 199
 200         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 201                 t->err_count++;
 202         else
 203                 t->err_count = 1;
 204         t->err_time = jiffies;
 205 }
 206
 207 static void gre_err(struct sk_buff *skb, u32 info)
 208 {
 209         /* All the routers (except for Linux) return only
 210          * 8 bytes of packet payload. It means, that precise relaying of
 211          * ICMP in the real Internet is absolutely infeasible.
 212          *
 213          * Moreover, Cisco "wise men" put GRE key to the third word
 214          * in GRE header. It makes impossible maintaining even soft
 215          * state for keyed
 216          * GRE tunnels with enabled checksum. Tell them "thank you".
 217          *
 218          * Well, I wonder, rfc1812 was written by Cisco employee,
 219          * what the hell these idiots break standards established
 220          * by themselves???
 221          */
 222
 223         const struct iphdr *iph = (struct iphdr *)skb->data;
 224         const int type = icmp_hdr(skb)->type;
 225         const int code = icmp_hdr(skb)->code;
 226         struct tnl_ptk_info tpi;
 227         bool csum_err = false;
 228
 229         if (gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP),
 230                              iph->ihl * 4) < 0) {
 231                 if (!csum_err)          /* ignore csum errors. */
 232                         return;
 233         }
 234
 235         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 236                 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
 237                                  skb->dev->ifindex, 0, IPPROTO_GRE, 0);
 238                 return;
 239         }
 240         if (type == ICMP_REDIRECT) {
 241                 ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0,
 242                               IPPROTO_GRE, 0);
 243                 return;
 244         }
 245
 246         ipgre_err(skb, info, &tpi);
 247 }
 248
 249 static __be64 key_to_tunnel_id(__be32 key)
 250 {
 251 #ifdef __BIG_ENDIAN
 252         return (__force __be64)((__force u32)key);
 253 #else
 254         return (__force __be64)((__force u64)key << 32);
 255 #endif
 256 }
 257
 258 /* Returns the least-significant 32 bits of a __be64. */
 259 static __be32 tunnel_id_to_key(__be64 x)
 260 {
 261 #ifdef __BIG_ENDIAN
 262         return (__force __be32)x;
 263 #else
 264         return (__force __be32)((__force u64)x >> 32);
 265 #endif
 266 }
 267
 268 static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 269                        struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
 270 {
 271         struct metadata_dst *tun_dst = NULL;
 272         const struct iphdr *iph;
 273         struct ip_tunnel *tunnel;
 274
 275         iph = ip_hdr(skb);
 276         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 277                                   iph->saddr, iph->daddr, tpi->key);
 278
 279         if (tunnel) {
 280                 if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
 281                                            raw_proto, false) < 0)
 282                         goto drop;
 283
 284                 if (tunnel->dev->type != ARPHRD_NONE)
 285                         skb_pop_mac_header(skb);
 286                 else
 287                         skb_reset_mac_header(skb);
 288                 if (tunnel->collect_md) {
 289                         __be16 flags;
 290                         __be64 tun_id;
 291
 292                         flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
 293                         tun_id = key_to_tunnel_id(tpi->key);
 294                         tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
 295                         if (!tun_dst)
 296                                 return PACKET_REJECT;
 297                 }
 298
 299                 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
 300                 return PACKET_RCVD;
 301         }
 302         return PACKET_NEXT;
 303
 304 drop:
 305         kfree_skb(skb);
 306         return PACKET_RCVD;
 307 }
 308
 309 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 310                      int hdr_len)
 311 {
 312         struct net *net = dev_net(skb->dev);
 313         struct ip_tunnel_net *itn;
 314         int res;
 315
 316         if (tpi->proto == htons(ETH_P_TEB))
 317                 itn = net_generic(net, gre_tap_net_id);
 318         else
 319                 itn = net_generic(net, ipgre_net_id);
 320
 321         res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
 322         if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
 323                 /* ipgre tunnels in collect metadata mode should receive
 324                  * also ETH_P_TEB traffic.
 325                  */
 326                 itn = net_generic(net, ipgre_net_id);
 327                 res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
 328         }
 329         return res;
 330 }
 331
 332 static int gre_rcv(struct sk_buff *skb)
 333 {
 334         struct tnl_ptk_info tpi;
 335         bool csum_err = false;
 336         int hdr_len;
 337
 338 #ifdef CONFIG_NET_IPGRE_BROADCAST
 339         if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
 340                 /* Looped back packet, drop it! */
 341                 if (rt_is_output_route(skb_rtable(skb)))
 342                         goto drop;
 343         }
 344 #endif
 345
 346         hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
 347         if (hdr_len < 0)
 348                 goto drop;
 349
 350         if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 351                 return 0;
 352
 353         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
 354 drop:
 355         kfree_skb(skb);
 356         return 0;
 357 }
 358
 359 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
 360                        const struct iphdr *tnl_params,
 361                        __be16 proto)
 362 {
 363         struct ip_tunnel *tunnel = netdev_priv(dev);
 364
 365         if (tunnel->parms.o_flags & TUNNEL_SEQ)
 366                 tunnel->o_seqno++;
 367
 368         /* Push GRE header. */
 369         gre_build_header(skb, tunnel->tun_hlen,
 370                          tunnel->parms.o_flags, proto, tunnel->parms.o_key,
 371                          htonl(tunnel->o_seqno));
 372
 373         skb_set_inner_protocol(skb, proto);
 374         ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
 375 }
 376
 377 static int gre_handle_offloads(struct sk_buff *skb, bool csum)
 378 {
 379         return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
 380 }
 381
 382 static struct rtable *gre_get_rt(struct sk_buff *skb,
 383                                  struct net_device *dev,
 384                                  struct flowi4 *fl,
 385                                  const struct ip_tunnel_key *key)
 386 {
 387         struct net *net = dev_net(dev);
 388
 389         memset(fl, 0, sizeof(*fl));
 390         fl->daddr = key->u.ipv4.dst;
 391         fl->saddr = key->u.ipv4.src;
 392         fl->flowi4_tos = RT_TOS(key->tos);
 393         fl->flowi4_mark = skb->mark;
 394         fl->flowi4_proto = IPPROTO_GRE;
 395
 396         return ip_route_output_key(net, fl);
 397 }
 398
 399 static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
 400                         __be16 proto)
 401 {
 402         struct ip_tunnel_info *tun_info;
 403         const struct ip_tunnel_key *key;
 404         struct rtable *rt = NULL;
 405         struct flowi4 fl;
 406         int min_headroom;
 407         int tunnel_hlen;
 408         __be16 df, flags;
 409         bool use_cache;
 410         int err;
 411
 412         tun_info = skb_tunnel_info(skb);
 413         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 414                      ip_tunnel_info_af(tun_info) != AF_INET))
 415                 goto err_free_skb;
 416
 417         key = &tun_info->key;
 418         use_cache = ip_tunnel_dst_cache_usable(skb, tun_info);
 419         if (use_cache)
 420                 rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl.saddr);
 421         if (!rt) {
 422                 rt = gre_get_rt(skb, dev, &fl, key);
 423                 if (IS_ERR(rt))
 424                                 goto err_free_skb;
 425                 if (use_cache)
 426                         dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst,
 427                                           fl.saddr);
 428         }
 429
 430         tunnel_hlen = gre_calc_hlen(key->tun_flags);
 431
 432         min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
 433                         + tunnel_hlen + sizeof(struct iphdr);
 434         if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
 435                 int head_delta = SKB_DATA_ALIGN(min_headroom -
 436                                                 skb_headroom(skb) +
 437                                                 16);
 438                 err = pskb_expand_head(skb, max_t(int, head_delta, 0),
 439                                        0, GFP_ATOMIC);
 440                 if (unlikely(err))
 441                         goto err_free_rt;
 442         }
 443
 444         /* Push Tunnel header. */
 445         if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
 446                 goto err_free_rt;
 447
 448         flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
 449         gre_build_header(skb, tunnel_hlen, flags, proto,
 450                          tunnel_id_to_key(tun_info->key.tun_id), 0);
 451
 452         df = key->tun_flags & TUNNEL_DONT_FRAGMENT ?  htons(IP_DF) : 0;
 453
 454         iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE,
 455                       key->tos, key->ttl, df, false);
 456         return;
 457
 458 err_free_rt:
 459         ip_rt_put(rt);
 460 err_free_skb:
 461         kfree_skb(skb);
 462         dev->stats.tx_dropped++;
 463 }
 464
 465 static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
 466 {
 467         struct ip_tunnel_info *info = skb_tunnel_info(skb);
 468         struct rtable *rt;
 469         struct flowi4 fl4;
 470
 471         if (ip_tunnel_info_af(info) != AF_INET)
 472                 return -EINVAL;
 473
 474         rt = gre_get_rt(skb, dev, &fl4, &info->key);
 475         if (IS_ERR(rt))
 476                 return PTR_ERR(rt);
 477
 478         ip_rt_put(rt);
 479         info->key.u.ipv4.src = fl4.saddr;
 480         return 0;
 481 }
 482
 483 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
 484                               struct net_device *dev)
 485 {
 486         struct ip_tunnel *tunnel = netdev_priv(dev);
 487         const struct iphdr *tnl_params;
 488
 489         if (tunnel->collect_md) {
 490                 gre_fb_xmit(skb, dev, skb->protocol);
 491                 return NETDEV_TX_OK;
 492         }
 493
 494         if (dev->header_ops) {
 495                 /* Need space for new headers */
 496                 if (skb_cow_head(skb, dev->needed_headroom -
 497                                       (tunnel->hlen + sizeof(struct iphdr))))
 498                         goto free_skb;
 499
 500                 tnl_params = (const struct iphdr *)skb->data;
 501
 502                 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
 503                  * to gre header.
 504                  */
 505                 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
 506                 skb_reset_mac_header(skb);
 507         } else {
 508                 if (skb_cow_head(skb, dev->needed_headroom))
 509                         goto free_skb;
 510
 511                 tnl_params = &tunnel->parms.iph;
 512         }
 513
 514         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 515                 goto free_skb;
 516
 517         __gre_xmit(skb, dev, tnl_params, skb->protocol);
 518         return NETDEV_TX_OK;
 519
 520 free_skb:
 521         kfree_skb(skb);
 522         dev->stats.tx_dropped++;
 523         return NETDEV_TX_OK;
 524 }
 525
 526 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
 527                                 struct net_device *dev)
 528 {
 529         struct ip_tunnel *tunnel = netdev_priv(dev);
 530
 531         if (tunnel->collect_md) {
 532                 gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
 533                 return NETDEV_TX_OK;
 534         }
 535
 536         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 537                 goto free_skb;
 538
 539         if (skb_cow_head(skb, dev->needed_headroom))
 540                 goto free_skb;
 541
 542         __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
 543         return NETDEV_TX_OK;
 544
 545 free_skb:
 546         kfree_skb(skb);
 547         dev->stats.tx_dropped++;
 548         return NETDEV_TX_OK;
 549 }
 550
 551 static int ipgre_tunnel_ioctl(struct net_device *dev,
 552                               struct ifreq *ifr, int cmd)
 553 {
 554         int err;
 555         struct ip_tunnel_parm p;
 556
 557         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 558                 return -EFAULT;
 559         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
 560                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
 561                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
 562                     ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
 563                         return -EINVAL;
 564         }
 565         p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
 566         p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
 567
 568         err = ip_tunnel_ioctl(dev, &p, cmd);
 569         if (err)
 570                 return err;
 571
 572         p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags);
 573         p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags);
 574
 575         if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 576                 return -EFAULT;
 577         return 0;
 578 }
 579
 580 /* Nice toy. Unfortunately, useless in real life :-)
 581    It allows to construct virtual multiprotocol broadcast "LAN"
 582    over the Internet, provided multicast routing is tuned.
 583
 584
 585    I have no idea was this bicycle invented before me,
 586    so that I had to set ARPHRD_IPGRE to a random value.
 587    I have an impression, that Cisco could make something similar,
 588    but this feature is apparently missing in IOS<=11.2(8).
 589
 590    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
 591    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
 592
 593    ping -t 255 224.66.66.66
 594
 595    If nobody answers, mbone does not work.
 596
 597    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
 598    ip addr add 10.66.66.<somewhat>/24 dev Universe
 599    ifconfig Universe up
 600    ifconfig Universe add fe80::<Your_real_addr>/10
 601    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
 602    ftp 10.66.66.66
 603    ...
 604    ftp fec0:6666:6666::193.233.7.65
 605    ...
 606  */
 607 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
 608                         unsigned short type,
 609                         const void *daddr, const void *saddr, unsigned int len)
 610 {
 611         struct ip_tunnel *t = netdev_priv(dev);
 612         struct iphdr *iph;
 613         struct gre_base_hdr *greh;
 614
 615         iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
 616         greh = (struct gre_base_hdr *)(iph+1);
 617         greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
 618         greh->protocol = htons(type);
 619
 620         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
 621
 622         /* Set the source hardware address. */
 623         if (saddr)
 624                 memcpy(&iph->saddr, saddr, 4);
 625         if (daddr)
 626                 memcpy(&iph->daddr, daddr, 4);
 627         if (iph->daddr)
 628                 return t->hlen + sizeof(*iph);
 629
 630         return -(t->hlen + sizeof(*iph));
 631 }
 632
 633 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
 634 {
 635         const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
 636         memcpy(haddr, &iph->saddr, 4);
 637         return 4;
 638 }
 639
 640 static const struct header_ops ipgre_header_ops = {
 641         .create = ipgre_header,
 642         .parse  = ipgre_header_parse,
 643 };
 644
 645 #ifdef CONFIG_NET_IPGRE_BROADCAST
 646 static int ipgre_open(struct net_device *dev)
 647 {
 648         struct ip_tunnel *t = netdev_priv(dev);
 649
 650         if (ipv4_is_multicast(t->parms.iph.daddr)) {
 651                 struct flowi4 fl4;
 652                 struct rtable *rt;
 653
 654                 rt = ip_route_output_gre(t->net, &fl4,
 655                                          t->parms.iph.daddr,
 656                                          t->parms.iph.saddr,
 657                                          t->parms.o_key,
 658                                          RT_TOS(t->parms.iph.tos),
 659                                          t->parms.link);
 660                 if (IS_ERR(rt))
 661                         return -EADDRNOTAVAIL;
 662                 dev = rt->dst.dev;
 663                 ip_rt_put(rt);
 664                 if (!__in_dev_get_rtnl(dev))
 665                         return -EADDRNOTAVAIL;
 666                 t->mlink = dev->ifindex;
 667                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
 668         }
 669         return 0;
 670 }
 671
 672 static int ipgre_close(struct net_device *dev)
 673 {
 674         struct ip_tunnel *t = netdev_priv(dev);
 675
 676         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
 677                 struct in_device *in_dev;
 678                 in_dev = inetdev_by_index(t->net, t->mlink);
 679                 if (in_dev)
 680                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 681         }
 682         return 0;
 683 }
 684 #endif
 685
 686 static const struct net_device_ops ipgre_netdev_ops = {
 687         .ndo_init               = ipgre_tunnel_init,
 688         .ndo_uninit             = ip_tunnel_uninit,
 689 #ifdef CONFIG_NET_IPGRE_BROADCAST
 690         .ndo_open               = ipgre_open,
 691         .ndo_stop               = ipgre_close,
 692 #endif
 693         .ndo_start_xmit         = ipgre_xmit,
 694         .ndo_do_ioctl           = ipgre_tunnel_ioctl,
 695         .ndo_change_mtu         = ip_tunnel_change_mtu,
 696         .ndo_get_stats64        = ip_tunnel_get_stats64,
 697         .ndo_get_iflink         = ip_tunnel_get_iflink,
 698 };
 699
 700 #define GRE_FEATURES (NETIF_F_SG |              \
 701                       NETIF_F_FRAGLIST |        \
 702                       NETIF_F_HIGHDMA |         \
 703                       NETIF_F_HW_CSUM)
 704
 705 static void ipgre_tunnel_setup(struct net_device *dev)
 706 {
 707         dev->netdev_ops         = &ipgre_netdev_ops;
 708         dev->type               = ARPHRD_IPGRE;
 709         ip_tunnel_setup(dev, ipgre_net_id);
 710 }
 711
 712 static void __gre_tunnel_init(struct net_device *dev)
 713 {
 714         struct ip_tunnel *tunnel;
 715         int t_hlen;
 716
 717         tunnel = netdev_priv(dev);
 718         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 719         tunnel->parms.iph.protocol = IPPROTO_GRE;
 720
 721         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 722
 723         t_hlen = tunnel->hlen + sizeof(struct iphdr);
 724
 725         dev->needed_headroom    = LL_MAX_HEADER + t_hlen + 4;
 726         dev->mtu                = ETH_DATA_LEN - t_hlen - 4;
 727
 728         dev->features           |= GRE_FEATURES;
 729         dev->hw_features        |= GRE_FEATURES;
 730
 731         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 732                 /* TCP offload with GRE SEQ is not supported, nor
 733                  * can we support 2 levels of outer headers requiring
 734                  * an update.
 735                  */
 736                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 737                     (tunnel->encap.type == TUNNEL_ENCAP_NONE)) {
 738                         dev->features    |= NETIF_F_GSO_SOFTWARE;
 739                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 740                 }
 741
 742                 /* Can use a lockless transmit, unless we generate
 743                  * output sequences
 744                  */
 745                 dev->features |= NETIF_F_LLTX;
 746         }
 747 }
 748
 749 static int ipgre_tunnel_init(struct net_device *dev)
 750 {
 751         struct ip_tunnel *tunnel = netdev_priv(dev);
 752         struct iphdr *iph = &tunnel->parms.iph;
 753
 754         __gre_tunnel_init(dev);
 755
 756         memcpy(dev->dev_addr, &iph->saddr, 4);
 757         memcpy(dev->broadcast, &iph->daddr, 4);
 758
 759         dev->flags              = IFF_NOARP;
 760         netif_keep_dst(dev);
 761         dev->addr_len           = 4;
 762
 763         if (iph->daddr && !tunnel->collect_md) {
 764 #ifdef CONFIG_NET_IPGRE_BROADCAST
 765                 if (ipv4_is_multicast(iph->daddr)) {
 766                         if (!iph->saddr)
 767                                 return -EINVAL;
 768                         dev->flags = IFF_BROADCAST;
 769                         dev->header_ops = &ipgre_header_ops;
 770                 }
 771 #endif
 772         } else if (!tunnel->collect_md) {
 773                 dev->header_ops = &ipgre_header_ops;
 774         }
 775
 776         return ip_tunnel_init(dev);
 777 }
 778
 779 static const struct gre_protocol ipgre_protocol = {
 780         .handler     = gre_rcv,
 781         .err_handler = gre_err,
 782 };
 783
 784 static int __net_init ipgre_init_net(struct net *net)
 785 {
 786         return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
 787 }
 788
 789 static void __net_exit ipgre_exit_net(struct net *net)
 790 {
 791         struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
 792         ip_tunnel_delete_net(itn, &ipgre_link_ops);
 793 }
 794
 795 static struct pernet_operations ipgre_net_ops = {
 796         .init = ipgre_init_net,
 797         .exit = ipgre_exit_net,
 798         .id   = &ipgre_net_id,
 799         .size = sizeof(struct ip_tunnel_net),
 800 };
 801
 802 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
 803 {
 804         __be16 flags;
 805
 806         if (!data)
 807                 return 0;
 808
 809         flags = 0;
 810         if (data[IFLA_GRE_IFLAGS])
 811                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
 812         if (data[IFLA_GRE_OFLAGS])
 813                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
 814         if (flags & (GRE_VERSION|GRE_ROUTING))
 815                 return -EINVAL;
 816
 817         if (data[IFLA_GRE_COLLECT_METADATA] &&
 818             data[IFLA_GRE_ENCAP_TYPE] &&
 819             nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
 820                 return -EINVAL;
 821
 822         return 0;
 823 }
 824
 825 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
 826 {
 827         __be32 daddr;
 828
 829         if (tb[IFLA_ADDRESS]) {
 830                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 831                         return -EINVAL;
 832                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 833                         return -EADDRNOTAVAIL;
 834         }
 835
 836         if (!data)
 837                 goto out;
 838
 839         if (data[IFLA_GRE_REMOTE]) {
 840                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
 841                 if (!daddr)
 842                         return -EINVAL;
 843         }
 844
 845 out:
 846         return ipgre_tunnel_validate(tb, data);
 847 }
 848
 849 static int ipgre_netlink_parms(struct net_device *dev,
 850                                 struct nlattr *data[],
 851                                 struct nlattr *tb[],
 852                                 struct ip_tunnel_parm *parms)
 853 {
 854         struct ip_tunnel *t = netdev_priv(dev);
 855
 856         memset(parms, 0, sizeof(*parms));
 857
 858         parms->iph.protocol = IPPROTO_GRE;
 859
 860         if (!data)
 861                 return 0;
 862
 863         if (data[IFLA_GRE_LINK])
 864                 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
 865
 866         if (data[IFLA_GRE_IFLAGS])
 867                 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
 868
 869         if (data[IFLA_GRE_OFLAGS])
 870                 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
 871
 872         if (data[IFLA_GRE_IKEY])
 873                 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
 874
 875         if (data[IFLA_GRE_OKEY])
 876                 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
 877
 878         if (data[IFLA_GRE_LOCAL])
 879                 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
 880
 881         if (data[IFLA_GRE_REMOTE])
 882                 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
 883
 884         if (data[IFLA_GRE_TTL])
 885                 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
 886
 887         if (data[IFLA_GRE_TOS])
 888                 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
 889
 890         if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
 891                 if (t->ignore_df)
 892                         return -EINVAL;
 893                 parms->iph.frag_off = htons(IP_DF);
 894         }
 895
 896         if (data[IFLA_GRE_COLLECT_METADATA]) {
 897                 t->collect_md = true;
 898                 if (dev->type == ARPHRD_IPGRE)
 899                         dev->type = ARPHRD_NONE;
 900         }
 901
 902         if (data[IFLA_GRE_IGNORE_DF]) {
 903                 if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
 904                   && (parms->iph.frag_off & htons(IP_DF)))
 905                         return -EINVAL;
 906                 t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
 907         }
 908
 909         return 0;
 910 }
 911
 912 /* This function returns true when ENCAP attributes are present in the nl msg */
 913 static bool ipgre_netlink_encap_parms(struct nlattr *data[],
 914                                       struct ip_tunnel_encap *ipencap)
 915 {
 916         bool ret = false;
 917
 918         memset(ipencap, 0, sizeof(*ipencap));
 919
 920         if (!data)
 921                 return ret;
 922
 923         if (data[IFLA_GRE_ENCAP_TYPE]) {
 924                 ret = true;
 925                 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
 926         }
 927
 928         if (data[IFLA_GRE_ENCAP_FLAGS]) {
 929                 ret = true;
 930                 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
 931         }
 932
 933         if (data[IFLA_GRE_ENCAP_SPORT]) {
 934                 ret = true;
 935                 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
 936         }
 937
 938         if (data[IFLA_GRE_ENCAP_DPORT]) {
 939                 ret = true;
 940                 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
 941         }
 942
 943         return ret;
 944 }
 945
 946 static int gre_tap_init(struct net_device *dev)
 947 {
 948         __gre_tunnel_init(dev);
 949         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 950
 951         return ip_tunnel_init(dev);
 952 }
 953
 954 static const struct net_device_ops gre_tap_netdev_ops = {
 955         .ndo_init               = gre_tap_init,
 956         .ndo_uninit             = ip_tunnel_uninit,
 957         .ndo_start_xmit         = gre_tap_xmit,
 958         .ndo_set_mac_address    = eth_mac_addr,
 959         .ndo_validate_addr      = eth_validate_addr,
 960         .ndo_change_mtu         = ip_tunnel_change_mtu,
 961         .ndo_get_stats64        = ip_tunnel_get_stats64,
 962         .ndo_get_iflink         = ip_tunnel_get_iflink,
 963         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
 964 };
 965
 966 static void ipgre_tap_setup(struct net_device *dev)
 967 {
 968         ether_setup(dev);
 969         dev->netdev_ops = &gre_tap_netdev_ops;
 970         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 971         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 972         ip_tunnel_setup(dev, gre_tap_net_id);
 973 }
 974
 975 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
 976                          struct nlattr *tb[], struct nlattr *data[])
 977 {
 978         struct ip_tunnel_parm p;
 979         struct ip_tunnel_encap ipencap;
 980         int err;
 981
 982         if (ipgre_netlink_encap_parms(data, &ipencap)) {
 983                 struct ip_tunnel *t = netdev_priv(dev);
 984                 err = ip_tunnel_encap_setup(t, &ipencap);
 985
 986                 if (err < 0)
 987                         return err;
 988         }
 989
 990         err = ipgre_netlink_parms(dev, data, tb, &p);
 991         if (err < 0)
 992                 return err;
 993         return ip_tunnel_newlink(dev, tb, &p);
 994 }
 995
 996 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
 997                             struct nlattr *data[])
 998 {
 999         struct ip_tunnel_parm p;
1000         struct ip_tunnel_encap ipencap;
1001         int err;
1002
1003         if (ipgre_netlink_encap_parms(data, &ipencap)) {
1004                 struct ip_tunnel *t = netdev_priv(dev);
1005                 err = ip_tunnel_encap_setup(t, &ipencap);
1006
1007                 if (err < 0)
1008                         return err;
1009         }
1010
1011         err = ipgre_netlink_parms(dev, data, tb, &p);
1012         if (err < 0)
1013                 return err;
1014         return ip_tunnel_changelink(dev, tb, &p);
1015 }
1016
1017 static size_t ipgre_get_size(const struct net_device *dev)
1018 {
1019         return
1020                 /* IFLA_GRE_LINK */
1021                 nla_total_size(4) +
1022                 /* IFLA_GRE_IFLAGS */
1023                 nla_total_size(2) +
1024                 /* IFLA_GRE_OFLAGS */
1025                 nla_total_size(2) +
1026                 /* IFLA_GRE_IKEY */
1027                 nla_total_size(4) +
1028                 /* IFLA_GRE_OKEY */
1029                 nla_total_size(4) +
1030                 /* IFLA_GRE_LOCAL */
1031                 nla_total_size(4) +
1032                 /* IFLA_GRE_REMOTE */
1033                 nla_total_size(4) +
1034                 /* IFLA_GRE_TTL */
1035                 nla_total_size(1) +
1036                 /* IFLA_GRE_TOS */
1037                 nla_total_size(1) +
1038                 /* IFLA_GRE_PMTUDISC */
1039                 nla_total_size(1) +
1040                 /* IFLA_GRE_ENCAP_TYPE */
1041                 nla_total_size(2) +
1042                 /* IFLA_GRE_ENCAP_FLAGS */
1043                 nla_total_size(2) +
1044                 /* IFLA_GRE_ENCAP_SPORT */
1045                 nla_total_size(2) +
1046                 /* IFLA_GRE_ENCAP_DPORT */
1047                 nla_total_size(2) +
1048                 /* IFLA_GRE_COLLECT_METADATA */
1049                 nla_total_size(0) +
1050                 /* IFLA_GRE_IGNORE_DF */
1051                 nla_total_size(1) +
1052                 0;
1053 }
1054
1055 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1056 {
1057         struct ip_tunnel *t = netdev_priv(dev);
1058         struct ip_tunnel_parm *p = &t->parms;
1059
1060         if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1061             nla_put_be16(skb, IFLA_GRE_IFLAGS,
1062                          gre_tnl_flags_to_gre_flags(p->i_flags)) ||
1063             nla_put_be16(skb, IFLA_GRE_OFLAGS,
1064                          gre_tnl_flags_to_gre_flags(p->o_flags)) ||
1065             nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1066             nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1067             nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1068             nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1069             nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1070             nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1071             nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1072                        !!(p->iph.frag_off & htons(IP_DF))))
1073                 goto nla_put_failure;
1074
1075         if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1076                         t->encap.type) ||
1077             nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1078                          t->encap.sport) ||
1079             nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1080                          t->encap.dport) ||
1081             nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1082                         t->encap.flags))
1083                 goto nla_put_failure;
1084
1085         if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
1086                 goto nla_put_failure;
1087
1088         if (t->collect_md) {
1089                 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1090                         goto nla_put_failure;
1091         }
1092
1093         return 0;
1094
1095 nla_put_failure:
1096         return -EMSGSIZE;
1097 }
1098
1099 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1100         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
1101         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
1102         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
1103         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
1104         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
1105         [IFLA_GRE_LOCAL]        = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1106         [IFLA_GRE_REMOTE]       = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
1107         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
1108         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
1109         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
1110         [IFLA_GRE_ENCAP_TYPE]   = { .type = NLA_U16 },
1111         [IFLA_GRE_ENCAP_FLAGS]  = { .type = NLA_U16 },
1112         [IFLA_GRE_ENCAP_SPORT]  = { .type = NLA_U16 },
1113         [IFLA_GRE_ENCAP_DPORT]  = { .type = NLA_U16 },
1114         [IFLA_GRE_COLLECT_METADATA]     = { .type = NLA_FLAG },
1115         [IFLA_GRE_IGNORE_DF]    = { .type = NLA_U8 },
1116 };
1117
1118 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1119         .kind           = "gre",
1120         .maxtype        = IFLA_GRE_MAX,
1121         .policy         = ipgre_policy,
1122         .priv_size      = sizeof(struct ip_tunnel),
1123         .setup          = ipgre_tunnel_setup,
1124         .validate       = ipgre_tunnel_validate,
1125         .newlink        = ipgre_newlink,
1126         .changelink     = ipgre_changelink,
1127         .dellink        = ip_tunnel_dellink,
1128         .get_size       = ipgre_get_size,
1129         .fill_info      = ipgre_fill_info,
1130         .get_link_net   = ip_tunnel_get_link_net,
1131 };
1132
1133 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1134         .kind           = "gretap",
1135         .maxtype        = IFLA_GRE_MAX,
1136         .policy         = ipgre_policy,
1137         .priv_size      = sizeof(struct ip_tunnel),
1138         .setup          = ipgre_tap_setup,
1139         .validate       = ipgre_tap_validate,
1140         .newlink        = ipgre_newlink,
1141         .changelink     = ipgre_changelink,
1142         .dellink        = ip_tunnel_dellink,
1143         .get_size       = ipgre_get_size,
1144         .fill_info      = ipgre_fill_info,
1145         .get_link_net   = ip_tunnel_get_link_net,
1146 };
1147
1148 struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1149                                         u8 name_assign_type)
1150 {
1151         struct nlattr *tb[IFLA_MAX + 1];
1152         struct net_device *dev;
1153         LIST_HEAD(list_kill);
1154         struct ip_tunnel *t;
1155         int err;
1156
1157         memset(&tb, 0, sizeof(tb));
1158
1159         dev = rtnl_create_link(net, name, name_assign_type,
1160                                &ipgre_tap_ops, tb);
1161         if (IS_ERR(dev))
1162                 return dev;
1163
1164         /* Configure flow based GRE device. */
1165         t = netdev_priv(dev);
1166         t->collect_md = true;
1167
1168         err = ipgre_newlink(net, dev, tb, NULL);
1169         if (err < 0) {
1170                 free_netdev(dev);
1171                 return ERR_PTR(err);
1172         }
1173
1174         /* openvswitch users expect packet sizes to be unrestricted,
1175          * so set the largest MTU we can.
1176          */
1177         err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
1178         if (err)
1179                 goto out;
1180
1181         err = rtnl_configure_link(dev, NULL);
1182         if (err < 0)
1183                 goto out;
1184
1185         return dev;
1186 out:
1187         ip_tunnel_dellink(dev, &list_kill);
1188         unregister_netdevice_many(&list_kill);
1189         return ERR_PTR(err);
1190 }
1191 EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1192
1193 static int __net_init ipgre_tap_init_net(struct net *net)
1194 {
1195         return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1196 }
1197
1198 static void __net_exit ipgre_tap_exit_net(struct net *net)
1199 {
1200         struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
1201         ip_tunnel_delete_net(itn, &ipgre_tap_ops);
1202 }
1203
1204 static struct pernet_operations ipgre_tap_net_ops = {
1205         .init = ipgre_tap_init_net,
1206         .exit = ipgre_tap_exit_net,
1207         .id   = &gre_tap_net_id,
1208         .size = sizeof(struct ip_tunnel_net),
1209 };
1210
1211 static int __init ipgre_init(void)
1212 {
1213         int err;
1214
1215         pr_info("GRE over IPv4 tunneling driver\n");
1216
1217         err = register_pernet_device(&ipgre_net_ops);
1218         if (err < 0)
1219                 return err;
1220
1221         err = register_pernet_device(&ipgre_tap_net_ops);
1222         if (err < 0)
1223                 goto pnet_tap_faied;
1224
1225         err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1226         if (err < 0) {
1227                 pr_info("%s: can't add protocol\n", __func__);
1228                 goto add_proto_failed;
1229         }
1230
1231         err = rtnl_link_register(&ipgre_link_ops);
1232         if (err < 0)
1233                 goto rtnl_link_failed;
1234
1235         err = rtnl_link_register(&ipgre_tap_ops);
1236         if (err < 0)
1237                 goto tap_ops_failed;
1238
1239         return 0;
1240
1241 tap_ops_failed:
1242         rtnl_link_unregister(&ipgre_link_ops);
1243 rtnl_link_failed:
1244         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1245 add_proto_failed:
1246         unregister_pernet_device(&ipgre_tap_net_ops);
1247 pnet_tap_faied:
1248         unregister_pernet_device(&ipgre_net_ops);
1249         return err;
1250 }
1251
1252 static void __exit ipgre_fini(void)
1253 {
1254         rtnl_link_unregister(&ipgre_tap_ops);
1255         rtnl_link_unregister(&ipgre_link_ops);
1256         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1257         unregister_pernet_device(&ipgre_tap_net_ops);
1258         unregister_pernet_device(&ipgre_net_ops);
1259 }
1260
1261 module_init(ipgre_init);
1262 module_exit(ipgre_fini);
1263 MODULE_LICENSE("GPL");
1264 MODULE_ALIAS_RTNL_LINK("gre");
1265 MODULE_ALIAS_RTNL_LINK("gretap");
1266 MODULE_ALIAS_NETDEV("gre0");
1267 MODULE_ALIAS_NETDEV("gretap0");