net/ipv4/ip_gre.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *      Linux NET3:     GRE over IP protocol decoder.
   4  *
   5  *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/capability.h>
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/uaccess.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/netdevice.h>
  18 #include <linux/in.h>
  19 #include <linux/tcp.h>
  20 #include <linux/udp.h>
  21 #include <linux/if_arp.h>
  22 #include <linux/if_vlan.h>
  23 #include <linux/init.h>
  24 #include <linux/in6.h>
  25 #include <linux/inetdevice.h>
  26 #include <linux/igmp.h>
  27 #include <linux/netfilter_ipv4.h>
  28 #include <linux/etherdevice.h>
  29 #include <linux/if_ether.h>
  30
  31 #include <net/sock.h>
  32 #include <net/ip.h>
  33 #include <net/icmp.h>
  34 #include <net/protocol.h>
  35 #include <net/ip_tunnels.h>
  36 #include <net/arp.h>
  37 #include <net/checksum.h>
  38 #include <net/dsfield.h>
  39 #include <net/inet_ecn.h>
  40 #include <net/xfrm.h>
  41 #include <net/net_namespace.h>
  42 #include <net/netns/generic.h>
  43 #include <net/rtnetlink.h>
  44 #include <net/gre.h>
  45 #include <net/dst_metadata.h>
  46 #include <net/erspan.h>
  47
  48 /*
  49    Problems & solutions
  50    --------------------
  51
  52    1. The most important issue is detecting local dead loops.
  53    They would cause complete host lockup in transmit, which
  54    would be "resolved" by stack overflow or, if queueing is enabled,
  55    with infinite looping in net_bh.
  56
  57    We cannot track such dead loops during route installation,
  58    it is infeasible task. The most general solutions would be
  59    to keep skb->encapsulation counter (sort of local ttl),
  60    and silently drop packet when it expires. It is a good
  61    solution, but it supposes maintaining new variable in ALL
  62    skb, even if no tunneling is used.
  63
  64    Current solution: xmit_recursion breaks dead loops. This is a percpu
  65    counter, since when we enter the first ndo_xmit(), cpu migration is
  66    forbidden. We force an exit if this counter reaches RECURSION_LIMIT
  67
  68    2. Networking dead loops would not kill routers, but would really
  69    kill network. IP hop limit plays role of "t->recursion" in this case,
  70    if we copy it from packet being encapsulated to upper header.
  71    It is very good solution, but it introduces two problems:
  72
  73    - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
  74      do not work over tunnels.
  75    - traceroute does not work. I planned to relay ICMP from tunnel,
  76      so that this problem would be solved and traceroute output
  77      would even more informative. This idea appeared to be wrong:
  78      only Linux complies to rfc1812 now (yes, guys, Linux is the only
  79      true router now :-)), all routers (at least, in neighbourhood of mine)
  80      return only 8 bytes of payload. It is the end.
  81
  82    Hence, if we want that OSPF worked or traceroute said something reasonable,
  83    we should search for another solution.
  84
  85    One of them is to parse packet trying to detect inner encapsulation
  86    made by our node. It is difficult or even impossible, especially,
  87    taking into account fragmentation. TO be short, ttl is not solution at all.
  88
  89    Current solution: The solution was UNEXPECTEDLY SIMPLE.
  90    We force DF flag on tunnels with preconfigured hop limit,
  91    that is ALL. :-) Well, it does not remove the problem completely,
  92    but exponential growth of network traffic is changed to linear
  93    (branches, that exceed pmtu are pruned) and tunnel mtu
  94    rapidly degrades to value <68, where looping stops.
  95    Yes, it is not good if there exists a router in the loop,
  96    which does not force DF, even when encapsulating packets have DF set.
  97    But it is not our problem! Nobody could accuse us, we made
  98    all that we could make. Even if it is your gated who injected
  99    fatal route to network, even if it were you who configured
 100    fatal static route: you are innocent. :-)
 101
 102    Alexey Kuznetsov.
 103  */
 104
 105 static bool log_ecn_error = true;
 106 module_param(log_ecn_error, bool, 0644);
 107 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 108
 109 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
 110 static int ipgre_tunnel_init(struct net_device *dev);
 111 static void erspan_build_header(struct sk_buff *skb,
 112                                 u32 id, u32 index,
 113                                 bool truncate, bool is_ipv4);
 114
 115 static unsigned int ipgre_net_id __read_mostly;
 116 static unsigned int gre_tap_net_id __read_mostly;
 117 static unsigned int erspan_net_id __read_mostly;
 118
 119 static int 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         if (tpi->proto == htons(ETH_P_TEB))
 145                 itn = net_generic(net, gre_tap_net_id);
 146         else if (tpi->proto == htons(ETH_P_ERSPAN) ||
 147                  tpi->proto == htons(ETH_P_ERSPAN2))
 148                 itn = net_generic(net, erspan_net_id);
 149         else
 150                 itn = net_generic(net, ipgre_net_id);
 151
 152         iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
 153         t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 154                              iph->daddr, iph->saddr, tpi->key);
 155
 156         if (!t)
 157                 return -ENOENT;
 158
 159         switch (type) {
 160         default:
 161         case ICMP_PARAMETERPROB:
 162                 return 0;
 163
 164         case ICMP_DEST_UNREACH:
 165                 switch (code) {
 166                 case ICMP_SR_FAILED:
 167                 case ICMP_PORT_UNREACH:
 168                         /* Impossible event. */
 169                         return 0;
 170                 default:
 171                         /* All others are translated to HOST_UNREACH.
 172                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 173                            I believe they are just ether pollution. --ANK
 174                          */
 175                         break;
 176                 }
 177                 break;
 178
 179         case ICMP_TIME_EXCEEDED:
 180                 if (code != ICMP_EXC_TTL)
 181                         return 0;
 182                 data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
 183                 break;
 184
 185         case ICMP_REDIRECT:
 186                 break;
 187         }
 188
 189 #if IS_ENABLED(CONFIG_IPV6)
 190        if (tpi->proto == htons(ETH_P_IPV6) &&
 191            !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len,
 192                                        type, data_len))
 193                return 0;
 194 #endif
 195
 196         if (t->parms.iph.daddr == 0 ||
 197             ipv4_is_multicast(t->parms.iph.daddr))
 198                 return 0;
 199
 200         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 201                 return 0;
 202
 203         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 204                 t->err_count++;
 205         else
 206                 t->err_count = 1;
 207         t->err_time = jiffies;
 208
 209         return 0;
 210 }
 211
 212 static void gre_err(struct sk_buff *skb, u32 info)
 213 {
 214         /* All the routers (except for Linux) return only
 215          * 8 bytes of packet payload. It means, that precise relaying of
 216          * ICMP in the real Internet is absolutely infeasible.
 217          *
 218          * Moreover, Cisco "wise men" put GRE key to the third word
 219          * in GRE header. It makes impossible maintaining even soft
 220          * state for keyed
 221          * GRE tunnels with enabled checksum. Tell them "thank you".
 222          *
 223          * Well, I wonder, rfc1812 was written by Cisco employee,
 224          * what the hell these idiots break standards established
 225          * by themselves???
 226          */
 227
 228         const struct iphdr *iph = (struct iphdr *)skb->data;
 229         const int type = icmp_hdr(skb)->type;
 230         const int code = icmp_hdr(skb)->code;
 231         struct tnl_ptk_info tpi;
 232
 233         if (gre_parse_header(skb, &tpi, NULL, htons(ETH_P_IP),
 234                              iph->ihl * 4) < 0)
 235                 return;
 236
 237         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 238                 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
 239                                  skb->dev->ifindex, IPPROTO_GRE);
 240                 return;
 241         }
 242         if (type == ICMP_REDIRECT) {
 243                 ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex,
 244                               IPPROTO_GRE);
 245                 return;
 246         }
 247
 248         ipgre_err(skb, info, &tpi);
 249 }
 250
 251 static bool is_erspan_type1(int gre_hdr_len)
 252 {
 253         /* Both ERSPAN type I (version 0) and type II (version 1) use
 254          * protocol 0x88BE, but the type I has only 4-byte GRE header,
 255          * while type II has 8-byte.
 256          */
 257         return gre_hdr_len == 4;
 258 }
 259
 260 static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi,
 261                       int gre_hdr_len)
 262 {
 263         struct net *net = dev_net(skb->dev);
 264         struct metadata_dst *tun_dst = NULL;
 265         struct erspan_base_hdr *ershdr;
 266         struct ip_tunnel_net *itn;
 267         struct ip_tunnel *tunnel;
 268         const struct iphdr *iph;
 269         struct erspan_md2 *md2;
 270         int ver;
 271         int len;
 272
 273         itn = net_generic(net, erspan_net_id);
 274         iph = ip_hdr(skb);
 275         if (is_erspan_type1(gre_hdr_len)) {
 276                 ver = 0;
 277                 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex,
 278                                           tpi->flags | TUNNEL_NO_KEY,
 279                                           iph->saddr, iph->daddr, 0);
 280         } else {
 281                 ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len);
 282                 ver = ershdr->ver;
 283                 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex,
 284                                           tpi->flags | TUNNEL_KEY,
 285                                           iph->saddr, iph->daddr, tpi->key);
 286         }
 287
 288         if (tunnel) {
 289                 if (is_erspan_type1(gre_hdr_len))
 290                         len = gre_hdr_len;
 291                 else
 292                         len = gre_hdr_len + erspan_hdr_len(ver);
 293
 294                 if (unlikely(!pskb_may_pull(skb, len)))
 295                         return PACKET_REJECT;
 296
 297                 if (__iptunnel_pull_header(skb,
 298                                            len,
 299                                            htons(ETH_P_TEB),
 300                                            false, false) < 0)
 301                         goto drop;
 302
 303                 if (tunnel->collect_md) {
 304                         struct erspan_metadata *pkt_md, *md;
 305                         struct ip_tunnel_info *info;
 306                         unsigned char *gh;
 307                         __be64 tun_id;
 308                         __be16 flags;
 309
 310                         tpi->flags |= TUNNEL_KEY;
 311                         flags = tpi->flags;
 312                         tun_id = key32_to_tunnel_id(tpi->key);
 313
 314                         tun_dst = ip_tun_rx_dst(skb, flags,
 315                                                 tun_id, sizeof(*md));
 316                         if (!tun_dst)
 317                                 return PACKET_REJECT;
 318
 319                         /* skb can be uncloned in __iptunnel_pull_header, so
 320                          * old pkt_md is no longer valid and we need to reset
 321                          * it
 322                          */
 323                         gh = skb_network_header(skb) +
 324                              skb_network_header_len(skb);
 325                         pkt_md = (struct erspan_metadata *)(gh + gre_hdr_len +
 326                                                             sizeof(*ershdr));
 327                         md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
 328                         md->version = ver;
 329                         md2 = &md->u.md2;
 330                         memcpy(md2, pkt_md, ver == 1 ? ERSPAN_V1_MDSIZE :
 331                                                        ERSPAN_V2_MDSIZE);
 332
 333                         info = &tun_dst->u.tun_info;
 334                         info->key.tun_flags |= TUNNEL_ERSPAN_OPT;
 335                         info->options_len = sizeof(*md);
 336                 }
 337
 338                 skb_reset_mac_header(skb);
 339                 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
 340                 return PACKET_RCVD;
 341         }
 342         return PACKET_REJECT;
 343
 344 drop:
 345         kfree_skb(skb);
 346         return PACKET_RCVD;
 347 }
 348
 349 static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 350                        struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
 351 {
 352         struct metadata_dst *tun_dst = NULL;
 353         const struct iphdr *iph;
 354         struct ip_tunnel *tunnel;
 355
 356         iph = ip_hdr(skb);
 357         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 358                                   iph->saddr, iph->daddr, tpi->key);
 359
 360         if (tunnel) {
 361                 const struct iphdr *tnl_params;
 362
 363                 if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
 364                                            raw_proto, false) < 0)
 365                         goto drop;
 366
 367                 if (tunnel->dev->type != ARPHRD_NONE)
 368                         skb_pop_mac_header(skb);
 369                 else
 370                         skb_reset_mac_header(skb);
 371
 372                 tnl_params = &tunnel->parms.iph;
 373                 if (tunnel->collect_md || tnl_params->daddr == 0) {
 374                         __be16 flags;
 375                         __be64 tun_id;
 376
 377                         flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
 378                         tun_id = key32_to_tunnel_id(tpi->key);
 379                         tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
 380                         if (!tun_dst)
 381                                 return PACKET_REJECT;
 382                 }
 383
 384                 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
 385                 return PACKET_RCVD;
 386         }
 387         return PACKET_NEXT;
 388
 389 drop:
 390         kfree_skb(skb);
 391         return PACKET_RCVD;
 392 }
 393
 394 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 395                      int hdr_len)
 396 {
 397         struct net *net = dev_net(skb->dev);
 398         struct ip_tunnel_net *itn;
 399         int res;
 400
 401         if (tpi->proto == htons(ETH_P_TEB))
 402                 itn = net_generic(net, gre_tap_net_id);
 403         else
 404                 itn = net_generic(net, ipgre_net_id);
 405
 406         res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
 407         if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
 408                 /* ipgre tunnels in collect metadata mode should receive
 409                  * also ETH_P_TEB traffic.
 410                  */
 411                 itn = net_generic(net, ipgre_net_id);
 412                 res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
 413         }
 414         return res;
 415 }
 416
 417 static int gre_rcv(struct sk_buff *skb)
 418 {
 419         struct tnl_ptk_info tpi;
 420         bool csum_err = false;
 421         int hdr_len;
 422
 423 #ifdef CONFIG_NET_IPGRE_BROADCAST
 424         if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
 425                 /* Looped back packet, drop it! */
 426                 if (rt_is_output_route(skb_rtable(skb)))
 427                         goto drop;
 428         }
 429 #endif
 430
 431         hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
 432         if (hdr_len < 0)
 433                 goto drop;
 434
 435         if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) ||
 436                      tpi.proto == htons(ETH_P_ERSPAN2))) {
 437                 if (erspan_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 438                         return 0;
 439                 goto out;
 440         }
 441
 442         if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 443                 return 0;
 444
 445 out:
 446         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
 447 drop:
 448         kfree_skb(skb);
 449         return 0;
 450 }
 451
 452 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
 453                        const struct iphdr *tnl_params,
 454                        __be16 proto)
 455 {
 456         struct ip_tunnel *tunnel = netdev_priv(dev);
 457
 458         if (tunnel->parms.o_flags & TUNNEL_SEQ)
 459                 tunnel->o_seqno++;
 460
 461         /* Push GRE header. */
 462         gre_build_header(skb, tunnel->tun_hlen,
 463                          tunnel->parms.o_flags, proto, tunnel->parms.o_key,
 464                          htonl(tunnel->o_seqno));
 465
 466         ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
 467 }
 468
 469 static int gre_handle_offloads(struct sk_buff *skb, bool csum)
 470 {
 471         if (csum && skb_checksum_start(skb) < skb->data)
 472                 return -EINVAL;
 473         return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
 474 }
 475
 476 static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
 477                         __be16 proto)
 478 {
 479         struct ip_tunnel *tunnel = netdev_priv(dev);
 480         struct ip_tunnel_info *tun_info;
 481         const struct ip_tunnel_key *key;
 482         int tunnel_hlen;
 483         __be16 flags;
 484
 485         tun_info = skb_tunnel_info(skb);
 486         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 487                      ip_tunnel_info_af(tun_info) != AF_INET))
 488                 goto err_free_skb;
 489
 490         key = &tun_info->key;
 491         tunnel_hlen = gre_calc_hlen(key->tun_flags);
 492
 493         if (skb_cow_head(skb, dev->needed_headroom))
 494                 goto err_free_skb;
 495
 496         /* Push Tunnel header. */
 497         if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
 498                 goto err_free_skb;
 499
 500         flags = tun_info->key.tun_flags &
 501                 (TUNNEL_CSUM | TUNNEL_KEY | TUNNEL_SEQ);
 502         gre_build_header(skb, tunnel_hlen, flags, proto,
 503                          tunnel_id_to_key32(tun_info->key.tun_id),
 504                          (flags & TUNNEL_SEQ) ? htonl(tunnel->o_seqno++) : 0);
 505
 506         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 507
 508         return;
 509
 510 err_free_skb:
 511         kfree_skb(skb);
 512         dev->stats.tx_dropped++;
 513 }
 514
 515 static void erspan_fb_xmit(struct sk_buff *skb, struct net_device *dev)
 516 {
 517         struct ip_tunnel *tunnel = netdev_priv(dev);
 518         struct ip_tunnel_info *tun_info;
 519         const struct ip_tunnel_key *key;
 520         struct erspan_metadata *md;
 521         bool truncate = false;
 522         __be16 proto;
 523         int tunnel_hlen;
 524         int version;
 525         int nhoff;
 526         int thoff;
 527
 528         tun_info = skb_tunnel_info(skb);
 529         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 530                      ip_tunnel_info_af(tun_info) != AF_INET))
 531                 goto err_free_skb;
 532
 533         key = &tun_info->key;
 534         if (!(tun_info->key.tun_flags & TUNNEL_ERSPAN_OPT))
 535                 goto err_free_skb;
 536         if (tun_info->options_len < sizeof(*md))
 537                 goto err_free_skb;
 538         md = ip_tunnel_info_opts(tun_info);
 539
 540         /* ERSPAN has fixed 8 byte GRE header */
 541         version = md->version;
 542         tunnel_hlen = 8 + erspan_hdr_len(version);
 543
 544         if (skb_cow_head(skb, dev->needed_headroom))
 545                 goto err_free_skb;
 546
 547         if (gre_handle_offloads(skb, false))
 548                 goto err_free_skb;
 549
 550         if (skb->len > dev->mtu + dev->hard_header_len) {
 551                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 552                 truncate = true;
 553         }
 554
 555         nhoff = skb_network_header(skb) - skb_mac_header(skb);
 556         if (skb->protocol == htons(ETH_P_IP) &&
 557             (ntohs(ip_hdr(skb)->tot_len) > skb->len - nhoff))
 558                 truncate = true;
 559
 560         thoff = skb_transport_header(skb) - skb_mac_header(skb);
 561         if (skb->protocol == htons(ETH_P_IPV6) &&
 562             (ntohs(ipv6_hdr(skb)->payload_len) > skb->len - thoff))
 563                 truncate = true;
 564
 565         if (version == 1) {
 566                 erspan_build_header(skb, ntohl(tunnel_id_to_key32(key->tun_id)),
 567                                     ntohl(md->u.index), truncate, true);
 568                 proto = htons(ETH_P_ERSPAN);
 569         } else if (version == 2) {
 570                 erspan_build_header_v2(skb,
 571                                        ntohl(tunnel_id_to_key32(key->tun_id)),
 572                                        md->u.md2.dir,
 573                                        get_hwid(&md->u.md2),
 574                                        truncate, true);
 575                 proto = htons(ETH_P_ERSPAN2);
 576         } else {
 577                 goto err_free_skb;
 578         }
 579
 580         gre_build_header(skb, 8, TUNNEL_SEQ,
 581                          proto, 0, htonl(tunnel->o_seqno++));
 582
 583         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 584
 585         return;
 586
 587 err_free_skb:
 588         kfree_skb(skb);
 589         dev->stats.tx_dropped++;
 590 }
 591
 592 static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
 593 {
 594         struct ip_tunnel_info *info = skb_tunnel_info(skb);
 595         const struct ip_tunnel_key *key;
 596         struct rtable *rt;
 597         struct flowi4 fl4;
 598
 599         if (ip_tunnel_info_af(info) != AF_INET)
 600                 return -EINVAL;
 601
 602         key = &info->key;
 603         ip_tunnel_init_flow(&fl4, IPPROTO_GRE, key->u.ipv4.dst, key->u.ipv4.src,
 604                             tunnel_id_to_key32(key->tun_id), key->tos, 0,
 605                             skb->mark, skb_get_hash(skb));
 606         rt = ip_route_output_key(dev_net(dev), &fl4);
 607         if (IS_ERR(rt))
 608                 return PTR_ERR(rt);
 609
 610         ip_rt_put(rt);
 611         info->key.u.ipv4.src = fl4.saddr;
 612         return 0;
 613 }
 614
 615 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
 616                               struct net_device *dev)
 617 {
 618         struct ip_tunnel *tunnel = netdev_priv(dev);
 619         const struct iphdr *tnl_params;
 620
 621         if (!pskb_inet_may_pull(skb))
 622                 goto free_skb;
 623
 624         if (tunnel->collect_md) {
 625                 gre_fb_xmit(skb, dev, skb->protocol);
 626                 return NETDEV_TX_OK;
 627         }
 628
 629         if (dev->header_ops) {
 630                 if (skb_cow_head(skb, 0))
 631                         goto free_skb;
 632
 633                 tnl_params = (const struct iphdr *)skb->data;
 634
 635                 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
 636                  * to gre header.
 637                  */
 638                 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
 639                 skb_reset_mac_header(skb);
 640         } else {
 641                 if (skb_cow_head(skb, dev->needed_headroom))
 642                         goto free_skb;
 643
 644                 tnl_params = &tunnel->parms.iph;
 645         }
 646
 647         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 648                 goto free_skb;
 649
 650         __gre_xmit(skb, dev, tnl_params, skb->protocol);
 651         return NETDEV_TX_OK;
 652
 653 free_skb:
 654         kfree_skb(skb);
 655         dev->stats.tx_dropped++;
 656         return NETDEV_TX_OK;
 657 }
 658
 659 static netdev_tx_t erspan_xmit(struct sk_buff *skb,
 660                                struct net_device *dev)
 661 {
 662         struct ip_tunnel *tunnel = netdev_priv(dev);
 663         bool truncate = false;
 664         __be16 proto;
 665
 666         if (!pskb_inet_may_pull(skb))
 667                 goto free_skb;
 668
 669         if (tunnel->collect_md) {
 670                 erspan_fb_xmit(skb, dev);
 671                 return NETDEV_TX_OK;
 672         }
 673
 674         if (gre_handle_offloads(skb, false))
 675                 goto free_skb;
 676
 677         if (skb_cow_head(skb, dev->needed_headroom))
 678                 goto free_skb;
 679
 680         if (skb->len > dev->mtu + dev->hard_header_len) {
 681                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 682                 truncate = true;
 683         }
 684
 685         /* Push ERSPAN header */
 686         if (tunnel->erspan_ver == 0) {
 687                 proto = htons(ETH_P_ERSPAN);
 688                 tunnel->parms.o_flags &= ~TUNNEL_SEQ;
 689         } else if (tunnel->erspan_ver == 1) {
 690                 erspan_build_header(skb, ntohl(tunnel->parms.o_key),
 691                                     tunnel->index,
 692                                     truncate, true);
 693                 proto = htons(ETH_P_ERSPAN);
 694         } else if (tunnel->erspan_ver == 2) {
 695                 erspan_build_header_v2(skb, ntohl(tunnel->parms.o_key),
 696                                        tunnel->dir, tunnel->hwid,
 697                                        truncate, true);
 698                 proto = htons(ETH_P_ERSPAN2);
 699         } else {
 700                 goto free_skb;
 701         }
 702
 703         tunnel->parms.o_flags &= ~TUNNEL_KEY;
 704         __gre_xmit(skb, dev, &tunnel->parms.iph, proto);
 705         return NETDEV_TX_OK;
 706
 707 free_skb:
 708         kfree_skb(skb);
 709         dev->stats.tx_dropped++;
 710         return NETDEV_TX_OK;
 711 }
 712
 713 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
 714                                 struct net_device *dev)
 715 {
 716         struct ip_tunnel *tunnel = netdev_priv(dev);
 717
 718         if (!pskb_inet_may_pull(skb))
 719                 goto free_skb;
 720
 721         if (tunnel->collect_md) {
 722                 gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
 723                 return NETDEV_TX_OK;
 724         }
 725
 726         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 727                 goto free_skb;
 728
 729         if (skb_cow_head(skb, dev->needed_headroom))
 730                 goto free_skb;
 731
 732         __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
 733         return NETDEV_TX_OK;
 734
 735 free_skb:
 736         kfree_skb(skb);
 737         dev->stats.tx_dropped++;
 738         return NETDEV_TX_OK;
 739 }
 740
 741 static void ipgre_link_update(struct net_device *dev, bool set_mtu)
 742 {
 743         struct ip_tunnel *tunnel = netdev_priv(dev);
 744         int len;
 745
 746         len = tunnel->tun_hlen;
 747         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 748         len = tunnel->tun_hlen - len;
 749         tunnel->hlen = tunnel->hlen + len;
 750
 751         if (dev->header_ops)
 752                 dev->hard_header_len += len;
 753         else
 754                 dev->needed_headroom += len;
 755
 756         if (set_mtu)
 757                 dev->mtu = max_t(int, dev->mtu - len, 68);
 758
 759         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 760                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 761                     tunnel->encap.type == TUNNEL_ENCAP_NONE) {
 762                         dev->features |= NETIF_F_GSO_SOFTWARE;
 763                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 764                 } else {
 765                         dev->features &= ~NETIF_F_GSO_SOFTWARE;
 766                         dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 767                 }
 768                 dev->features |= NETIF_F_LLTX;
 769         } else {
 770                 dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 771                 dev->features &= ~(NETIF_F_LLTX | NETIF_F_GSO_SOFTWARE);
 772         }
 773 }
 774
 775 static int ipgre_tunnel_ctl(struct net_device *dev, struct ip_tunnel_parm *p,
 776                             int cmd)
 777 {
 778         int err;
 779
 780         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
 781                 if (p->iph.version != 4 || p->iph.protocol != IPPROTO_GRE ||
 782                     p->iph.ihl != 5 || (p->iph.frag_off & htons(~IP_DF)) ||
 783                     ((p->i_flags | p->o_flags) & (GRE_VERSION | GRE_ROUTING)))
 784                         return -EINVAL;
 785         }
 786
 787         p->i_flags = gre_flags_to_tnl_flags(p->i_flags);
 788         p->o_flags = gre_flags_to_tnl_flags(p->o_flags);
 789
 790         err = ip_tunnel_ctl(dev, p, cmd);
 791         if (err)
 792                 return err;
 793
 794         if (cmd == SIOCCHGTUNNEL) {
 795                 struct ip_tunnel *t = netdev_priv(dev);
 796
 797                 t->parms.i_flags = p->i_flags;
 798                 t->parms.o_flags = p->o_flags;
 799
 800                 if (strcmp(dev->rtnl_link_ops->kind, "erspan"))
 801                         ipgre_link_update(dev, true);
 802         }
 803
 804         p->i_flags = gre_tnl_flags_to_gre_flags(p->i_flags);
 805         p->o_flags = gre_tnl_flags_to_gre_flags(p->o_flags);
 806         return 0;
 807 }
 808
 809 /* Nice toy. Unfortunately, useless in real life :-)
 810    It allows to construct virtual multiprotocol broadcast "LAN"
 811    over the Internet, provided multicast routing is tuned.
 812
 813
 814    I have no idea was this bicycle invented before me,
 815    so that I had to set ARPHRD_IPGRE to a random value.
 816    I have an impression, that Cisco could make something similar,
 817    but this feature is apparently missing in IOS<=11.2(8).
 818
 819    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
 820    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
 821
 822    ping -t 255 224.66.66.66
 823
 824    If nobody answers, mbone does not work.
 825
 826    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
 827    ip addr add 10.66.66.<somewhat>/24 dev Universe
 828    ifconfig Universe up
 829    ifconfig Universe add fe80::<Your_real_addr>/10
 830    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
 831    ftp 10.66.66.66
 832    ...
 833    ftp fec0:6666:6666::193.233.7.65
 834    ...
 835  */
 836 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
 837                         unsigned short type,
 838                         const void *daddr, const void *saddr, unsigned int len)
 839 {
 840         struct ip_tunnel *t = netdev_priv(dev);
 841         struct iphdr *iph;
 842         struct gre_base_hdr *greh;
 843
 844         iph = skb_push(skb, t->hlen + sizeof(*iph));
 845         greh = (struct gre_base_hdr *)(iph+1);
 846         greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
 847         greh->protocol = htons(type);
 848
 849         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
 850
 851         /* Set the source hardware address. */
 852         if (saddr)
 853                 memcpy(&iph->saddr, saddr, 4);
 854         if (daddr)
 855                 memcpy(&iph->daddr, daddr, 4);
 856         if (iph->daddr)
 857                 return t->hlen + sizeof(*iph);
 858
 859         return -(t->hlen + sizeof(*iph));
 860 }
 861
 862 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
 863 {
 864         const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
 865         memcpy(haddr, &iph->saddr, 4);
 866         return 4;
 867 }
 868
 869 static const struct header_ops ipgre_header_ops = {
 870         .create = ipgre_header,
 871         .parse  = ipgre_header_parse,
 872 };
 873
 874 #ifdef CONFIG_NET_IPGRE_BROADCAST
 875 static int ipgre_open(struct net_device *dev)
 876 {
 877         struct ip_tunnel *t = netdev_priv(dev);
 878
 879         if (ipv4_is_multicast(t->parms.iph.daddr)) {
 880                 struct flowi4 fl4;
 881                 struct rtable *rt;
 882
 883                 rt = ip_route_output_gre(t->net, &fl4,
 884                                          t->parms.iph.daddr,
 885                                          t->parms.iph.saddr,
 886                                          t->parms.o_key,
 887                                          RT_TOS(t->parms.iph.tos),
 888                                          t->parms.link);
 889                 if (IS_ERR(rt))
 890                         return -EADDRNOTAVAIL;
 891                 dev = rt->dst.dev;
 892                 ip_rt_put(rt);
 893                 if (!__in_dev_get_rtnl(dev))
 894                         return -EADDRNOTAVAIL;
 895                 t->mlink = dev->ifindex;
 896                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
 897         }
 898         return 0;
 899 }
 900
 901 static int ipgre_close(struct net_device *dev)
 902 {
 903         struct ip_tunnel *t = netdev_priv(dev);
 904
 905         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
 906                 struct in_device *in_dev;
 907                 in_dev = inetdev_by_index(t->net, t->mlink);
 908                 if (in_dev)
 909                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 910         }
 911         return 0;
 912 }
 913 #endif
 914
 915 static const struct net_device_ops ipgre_netdev_ops = {
 916         .ndo_init               = ipgre_tunnel_init,
 917         .ndo_uninit             = ip_tunnel_uninit,
 918 #ifdef CONFIG_NET_IPGRE_BROADCAST
 919         .ndo_open               = ipgre_open,
 920         .ndo_stop               = ipgre_close,
 921 #endif
 922         .ndo_start_xmit         = ipgre_xmit,
 923         .ndo_do_ioctl           = ip_tunnel_ioctl,
 924         .ndo_change_mtu         = ip_tunnel_change_mtu,
 925         .ndo_get_stats64        = dev_get_tstats64,
 926         .ndo_get_iflink         = ip_tunnel_get_iflink,
 927         .ndo_tunnel_ctl         = ipgre_tunnel_ctl,
 928 };
 929
 930 #define GRE_FEATURES (NETIF_F_SG |              \
 931                       NETIF_F_FRAGLIST |        \
 932                       NETIF_F_HIGHDMA |         \
 933                       NETIF_F_HW_CSUM)
 934
 935 static void ipgre_tunnel_setup(struct net_device *dev)
 936 {
 937         dev->netdev_ops         = &ipgre_netdev_ops;
 938         dev->type               = ARPHRD_IPGRE;
 939         ip_tunnel_setup(dev, ipgre_net_id);
 940 }
 941
 942 static void __gre_tunnel_init(struct net_device *dev)
 943 {
 944         struct ip_tunnel *tunnel;
 945
 946         tunnel = netdev_priv(dev);
 947         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 948         tunnel->parms.iph.protocol = IPPROTO_GRE;
 949
 950         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 951         dev->needed_headroom = tunnel->hlen + sizeof(tunnel->parms.iph);
 952
 953         dev->features           |= GRE_FEATURES;
 954         dev->hw_features        |= GRE_FEATURES;
 955
 956         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 957                 /* TCP offload with GRE SEQ is not supported, nor
 958                  * can we support 2 levels of outer headers requiring
 959                  * an update.
 960                  */
 961                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 962                     (tunnel->encap.type == TUNNEL_ENCAP_NONE)) {
 963                         dev->features    |= NETIF_F_GSO_SOFTWARE;
 964                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 965                 }
 966
 967                 /* Can use a lockless transmit, unless we generate
 968                  * output sequences
 969                  */
 970                 dev->features |= NETIF_F_LLTX;
 971         }
 972 }
 973
 974 static int ipgre_tunnel_init(struct net_device *dev)
 975 {
 976         struct ip_tunnel *tunnel = netdev_priv(dev);
 977         struct iphdr *iph = &tunnel->parms.iph;
 978
 979         __gre_tunnel_init(dev);
 980
 981         memcpy(dev->dev_addr, &iph->saddr, 4);
 982         memcpy(dev->broadcast, &iph->daddr, 4);
 983
 984         dev->flags              = IFF_NOARP;
 985         netif_keep_dst(dev);
 986         dev->addr_len           = 4;
 987
 988         if (iph->daddr && !tunnel->collect_md) {
 989 #ifdef CONFIG_NET_IPGRE_BROADCAST
 990                 if (ipv4_is_multicast(iph->daddr)) {
 991                         if (!iph->saddr)
 992                                 return -EINVAL;
 993                         dev->flags = IFF_BROADCAST;
 994                         dev->header_ops = &ipgre_header_ops;
 995                         dev->hard_header_len = tunnel->hlen + sizeof(*iph);
 996                         dev->needed_headroom = 0;
 997                 }
 998 #endif
 999         } else if (!tunnel->collect_md) {
1000                 dev->header_ops = &ipgre_header_ops;
1001                 dev->hard_header_len = tunnel->hlen + sizeof(*iph);
1002                 dev->needed_headroom = 0;
1003         }
1004
1005         return ip_tunnel_init(dev);
1006 }
1007
1008 static const struct gre_protocol ipgre_protocol = {
1009         .handler     = gre_rcv,
1010         .err_handler = gre_err,
1011 };
1012
1013 static int __net_init ipgre_init_net(struct net *net)
1014 {
1015         return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
1016 }
1017
1018 static void __net_exit ipgre_exit_batch_net(struct list_head *list_net)
1019 {
1020         ip_tunnel_delete_nets(list_net, ipgre_net_id, &ipgre_link_ops);
1021 }
1022
1023 static struct pernet_operations ipgre_net_ops = {
1024         .init = ipgre_init_net,
1025         .exit_batch = ipgre_exit_batch_net,
1026         .id   = &ipgre_net_id,
1027         .size = sizeof(struct ip_tunnel_net),
1028 };
1029
1030 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
1031                                  struct netlink_ext_ack *extack)
1032 {
1033         __be16 flags;
1034
1035         if (!data)
1036                 return 0;
1037
1038         flags = 0;
1039         if (data[IFLA_GRE_IFLAGS])
1040                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1041         if (data[IFLA_GRE_OFLAGS])
1042                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1043         if (flags & (GRE_VERSION|GRE_ROUTING))
1044                 return -EINVAL;
1045
1046         if (data[IFLA_GRE_COLLECT_METADATA] &&
1047             data[IFLA_GRE_ENCAP_TYPE] &&
1048             nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
1049                 return -EINVAL;
1050
1051         return 0;
1052 }
1053
1054 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
1055                               struct netlink_ext_ack *extack)
1056 {
1057         __be32 daddr;
1058
1059         if (tb[IFLA_ADDRESS]) {
1060                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1061                         return -EINVAL;
1062                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1063                         return -EADDRNOTAVAIL;
1064         }
1065
1066         if (!data)
1067                 goto out;
1068
1069         if (data[IFLA_GRE_REMOTE]) {
1070                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1071                 if (!daddr)
1072                         return -EINVAL;
1073         }
1074
1075 out:
1076         return ipgre_tunnel_validate(tb, data, extack);
1077 }
1078
1079 static int erspan_validate(struct nlattr *tb[], struct nlattr *data[],
1080                            struct netlink_ext_ack *extack)
1081 {
1082         __be16 flags = 0;
1083         int ret;
1084
1085         if (!data)
1086                 return 0;
1087
1088         ret = ipgre_tap_validate(tb, data, extack);
1089         if (ret)
1090                 return ret;
1091
1092         if (data[IFLA_GRE_ERSPAN_VER] &&
1093             nla_get_u8(data[IFLA_GRE_ERSPAN_VER]) == 0)
1094                 return 0;
1095
1096         /* ERSPAN type II/III should only have GRE sequence and key flag */
1097         if (data[IFLA_GRE_OFLAGS])
1098                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1099         if (data[IFLA_GRE_IFLAGS])
1100                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1101         if (!data[IFLA_GRE_COLLECT_METADATA] &&
1102             flags != (GRE_SEQ | GRE_KEY))
1103                 return -EINVAL;
1104
1105         /* ERSPAN Session ID only has 10-bit. Since we reuse
1106          * 32-bit key field as ID, check it's range.
1107          */
1108         if (data[IFLA_GRE_IKEY] &&
1109             (ntohl(nla_get_be32(data[IFLA_GRE_IKEY])) & ~ID_MASK))
1110                 return -EINVAL;
1111
1112         if (data[IFLA_GRE_OKEY] &&
1113             (ntohl(nla_get_be32(data[IFLA_GRE_OKEY])) & ~ID_MASK))
1114                 return -EINVAL;
1115
1116         return 0;
1117 }
1118
1119 static int ipgre_netlink_parms(struct net_device *dev,
1120                                 struct nlattr *data[],
1121                                 struct nlattr *tb[],
1122                                 struct ip_tunnel_parm *parms,
1123                                 __u32 *fwmark)
1124 {
1125         struct ip_tunnel *t = netdev_priv(dev);
1126
1127         memset(parms, 0, sizeof(*parms));
1128
1129         parms->iph.protocol = IPPROTO_GRE;
1130
1131         if (!data)
1132                 return 0;
1133
1134         if (data[IFLA_GRE_LINK])
1135                 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1136
1137         if (data[IFLA_GRE_IFLAGS])
1138                 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
1139
1140         if (data[IFLA_GRE_OFLAGS])
1141                 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
1142
1143         if (data[IFLA_GRE_IKEY])
1144                 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1145
1146         if (data[IFLA_GRE_OKEY])
1147                 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1148
1149         if (data[IFLA_GRE_LOCAL])
1150                 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
1151
1152         if (data[IFLA_GRE_REMOTE])
1153                 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
1154
1155         if (data[IFLA_GRE_TTL])
1156                 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1157
1158         if (data[IFLA_GRE_TOS])
1159                 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1160
1161         if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
1162                 if (t->ignore_df)
1163                         return -EINVAL;
1164                 parms->iph.frag_off = htons(IP_DF);
1165         }
1166
1167         if (data[IFLA_GRE_COLLECT_METADATA]) {
1168                 t->collect_md = true;
1169                 if (dev->type == ARPHRD_IPGRE)
1170                         dev->type = ARPHRD_NONE;
1171         }
1172
1173         if (data[IFLA_GRE_IGNORE_DF]) {
1174                 if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
1175                   && (parms->iph.frag_off & htons(IP_DF)))
1176                         return -EINVAL;
1177                 t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
1178         }
1179
1180         if (data[IFLA_GRE_FWMARK])
1181                 *fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
1182
1183         return 0;
1184 }
1185
1186 static int erspan_netlink_parms(struct net_device *dev,
1187                                 struct nlattr *data[],
1188                                 struct nlattr *tb[],
1189                                 struct ip_tunnel_parm *parms,
1190                                 __u32 *fwmark)
1191 {
1192         struct ip_tunnel *t = netdev_priv(dev);
1193         int err;
1194
1195         err = ipgre_netlink_parms(dev, data, tb, parms, fwmark);
1196         if (err)
1197                 return err;
1198         if (!data)
1199                 return 0;
1200
1201         if (data[IFLA_GRE_ERSPAN_VER]) {
1202                 t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1203
1204                 if (t->erspan_ver > 2)
1205                         return -EINVAL;
1206         }
1207
1208         if (t->erspan_ver == 1) {
1209                 if (data[IFLA_GRE_ERSPAN_INDEX]) {
1210                         t->index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]);
1211                         if (t->index & ~INDEX_MASK)
1212                                 return -EINVAL;
1213                 }
1214         } else if (t->erspan_ver == 2) {
1215                 if (data[IFLA_GRE_ERSPAN_DIR]) {
1216                         t->dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]);
1217                         if (t->dir & ~(DIR_MASK >> DIR_OFFSET))
1218                                 return -EINVAL;
1219                 }
1220                 if (data[IFLA_GRE_ERSPAN_HWID]) {
1221                         t->hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]);
1222                         if (t->hwid & ~(HWID_MASK >> HWID_OFFSET))
1223                                 return -EINVAL;
1224                 }
1225         }
1226
1227         return 0;
1228 }
1229
1230 /* This function returns true when ENCAP attributes are present in the nl msg */
1231 static bool ipgre_netlink_encap_parms(struct nlattr *data[],
1232                                       struct ip_tunnel_encap *ipencap)
1233 {
1234         bool ret = false;
1235
1236         memset(ipencap, 0, sizeof(*ipencap));
1237
1238         if (!data)
1239                 return ret;
1240
1241         if (data[IFLA_GRE_ENCAP_TYPE]) {
1242                 ret = true;
1243                 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
1244         }
1245
1246         if (data[IFLA_GRE_ENCAP_FLAGS]) {
1247                 ret = true;
1248                 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
1249         }
1250
1251         if (data[IFLA_GRE_ENCAP_SPORT]) {
1252                 ret = true;
1253                 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
1254         }
1255
1256         if (data[IFLA_GRE_ENCAP_DPORT]) {
1257                 ret = true;
1258                 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
1259         }
1260
1261         return ret;
1262 }
1263
1264 static int gre_tap_init(struct net_device *dev)
1265 {
1266         __gre_tunnel_init(dev);
1267         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1268         netif_keep_dst(dev);
1269
1270         return ip_tunnel_init(dev);
1271 }
1272
1273 static const struct net_device_ops gre_tap_netdev_ops = {
1274         .ndo_init               = gre_tap_init,
1275         .ndo_uninit             = ip_tunnel_uninit,
1276         .ndo_start_xmit         = gre_tap_xmit,
1277         .ndo_set_mac_address    = eth_mac_addr,
1278         .ndo_validate_addr      = eth_validate_addr,
1279         .ndo_change_mtu         = ip_tunnel_change_mtu,
1280         .ndo_get_stats64        = dev_get_tstats64,
1281         .ndo_get_iflink         = ip_tunnel_get_iflink,
1282         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1283 };
1284
1285 static int erspan_tunnel_init(struct net_device *dev)
1286 {
1287         struct ip_tunnel *tunnel = netdev_priv(dev);
1288
1289         if (tunnel->erspan_ver == 0)
1290                 tunnel->tun_hlen = 4; /* 4-byte GRE hdr. */
1291         else
1292                 tunnel->tun_hlen = 8; /* 8-byte GRE hdr. */
1293
1294         tunnel->parms.iph.protocol = IPPROTO_GRE;
1295         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen +
1296                        erspan_hdr_len(tunnel->erspan_ver);
1297
1298         dev->features           |= GRE_FEATURES;
1299         dev->hw_features        |= GRE_FEATURES;
1300         dev->priv_flags         |= IFF_LIVE_ADDR_CHANGE;
1301         netif_keep_dst(dev);
1302
1303         return ip_tunnel_init(dev);
1304 }
1305
1306 static const struct net_device_ops erspan_netdev_ops = {
1307         .ndo_init               = erspan_tunnel_init,
1308         .ndo_uninit             = ip_tunnel_uninit,
1309         .ndo_start_xmit         = erspan_xmit,
1310         .ndo_set_mac_address    = eth_mac_addr,
1311         .ndo_validate_addr      = eth_validate_addr,
1312         .ndo_change_mtu         = ip_tunnel_change_mtu,
1313         .ndo_get_stats64        = dev_get_tstats64,
1314         .ndo_get_iflink         = ip_tunnel_get_iflink,
1315         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1316 };
1317
1318 static void ipgre_tap_setup(struct net_device *dev)
1319 {
1320         ether_setup(dev);
1321         dev->max_mtu = 0;
1322         dev->netdev_ops = &gre_tap_netdev_ops;
1323         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1324         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1325         ip_tunnel_setup(dev, gre_tap_net_id);
1326 }
1327
1328 static int
1329 ipgre_newlink_encap_setup(struct net_device *dev, struct nlattr *data[])
1330 {
1331         struct ip_tunnel_encap ipencap;
1332
1333         if (ipgre_netlink_encap_parms(data, &ipencap)) {
1334                 struct ip_tunnel *t = netdev_priv(dev);
1335                 int err = ip_tunnel_encap_setup(t, &ipencap);
1336
1337                 if (err < 0)
1338                         return err;
1339         }
1340
1341         return 0;
1342 }
1343
1344 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
1345                          struct nlattr *tb[], struct nlattr *data[],
1346                          struct netlink_ext_ack *extack)
1347 {
1348         struct ip_tunnel_parm p;
1349         __u32 fwmark = 0;
1350         int err;
1351
1352         err = ipgre_newlink_encap_setup(dev, data);
1353         if (err)
1354                 return err;
1355
1356         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1357         if (err < 0)
1358                 return err;
1359         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1360 }
1361
1362 static int erspan_newlink(struct net *src_net, struct net_device *dev,
1363                           struct nlattr *tb[], struct nlattr *data[],
1364                           struct netlink_ext_ack *extack)
1365 {
1366         struct ip_tunnel_parm p;
1367         __u32 fwmark = 0;
1368         int err;
1369
1370         err = ipgre_newlink_encap_setup(dev, data);
1371         if (err)
1372                 return err;
1373
1374         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1375         if (err)
1376                 return err;
1377         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1378 }
1379
1380 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1381                             struct nlattr *data[],
1382                             struct netlink_ext_ack *extack)
1383 {
1384         struct ip_tunnel *t = netdev_priv(dev);
1385         __u32 fwmark = t->fwmark;
1386         struct ip_tunnel_parm p;
1387         int err;
1388
1389         err = ipgre_newlink_encap_setup(dev, data);
1390         if (err)
1391                 return err;
1392
1393         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1394         if (err < 0)
1395                 return err;
1396
1397         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1398         if (err < 0)
1399                 return err;
1400
1401         t->parms.i_flags = p.i_flags;
1402         t->parms.o_flags = p.o_flags;
1403
1404         ipgre_link_update(dev, !tb[IFLA_MTU]);
1405
1406         return 0;
1407 }
1408
1409 static int erspan_changelink(struct net_device *dev, struct nlattr *tb[],
1410                              struct nlattr *data[],
1411                              struct netlink_ext_ack *extack)
1412 {
1413         struct ip_tunnel *t = netdev_priv(dev);
1414         __u32 fwmark = t->fwmark;
1415         struct ip_tunnel_parm p;
1416         int err;
1417
1418         err = ipgre_newlink_encap_setup(dev, data);
1419         if (err)
1420                 return err;
1421
1422         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1423         if (err < 0)
1424                 return err;
1425
1426         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1427         if (err < 0)
1428                 return err;
1429
1430         t->parms.i_flags = p.i_flags;
1431         t->parms.o_flags = p.o_flags;
1432
1433         return 0;
1434 }
1435
1436 static size_t ipgre_get_size(const struct net_device *dev)
1437 {
1438         return
1439                 /* IFLA_GRE_LINK */
1440                 nla_total_size(4) +
1441                 /* IFLA_GRE_IFLAGS */
1442                 nla_total_size(2) +
1443                 /* IFLA_GRE_OFLAGS */
1444                 nla_total_size(2) +
1445                 /* IFLA_GRE_IKEY */
1446                 nla_total_size(4) +
1447                 /* IFLA_GRE_OKEY */
1448                 nla_total_size(4) +
1449                 /* IFLA_GRE_LOCAL */
1450                 nla_total_size(4) +
1451                 /* IFLA_GRE_REMOTE */
1452                 nla_total_size(4) +
1453                 /* IFLA_GRE_TTL */
1454                 nla_total_size(1) +
1455                 /* IFLA_GRE_TOS */
1456                 nla_total_size(1) +
1457                 /* IFLA_GRE_PMTUDISC */
1458                 nla_total_size(1) +
1459                 /* IFLA_GRE_ENCAP_TYPE */
1460                 nla_total_size(2) +
1461                 /* IFLA_GRE_ENCAP_FLAGS */
1462                 nla_total_size(2) +
1463                 /* IFLA_GRE_ENCAP_SPORT */
1464                 nla_total_size(2) +
1465                 /* IFLA_GRE_ENCAP_DPORT */
1466                 nla_total_size(2) +
1467                 /* IFLA_GRE_COLLECT_METADATA */
1468                 nla_total_size(0) +
1469                 /* IFLA_GRE_IGNORE_DF */
1470                 nla_total_size(1) +
1471                 /* IFLA_GRE_FWMARK */
1472                 nla_total_size(4) +
1473                 /* IFLA_GRE_ERSPAN_INDEX */
1474                 nla_total_size(4) +
1475                 /* IFLA_GRE_ERSPAN_VER */
1476                 nla_total_size(1) +
1477                 /* IFLA_GRE_ERSPAN_DIR */
1478                 nla_total_size(1) +
1479                 /* IFLA_GRE_ERSPAN_HWID */
1480                 nla_total_size(2) +
1481                 0;
1482 }
1483
1484 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1485 {
1486         struct ip_tunnel *t = netdev_priv(dev);
1487         struct ip_tunnel_parm *p = &t->parms;
1488         __be16 o_flags = p->o_flags;
1489
1490         if (t->erspan_ver <= 2) {
1491                 if (t->erspan_ver != 0 && !t->collect_md)
1492                         o_flags |= TUNNEL_KEY;
1493
1494                 if (nla_put_u8(skb, IFLA_GRE_ERSPAN_VER, t->erspan_ver))
1495                         goto nla_put_failure;
1496
1497                 if (t->erspan_ver == 1) {
1498                         if (nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, t->index))
1499                                 goto nla_put_failure;
1500                 } else if (t->erspan_ver == 2) {
1501                         if (nla_put_u8(skb, IFLA_GRE_ERSPAN_DIR, t->dir))
1502                                 goto nla_put_failure;
1503                         if (nla_put_u16(skb, IFLA_GRE_ERSPAN_HWID, t->hwid))
1504                                 goto nla_put_failure;
1505                 }
1506         }
1507
1508         if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1509             nla_put_be16(skb, IFLA_GRE_IFLAGS,
1510                          gre_tnl_flags_to_gre_flags(p->i_flags)) ||
1511             nla_put_be16(skb, IFLA_GRE_OFLAGS,
1512                          gre_tnl_flags_to_gre_flags(o_flags)) ||
1513             nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1514             nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1515             nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1516             nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1517             nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1518             nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1519             nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1520                        !!(p->iph.frag_off & htons(IP_DF))) ||
1521             nla_put_u32(skb, IFLA_GRE_FWMARK, t->fwmark))
1522                 goto nla_put_failure;
1523
1524         if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1525                         t->encap.type) ||
1526             nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1527                          t->encap.sport) ||
1528             nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1529                          t->encap.dport) ||
1530             nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1531                         t->encap.flags))
1532                 goto nla_put_failure;
1533
1534         if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
1535                 goto nla_put_failure;
1536
1537         if (t->collect_md) {
1538                 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1539                         goto nla_put_failure;
1540         }
1541
1542         return 0;
1543
1544 nla_put_failure:
1545         return -EMSGSIZE;
1546 }
1547
1548 static void erspan_setup(struct net_device *dev)
1549 {
1550         struct ip_tunnel *t = netdev_priv(dev);
1551
1552         ether_setup(dev);
1553         dev->max_mtu = 0;
1554         dev->netdev_ops = &erspan_netdev_ops;
1555         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1556         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1557         ip_tunnel_setup(dev, erspan_net_id);
1558         t->erspan_ver = 1;
1559 }
1560
1561 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1562         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
1563         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
1564         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
1565         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
1566         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
1567         [IFLA_GRE_LOCAL]        = { .len = sizeof_field(struct iphdr, saddr) },
1568         [IFLA_GRE_REMOTE]       = { .len = sizeof_field(struct iphdr, daddr) },
1569         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
1570         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
1571         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
1572         [IFLA_GRE_ENCAP_TYPE]   = { .type = NLA_U16 },
1573         [IFLA_GRE_ENCAP_FLAGS]  = { .type = NLA_U16 },
1574         [IFLA_GRE_ENCAP_SPORT]  = { .type = NLA_U16 },
1575         [IFLA_GRE_ENCAP_DPORT]  = { .type = NLA_U16 },
1576         [IFLA_GRE_COLLECT_METADATA]     = { .type = NLA_FLAG },
1577         [IFLA_GRE_IGNORE_DF]    = { .type = NLA_U8 },
1578         [IFLA_GRE_FWMARK]       = { .type = NLA_U32 },
1579         [IFLA_GRE_ERSPAN_INDEX] = { .type = NLA_U32 },
1580         [IFLA_GRE_ERSPAN_VER]   = { .type = NLA_U8 },
1581         [IFLA_GRE_ERSPAN_DIR]   = { .type = NLA_U8 },
1582         [IFLA_GRE_ERSPAN_HWID]  = { .type = NLA_U16 },
1583 };
1584
1585 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1586         .kind           = "gre",
1587         .maxtype        = IFLA_GRE_MAX,
1588         .policy         = ipgre_policy,
1589         .priv_size      = sizeof(struct ip_tunnel),
1590         .setup          = ipgre_tunnel_setup,
1591         .validate       = ipgre_tunnel_validate,
1592         .newlink        = ipgre_newlink,
1593         .changelink     = ipgre_changelink,
1594         .dellink        = ip_tunnel_dellink,
1595         .get_size       = ipgre_get_size,
1596         .fill_info      = ipgre_fill_info,
1597         .get_link_net   = ip_tunnel_get_link_net,
1598 };
1599
1600 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1601         .kind           = "gretap",
1602         .maxtype        = IFLA_GRE_MAX,
1603         .policy         = ipgre_policy,
1604         .priv_size      = sizeof(struct ip_tunnel),
1605         .setup          = ipgre_tap_setup,
1606         .validate       = ipgre_tap_validate,
1607         .newlink        = ipgre_newlink,
1608         .changelink     = ipgre_changelink,
1609         .dellink        = ip_tunnel_dellink,
1610         .get_size       = ipgre_get_size,
1611         .fill_info      = ipgre_fill_info,
1612         .get_link_net   = ip_tunnel_get_link_net,
1613 };
1614
1615 static struct rtnl_link_ops erspan_link_ops __read_mostly = {
1616         .kind           = "erspan",
1617         .maxtype        = IFLA_GRE_MAX,
1618         .policy         = ipgre_policy,
1619         .priv_size      = sizeof(struct ip_tunnel),
1620         .setup          = erspan_setup,
1621         .validate       = erspan_validate,
1622         .newlink        = erspan_newlink,
1623         .changelink     = erspan_changelink,
1624         .dellink        = ip_tunnel_dellink,
1625         .get_size       = ipgre_get_size,
1626         .fill_info      = ipgre_fill_info,
1627         .get_link_net   = ip_tunnel_get_link_net,
1628 };
1629
1630 struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1631                                         u8 name_assign_type)
1632 {
1633         struct nlattr *tb[IFLA_MAX + 1];
1634         struct net_device *dev;
1635         LIST_HEAD(list_kill);
1636         struct ip_tunnel *t;
1637         int err;
1638
1639         memset(&tb, 0, sizeof(tb));
1640
1641         dev = rtnl_create_link(net, name, name_assign_type,
1642                                &ipgre_tap_ops, tb, NULL);
1643         if (IS_ERR(dev))
1644                 return dev;
1645
1646         /* Configure flow based GRE device. */
1647         t = netdev_priv(dev);
1648         t->collect_md = true;
1649
1650         err = ipgre_newlink(net, dev, tb, NULL, NULL);
1651         if (err < 0) {
1652                 free_netdev(dev);
1653                 return ERR_PTR(err);
1654         }
1655
1656         /* openvswitch users expect packet sizes to be unrestricted,
1657          * so set the largest MTU we can.
1658          */
1659         err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
1660         if (err)
1661                 goto out;
1662
1663         err = rtnl_configure_link(dev, NULL);
1664         if (err < 0)
1665                 goto out;
1666
1667         return dev;
1668 out:
1669         ip_tunnel_dellink(dev, &list_kill);
1670         unregister_netdevice_many(&list_kill);
1671         return ERR_PTR(err);
1672 }
1673 EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1674
1675 static int __net_init ipgre_tap_init_net(struct net *net)
1676 {
1677         return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1678 }
1679
1680 static void __net_exit ipgre_tap_exit_batch_net(struct list_head *list_net)
1681 {
1682         ip_tunnel_delete_nets(list_net, gre_tap_net_id, &ipgre_tap_ops);
1683 }
1684
1685 static struct pernet_operations ipgre_tap_net_ops = {
1686         .init = ipgre_tap_init_net,
1687         .exit_batch = ipgre_tap_exit_batch_net,
1688         .id   = &gre_tap_net_id,
1689         .size = sizeof(struct ip_tunnel_net),
1690 };
1691
1692 static int __net_init erspan_init_net(struct net *net)
1693 {
1694         return ip_tunnel_init_net(net, erspan_net_id,
1695                                   &erspan_link_ops, "erspan0");
1696 }
1697
1698 static void __net_exit erspan_exit_batch_net(struct list_head *net_list)
1699 {
1700         ip_tunnel_delete_nets(net_list, erspan_net_id, &erspan_link_ops);
1701 }
1702
1703 static struct pernet_operations erspan_net_ops = {
1704         .init = erspan_init_net,
1705         .exit_batch = erspan_exit_batch_net,
1706         .id   = &erspan_net_id,
1707         .size = sizeof(struct ip_tunnel_net),
1708 };
1709
1710 static int __init ipgre_init(void)
1711 {
1712         int err;
1713
1714         pr_info("GRE over IPv4 tunneling driver\n");
1715
1716         err = register_pernet_device(&ipgre_net_ops);
1717         if (err < 0)
1718                 return err;
1719
1720         err = register_pernet_device(&ipgre_tap_net_ops);
1721         if (err < 0)
1722                 goto pnet_tap_failed;
1723
1724         err = register_pernet_device(&erspan_net_ops);
1725         if (err < 0)
1726                 goto pnet_erspan_failed;
1727
1728         err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1729         if (err < 0) {
1730                 pr_info("%s: can't add protocol\n", __func__);
1731                 goto add_proto_failed;
1732         }
1733
1734         err = rtnl_link_register(&ipgre_link_ops);
1735         if (err < 0)
1736                 goto rtnl_link_failed;
1737
1738         err = rtnl_link_register(&ipgre_tap_ops);
1739         if (err < 0)
1740                 goto tap_ops_failed;
1741
1742         err = rtnl_link_register(&erspan_link_ops);
1743         if (err < 0)
1744                 goto erspan_link_failed;
1745
1746         return 0;
1747
1748 erspan_link_failed:
1749         rtnl_link_unregister(&ipgre_tap_ops);
1750 tap_ops_failed:
1751         rtnl_link_unregister(&ipgre_link_ops);
1752 rtnl_link_failed:
1753         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1754 add_proto_failed:
1755         unregister_pernet_device(&erspan_net_ops);
1756 pnet_erspan_failed:
1757         unregister_pernet_device(&ipgre_tap_net_ops);
1758 pnet_tap_failed:
1759         unregister_pernet_device(&ipgre_net_ops);
1760         return err;
1761 }
1762
1763 static void __exit ipgre_fini(void)
1764 {
1765         rtnl_link_unregister(&ipgre_tap_ops);
1766         rtnl_link_unregister(&ipgre_link_ops);
1767         rtnl_link_unregister(&erspan_link_ops);
1768         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1769         unregister_pernet_device(&ipgre_tap_net_ops);
1770         unregister_pernet_device(&ipgre_net_ops);
1771         unregister_pernet_device(&erspan_net_ops);
1772 }
1773
1774 module_init(ipgre_init);
1775 module_exit(ipgre_fini);
1776 MODULE_LICENSE("GPL");
1777 MODULE_ALIAS_RTNL_LINK("gre");
1778 MODULE_ALIAS_RTNL_LINK("gretap");
1779 MODULE_ALIAS_RTNL_LINK("erspan");
1780 MODULE_ALIAS_NETDEV("gre0");
1781 MODULE_ALIAS_NETDEV("gretap0");
1782 MODULE_ALIAS_NETDEV("erspan0");