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