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         return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
 472 }
 473
 474 static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
 475                         __be16 proto)
 476 {
 477         struct ip_tunnel *tunnel = netdev_priv(dev);
 478         struct ip_tunnel_info *tun_info;
 479         const struct ip_tunnel_key *key;
 480         int tunnel_hlen;
 481         __be16 flags;
 482
 483         tun_info = skb_tunnel_info(skb);
 484         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 485                      ip_tunnel_info_af(tun_info) != AF_INET))
 486                 goto err_free_skb;
 487
 488         key = &tun_info->key;
 489         tunnel_hlen = gre_calc_hlen(key->tun_flags);
 490
 491         if (skb_cow_head(skb, dev->needed_headroom))
 492                 goto err_free_skb;
 493
 494         /* Push Tunnel header. */
 495         if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
 496                 goto err_free_skb;
 497
 498         flags = tun_info->key.tun_flags &
 499                 (TUNNEL_CSUM | TUNNEL_KEY | TUNNEL_SEQ);
 500         gre_build_header(skb, tunnel_hlen, flags, proto,
 501                          tunnel_id_to_key32(tun_info->key.tun_id),
 502                          (flags & TUNNEL_SEQ) ? htonl(tunnel->o_seqno++) : 0);
 503
 504         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 505
 506         return;
 507
 508 err_free_skb:
 509         kfree_skb(skb);
 510         dev->stats.tx_dropped++;
 511 }
 512
 513 static void erspan_fb_xmit(struct sk_buff *skb, struct net_device *dev)
 514 {
 515         struct ip_tunnel *tunnel = netdev_priv(dev);
 516         struct ip_tunnel_info *tun_info;
 517         const struct ip_tunnel_key *key;
 518         struct erspan_metadata *md;
 519         bool truncate = false;
 520         __be16 proto;
 521         int tunnel_hlen;
 522         int version;
 523         int nhoff;
 524         int thoff;
 525
 526         tun_info = skb_tunnel_info(skb);
 527         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 528                      ip_tunnel_info_af(tun_info) != AF_INET))
 529                 goto err_free_skb;
 530
 531         key = &tun_info->key;
 532         if (!(tun_info->key.tun_flags & TUNNEL_ERSPAN_OPT))
 533                 goto err_free_skb;
 534         if (tun_info->options_len < sizeof(*md))
 535                 goto err_free_skb;
 536         md = ip_tunnel_info_opts(tun_info);
 537
 538         /* ERSPAN has fixed 8 byte GRE header */
 539         version = md->version;
 540         tunnel_hlen = 8 + erspan_hdr_len(version);
 541
 542         if (skb_cow_head(skb, dev->needed_headroom))
 543                 goto err_free_skb;
 544
 545         if (gre_handle_offloads(skb, false))
 546                 goto err_free_skb;
 547
 548         if (skb->len > dev->mtu + dev->hard_header_len) {
 549                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 550                 truncate = true;
 551         }
 552
 553         nhoff = skb_network_header(skb) - skb_mac_header(skb);
 554         if (skb->protocol == htons(ETH_P_IP) &&
 555             (ntohs(ip_hdr(skb)->tot_len) > skb->len - nhoff))
 556                 truncate = true;
 557
 558         thoff = skb_transport_header(skb) - skb_mac_header(skb);
 559         if (skb->protocol == htons(ETH_P_IPV6) &&
 560             (ntohs(ipv6_hdr(skb)->payload_len) > skb->len - thoff))
 561                 truncate = true;
 562
 563         if (version == 1) {
 564                 erspan_build_header(skb, ntohl(tunnel_id_to_key32(key->tun_id)),
 565                                     ntohl(md->u.index), truncate, true);
 566                 proto = htons(ETH_P_ERSPAN);
 567         } else if (version == 2) {
 568                 erspan_build_header_v2(skb,
 569                                        ntohl(tunnel_id_to_key32(key->tun_id)),
 570                                        md->u.md2.dir,
 571                                        get_hwid(&md->u.md2),
 572                                        truncate, true);
 573                 proto = htons(ETH_P_ERSPAN2);
 574         } else {
 575                 goto err_free_skb;
 576         }
 577
 578         gre_build_header(skb, 8, TUNNEL_SEQ,
 579                          proto, 0, htonl(tunnel->o_seqno++));
 580
 581         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 582
 583         return;
 584
 585 err_free_skb:
 586         kfree_skb(skb);
 587         dev->stats.tx_dropped++;
 588 }
 589
 590 static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
 591 {
 592         struct ip_tunnel_info *info = skb_tunnel_info(skb);
 593         const struct ip_tunnel_key *key;
 594         struct rtable *rt;
 595         struct flowi4 fl4;
 596
 597         if (ip_tunnel_info_af(info) != AF_INET)
 598                 return -EINVAL;
 599
 600         key = &info->key;
 601         ip_tunnel_init_flow(&fl4, IPPROTO_GRE, key->u.ipv4.dst, key->u.ipv4.src,
 602                             tunnel_id_to_key32(key->tun_id), key->tos, 0,
 603                             skb->mark, skb_get_hash(skb));
 604         rt = ip_route_output_key(dev_net(dev), &fl4);
 605         if (IS_ERR(rt))
 606                 return PTR_ERR(rt);
 607
 608         ip_rt_put(rt);
 609         info->key.u.ipv4.src = fl4.saddr;
 610         return 0;
 611 }
 612
 613 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
 614                               struct net_device *dev)
 615 {
 616         struct ip_tunnel *tunnel = netdev_priv(dev);
 617         const struct iphdr *tnl_params;
 618
 619         if (!pskb_inet_may_pull(skb))
 620                 goto free_skb;
 621
 622         if (tunnel->collect_md) {
 623                 gre_fb_xmit(skb, dev, skb->protocol);
 624                 return NETDEV_TX_OK;
 625         }
 626
 627         if (dev->header_ops) {
 628                 if (skb_cow_head(skb, 0))
 629                         goto free_skb;
 630
 631                 tnl_params = (const struct iphdr *)skb->data;
 632
 633                 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
 634                  * to gre header.
 635                  */
 636                 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
 637                 skb_reset_mac_header(skb);
 638         } else {
 639                 if (skb_cow_head(skb, dev->needed_headroom))
 640                         goto free_skb;
 641
 642                 tnl_params = &tunnel->parms.iph;
 643         }
 644
 645         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 646                 goto free_skb;
 647
 648         __gre_xmit(skb, dev, tnl_params, skb->protocol);
 649         return NETDEV_TX_OK;
 650
 651 free_skb:
 652         kfree_skb(skb);
 653         dev->stats.tx_dropped++;
 654         return NETDEV_TX_OK;
 655 }
 656
 657 static netdev_tx_t erspan_xmit(struct sk_buff *skb,
 658                                struct net_device *dev)
 659 {
 660         struct ip_tunnel *tunnel = netdev_priv(dev);
 661         bool truncate = false;
 662         __be16 proto;
 663
 664         if (!pskb_inet_may_pull(skb))
 665                 goto free_skb;
 666
 667         if (tunnel->collect_md) {
 668                 erspan_fb_xmit(skb, dev);
 669                 return NETDEV_TX_OK;
 670         }
 671
 672         if (gre_handle_offloads(skb, false))
 673                 goto free_skb;
 674
 675         if (skb_cow_head(skb, dev->needed_headroom))
 676                 goto free_skb;
 677
 678         if (skb->len > dev->mtu + dev->hard_header_len) {
 679                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 680                 truncate = true;
 681         }
 682
 683         /* Push ERSPAN header */
 684         if (tunnel->erspan_ver == 0) {
 685                 proto = htons(ETH_P_ERSPAN);
 686                 tunnel->parms.o_flags &= ~TUNNEL_SEQ;
 687         } else if (tunnel->erspan_ver == 1) {
 688                 erspan_build_header(skb, ntohl(tunnel->parms.o_key),
 689                                     tunnel->index,
 690                                     truncate, true);
 691                 proto = htons(ETH_P_ERSPAN);
 692         } else if (tunnel->erspan_ver == 2) {
 693                 erspan_build_header_v2(skb, ntohl(tunnel->parms.o_key),
 694                                        tunnel->dir, tunnel->hwid,
 695                                        truncate, true);
 696                 proto = htons(ETH_P_ERSPAN2);
 697         } else {
 698                 goto free_skb;
 699         }
 700
 701         tunnel->parms.o_flags &= ~TUNNEL_KEY;
 702         __gre_xmit(skb, dev, &tunnel->parms.iph, proto);
 703         return NETDEV_TX_OK;
 704
 705 free_skb:
 706         kfree_skb(skb);
 707         dev->stats.tx_dropped++;
 708         return NETDEV_TX_OK;
 709 }
 710
 711 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
 712                                 struct net_device *dev)
 713 {
 714         struct ip_tunnel *tunnel = netdev_priv(dev);
 715
 716         if (!pskb_inet_may_pull(skb))
 717                 goto free_skb;
 718
 719         if (tunnel->collect_md) {
 720                 gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
 721                 return NETDEV_TX_OK;
 722         }
 723
 724         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 725                 goto free_skb;
 726
 727         if (skb_cow_head(skb, dev->needed_headroom))
 728                 goto free_skb;
 729
 730         __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
 731         return NETDEV_TX_OK;
 732
 733 free_skb:
 734         kfree_skb(skb);
 735         dev->stats.tx_dropped++;
 736         return NETDEV_TX_OK;
 737 }
 738
 739 static void ipgre_link_update(struct net_device *dev, bool set_mtu)
 740 {
 741         struct ip_tunnel *tunnel = netdev_priv(dev);
 742         int len;
 743
 744         len = tunnel->tun_hlen;
 745         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 746         len = tunnel->tun_hlen - len;
 747         tunnel->hlen = tunnel->hlen + len;
 748
 749         if (dev->header_ops)
 750                 dev->hard_header_len += len;
 751         else
 752                 dev->needed_headroom += len;
 753
 754         if (set_mtu)
 755                 dev->mtu = max_t(int, dev->mtu - len, 68);
 756
 757         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 758                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 759                     tunnel->encap.type == TUNNEL_ENCAP_NONE) {
 760                         dev->features |= NETIF_F_GSO_SOFTWARE;
 761                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 762                 } else {
 763                         dev->features &= ~NETIF_F_GSO_SOFTWARE;
 764                         dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 765                 }
 766                 dev->features |= NETIF_F_LLTX;
 767         } else {
 768                 dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 769                 dev->features &= ~(NETIF_F_LLTX | NETIF_F_GSO_SOFTWARE);
 770         }
 771 }
 772
 773 static int ipgre_tunnel_ctl(struct net_device *dev, struct ip_tunnel_parm *p,
 774                             int cmd)
 775 {
 776         int err;
 777
 778         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
 779                 if (p->iph.version != 4 || p->iph.protocol != IPPROTO_GRE ||
 780                     p->iph.ihl != 5 || (p->iph.frag_off & htons(~IP_DF)) ||
 781                     ((p->i_flags | p->o_flags) & (GRE_VERSION | GRE_ROUTING)))
 782                         return -EINVAL;
 783         }
 784
 785         p->i_flags = gre_flags_to_tnl_flags(p->i_flags);
 786         p->o_flags = gre_flags_to_tnl_flags(p->o_flags);
 787
 788         err = ip_tunnel_ctl(dev, p, cmd);
 789         if (err)
 790                 return err;
 791
 792         if (cmd == SIOCCHGTUNNEL) {
 793                 struct ip_tunnel *t = netdev_priv(dev);
 794
 795                 t->parms.i_flags = p->i_flags;
 796                 t->parms.o_flags = p->o_flags;
 797
 798                 if (strcmp(dev->rtnl_link_ops->kind, "erspan"))
 799                         ipgre_link_update(dev, true);
 800         }
 801
 802         p->i_flags = gre_tnl_flags_to_gre_flags(p->i_flags);
 803         p->o_flags = gre_tnl_flags_to_gre_flags(p->o_flags);
 804         return 0;
 805 }
 806
 807 /* Nice toy. Unfortunately, useless in real life :-)
 808    It allows to construct virtual multiprotocol broadcast "LAN"
 809    over the Internet, provided multicast routing is tuned.
 810
 811
 812    I have no idea was this bicycle invented before me,
 813    so that I had to set ARPHRD_IPGRE to a random value.
 814    I have an impression, that Cisco could make something similar,
 815    but this feature is apparently missing in IOS<=11.2(8).
 816
 817    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
 818    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
 819
 820    ping -t 255 224.66.66.66
 821
 822    If nobody answers, mbone does not work.
 823
 824    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
 825    ip addr add 10.66.66.<somewhat>/24 dev Universe
 826    ifconfig Universe up
 827    ifconfig Universe add fe80::<Your_real_addr>/10
 828    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
 829    ftp 10.66.66.66
 830    ...
 831    ftp fec0:6666:6666::193.233.7.65
 832    ...
 833  */
 834 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
 835                         unsigned short type,
 836                         const void *daddr, const void *saddr, unsigned int len)
 837 {
 838         struct ip_tunnel *t = netdev_priv(dev);
 839         struct iphdr *iph;
 840         struct gre_base_hdr *greh;
 841
 842         iph = skb_push(skb, t->hlen + sizeof(*iph));
 843         greh = (struct gre_base_hdr *)(iph+1);
 844         greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
 845         greh->protocol = htons(type);
 846
 847         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
 848
 849         /* Set the source hardware address. */
 850         if (saddr)
 851                 memcpy(&iph->saddr, saddr, 4);
 852         if (daddr)
 853                 memcpy(&iph->daddr, daddr, 4);
 854         if (iph->daddr)
 855                 return t->hlen + sizeof(*iph);
 856
 857         return -(t->hlen + sizeof(*iph));
 858 }
 859
 860 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
 861 {
 862         const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
 863         memcpy(haddr, &iph->saddr, 4);
 864         return 4;
 865 }
 866
 867 static const struct header_ops ipgre_header_ops = {
 868         .create = ipgre_header,
 869         .parse  = ipgre_header_parse,
 870 };
 871
 872 #ifdef CONFIG_NET_IPGRE_BROADCAST
 873 static int ipgre_open(struct net_device *dev)
 874 {
 875         struct ip_tunnel *t = netdev_priv(dev);
 876
 877         if (ipv4_is_multicast(t->parms.iph.daddr)) {
 878                 struct flowi4 fl4;
 879                 struct rtable *rt;
 880
 881                 rt = ip_route_output_gre(t->net, &fl4,
 882                                          t->parms.iph.daddr,
 883                                          t->parms.iph.saddr,
 884                                          t->parms.o_key,
 885                                          RT_TOS(t->parms.iph.tos),
 886                                          t->parms.link);
 887                 if (IS_ERR(rt))
 888                         return -EADDRNOTAVAIL;
 889                 dev = rt->dst.dev;
 890                 ip_rt_put(rt);
 891                 if (!__in_dev_get_rtnl(dev))
 892                         return -EADDRNOTAVAIL;
 893                 t->mlink = dev->ifindex;
 894                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
 895         }
 896         return 0;
 897 }
 898
 899 static int ipgre_close(struct net_device *dev)
 900 {
 901         struct ip_tunnel *t = netdev_priv(dev);
 902
 903         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
 904                 struct in_device *in_dev;
 905                 in_dev = inetdev_by_index(t->net, t->mlink);
 906                 if (in_dev)
 907                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 908         }
 909         return 0;
 910 }
 911 #endif
 912
 913 static const struct net_device_ops ipgre_netdev_ops = {
 914         .ndo_init               = ipgre_tunnel_init,
 915         .ndo_uninit             = ip_tunnel_uninit,
 916 #ifdef CONFIG_NET_IPGRE_BROADCAST
 917         .ndo_open               = ipgre_open,
 918         .ndo_stop               = ipgre_close,
 919 #endif
 920         .ndo_start_xmit         = ipgre_xmit,
 921         .ndo_do_ioctl           = ip_tunnel_ioctl,
 922         .ndo_change_mtu         = ip_tunnel_change_mtu,
 923         .ndo_get_stats64        = ip_tunnel_get_stats64,
 924         .ndo_get_iflink         = ip_tunnel_get_iflink,
 925         .ndo_tunnel_ctl         = ipgre_tunnel_ctl,
 926 };
 927
 928 #define GRE_FEATURES (NETIF_F_SG |              \
 929                       NETIF_F_FRAGLIST |        \
 930                       NETIF_F_HIGHDMA |         \
 931                       NETIF_F_HW_CSUM)
 932
 933 static void ipgre_tunnel_setup(struct net_device *dev)
 934 {
 935         dev->netdev_ops         = &ipgre_netdev_ops;
 936         dev->type               = ARPHRD_IPGRE;
 937         ip_tunnel_setup(dev, ipgre_net_id);
 938 }
 939
 940 static void __gre_tunnel_init(struct net_device *dev)
 941 {
 942         struct ip_tunnel *tunnel;
 943
 944         tunnel = netdev_priv(dev);
 945         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 946         tunnel->parms.iph.protocol = IPPROTO_GRE;
 947
 948         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 949         dev->needed_headroom = tunnel->hlen + sizeof(tunnel->parms.iph);
 950
 951         dev->features           |= GRE_FEATURES;
 952         dev->hw_features        |= GRE_FEATURES;
 953
 954         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 955                 /* TCP offload with GRE SEQ is not supported, nor
 956                  * can we support 2 levels of outer headers requiring
 957                  * an update.
 958                  */
 959                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 960                     (tunnel->encap.type == TUNNEL_ENCAP_NONE)) {
 961                         dev->features    |= NETIF_F_GSO_SOFTWARE;
 962                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 963                 }
 964
 965                 /* Can use a lockless transmit, unless we generate
 966                  * output sequences
 967                  */
 968                 dev->features |= NETIF_F_LLTX;
 969         }
 970 }
 971
 972 static int ipgre_tunnel_init(struct net_device *dev)
 973 {
 974         struct ip_tunnel *tunnel = netdev_priv(dev);
 975         struct iphdr *iph = &tunnel->parms.iph;
 976
 977         __gre_tunnel_init(dev);
 978
 979         memcpy(dev->dev_addr, &iph->saddr, 4);
 980         memcpy(dev->broadcast, &iph->daddr, 4);
 981
 982         dev->flags              = IFF_NOARP;
 983         netif_keep_dst(dev);
 984         dev->addr_len           = 4;
 985
 986         if (iph->daddr && !tunnel->collect_md) {
 987 #ifdef CONFIG_NET_IPGRE_BROADCAST
 988                 if (ipv4_is_multicast(iph->daddr)) {
 989                         if (!iph->saddr)
 990                                 return -EINVAL;
 991                         dev->flags = IFF_BROADCAST;
 992                         dev->header_ops = &ipgre_header_ops;
 993                         dev->hard_header_len = tunnel->hlen + sizeof(*iph);
 994                         dev->needed_headroom = 0;
 995                 }
 996 #endif
 997         } else if (!tunnel->collect_md) {
 998                 dev->header_ops = &ipgre_header_ops;
 999                 dev->hard_header_len = tunnel->hlen + sizeof(*iph);
1000                 dev->needed_headroom = 0;
1001         }
1002
1003         return ip_tunnel_init(dev);
1004 }
1005
1006 static const struct gre_protocol ipgre_protocol = {
1007         .handler     = gre_rcv,
1008         .err_handler = gre_err,
1009 };
1010
1011 static int __net_init ipgre_init_net(struct net *net)
1012 {
1013         return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
1014 }
1015
1016 static void __net_exit ipgre_exit_batch_net(struct list_head *list_net)
1017 {
1018         ip_tunnel_delete_nets(list_net, ipgre_net_id, &ipgre_link_ops);
1019 }
1020
1021 static struct pernet_operations ipgre_net_ops = {
1022         .init = ipgre_init_net,
1023         .exit_batch = ipgre_exit_batch_net,
1024         .id   = &ipgre_net_id,
1025         .size = sizeof(struct ip_tunnel_net),
1026 };
1027
1028 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
1029                                  struct netlink_ext_ack *extack)
1030 {
1031         __be16 flags;
1032
1033         if (!data)
1034                 return 0;
1035
1036         flags = 0;
1037         if (data[IFLA_GRE_IFLAGS])
1038                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1039         if (data[IFLA_GRE_OFLAGS])
1040                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1041         if (flags & (GRE_VERSION|GRE_ROUTING))
1042                 return -EINVAL;
1043
1044         if (data[IFLA_GRE_COLLECT_METADATA] &&
1045             data[IFLA_GRE_ENCAP_TYPE] &&
1046             nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
1047                 return -EINVAL;
1048
1049         return 0;
1050 }
1051
1052 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
1053                               struct netlink_ext_ack *extack)
1054 {
1055         __be32 daddr;
1056
1057         if (tb[IFLA_ADDRESS]) {
1058                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1059                         return -EINVAL;
1060                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1061                         return -EADDRNOTAVAIL;
1062         }
1063
1064         if (!data)
1065                 goto out;
1066
1067         if (data[IFLA_GRE_REMOTE]) {
1068                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1069                 if (!daddr)
1070                         return -EINVAL;
1071         }
1072
1073 out:
1074         return ipgre_tunnel_validate(tb, data, extack);
1075 }
1076
1077 static int erspan_validate(struct nlattr *tb[], struct nlattr *data[],
1078                            struct netlink_ext_ack *extack)
1079 {
1080         __be16 flags = 0;
1081         int ret;
1082
1083         if (!data)
1084                 return 0;
1085
1086         ret = ipgre_tap_validate(tb, data, extack);
1087         if (ret)
1088                 return ret;
1089
1090         if (data[IFLA_GRE_ERSPAN_VER] &&
1091             nla_get_u8(data[IFLA_GRE_ERSPAN_VER]) == 0)
1092                 return 0;
1093
1094         /* ERSPAN type II/III should only have GRE sequence and key flag */
1095         if (data[IFLA_GRE_OFLAGS])
1096                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1097         if (data[IFLA_GRE_IFLAGS])
1098                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1099         if (!data[IFLA_GRE_COLLECT_METADATA] &&
1100             flags != (GRE_SEQ | GRE_KEY))
1101                 return -EINVAL;
1102
1103         /* ERSPAN Session ID only has 10-bit. Since we reuse
1104          * 32-bit key field as ID, check it's range.
1105          */
1106         if (data[IFLA_GRE_IKEY] &&
1107             (ntohl(nla_get_be32(data[IFLA_GRE_IKEY])) & ~ID_MASK))
1108                 return -EINVAL;
1109
1110         if (data[IFLA_GRE_OKEY] &&
1111             (ntohl(nla_get_be32(data[IFLA_GRE_OKEY])) & ~ID_MASK))
1112                 return -EINVAL;
1113
1114         return 0;
1115 }
1116
1117 static int ipgre_netlink_parms(struct net_device *dev,
1118                                 struct nlattr *data[],
1119                                 struct nlattr *tb[],
1120                                 struct ip_tunnel_parm *parms,
1121                                 __u32 *fwmark)
1122 {
1123         struct ip_tunnel *t = netdev_priv(dev);
1124
1125         memset(parms, 0, sizeof(*parms));
1126
1127         parms->iph.protocol = IPPROTO_GRE;
1128
1129         if (!data)
1130                 return 0;
1131
1132         if (data[IFLA_GRE_LINK])
1133                 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1134
1135         if (data[IFLA_GRE_IFLAGS])
1136                 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
1137
1138         if (data[IFLA_GRE_OFLAGS])
1139                 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
1140
1141         if (data[IFLA_GRE_IKEY])
1142                 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1143
1144         if (data[IFLA_GRE_OKEY])
1145                 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1146
1147         if (data[IFLA_GRE_LOCAL])
1148                 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
1149
1150         if (data[IFLA_GRE_REMOTE])
1151                 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
1152
1153         if (data[IFLA_GRE_TTL])
1154                 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1155
1156         if (data[IFLA_GRE_TOS])
1157                 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1158
1159         if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
1160                 if (t->ignore_df)
1161                         return -EINVAL;
1162                 parms->iph.frag_off = htons(IP_DF);
1163         }
1164
1165         if (data[IFLA_GRE_COLLECT_METADATA]) {
1166                 t->collect_md = true;
1167                 if (dev->type == ARPHRD_IPGRE)
1168                         dev->type = ARPHRD_NONE;
1169         }
1170
1171         if (data[IFLA_GRE_IGNORE_DF]) {
1172                 if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
1173                   && (parms->iph.frag_off & htons(IP_DF)))
1174                         return -EINVAL;
1175                 t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
1176         }
1177
1178         if (data[IFLA_GRE_FWMARK])
1179                 *fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
1180
1181         return 0;
1182 }
1183
1184 static int erspan_netlink_parms(struct net_device *dev,
1185                                 struct nlattr *data[],
1186                                 struct nlattr *tb[],
1187                                 struct ip_tunnel_parm *parms,
1188                                 __u32 *fwmark)
1189 {
1190         struct ip_tunnel *t = netdev_priv(dev);
1191         int err;
1192
1193         err = ipgre_netlink_parms(dev, data, tb, parms, fwmark);
1194         if (err)
1195                 return err;
1196         if (!data)
1197                 return 0;
1198
1199         if (data[IFLA_GRE_ERSPAN_VER]) {
1200                 t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1201
1202                 if (t->erspan_ver > 2)
1203                         return -EINVAL;
1204         }
1205
1206         if (t->erspan_ver == 1) {
1207                 if (data[IFLA_GRE_ERSPAN_INDEX]) {
1208                         t->index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]);
1209                         if (t->index & ~INDEX_MASK)
1210                                 return -EINVAL;
1211                 }
1212         } else if (t->erspan_ver == 2) {
1213                 if (data[IFLA_GRE_ERSPAN_DIR]) {
1214                         t->dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]);
1215                         if (t->dir & ~(DIR_MASK >> DIR_OFFSET))
1216                                 return -EINVAL;
1217                 }
1218                 if (data[IFLA_GRE_ERSPAN_HWID]) {
1219                         t->hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]);
1220                         if (t->hwid & ~(HWID_MASK >> HWID_OFFSET))
1221                                 return -EINVAL;
1222                 }
1223         }
1224
1225         return 0;
1226 }
1227
1228 /* This function returns true when ENCAP attributes are present in the nl msg */
1229 static bool ipgre_netlink_encap_parms(struct nlattr *data[],
1230                                       struct ip_tunnel_encap *ipencap)
1231 {
1232         bool ret = false;
1233
1234         memset(ipencap, 0, sizeof(*ipencap));
1235
1236         if (!data)
1237                 return ret;
1238
1239         if (data[IFLA_GRE_ENCAP_TYPE]) {
1240                 ret = true;
1241                 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
1242         }
1243
1244         if (data[IFLA_GRE_ENCAP_FLAGS]) {
1245                 ret = true;
1246                 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
1247         }
1248
1249         if (data[IFLA_GRE_ENCAP_SPORT]) {
1250                 ret = true;
1251                 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
1252         }
1253
1254         if (data[IFLA_GRE_ENCAP_DPORT]) {
1255                 ret = true;
1256                 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
1257         }
1258
1259         return ret;
1260 }
1261
1262 static int gre_tap_init(struct net_device *dev)
1263 {
1264         __gre_tunnel_init(dev);
1265         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1266         netif_keep_dst(dev);
1267
1268         return ip_tunnel_init(dev);
1269 }
1270
1271 static const struct net_device_ops gre_tap_netdev_ops = {
1272         .ndo_init               = gre_tap_init,
1273         .ndo_uninit             = ip_tunnel_uninit,
1274         .ndo_start_xmit         = gre_tap_xmit,
1275         .ndo_set_mac_address    = eth_mac_addr,
1276         .ndo_validate_addr      = eth_validate_addr,
1277         .ndo_change_mtu         = ip_tunnel_change_mtu,
1278         .ndo_get_stats64        = ip_tunnel_get_stats64,
1279         .ndo_get_iflink         = ip_tunnel_get_iflink,
1280         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1281 };
1282
1283 static int erspan_tunnel_init(struct net_device *dev)
1284 {
1285         struct ip_tunnel *tunnel = netdev_priv(dev);
1286
1287         if (tunnel->erspan_ver == 0)
1288                 tunnel->tun_hlen = 4; /* 4-byte GRE hdr. */
1289         else
1290                 tunnel->tun_hlen = 8; /* 8-byte GRE hdr. */
1291
1292         tunnel->parms.iph.protocol = IPPROTO_GRE;
1293         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen +
1294                        erspan_hdr_len(tunnel->erspan_ver);
1295
1296         dev->features           |= GRE_FEATURES;
1297         dev->hw_features        |= GRE_FEATURES;
1298         dev->priv_flags         |= IFF_LIVE_ADDR_CHANGE;
1299         netif_keep_dst(dev);
1300
1301         return ip_tunnel_init(dev);
1302 }
1303
1304 static const struct net_device_ops erspan_netdev_ops = {
1305         .ndo_init               = erspan_tunnel_init,
1306         .ndo_uninit             = ip_tunnel_uninit,
1307         .ndo_start_xmit         = erspan_xmit,
1308         .ndo_set_mac_address    = eth_mac_addr,
1309         .ndo_validate_addr      = eth_validate_addr,
1310         .ndo_change_mtu         = ip_tunnel_change_mtu,
1311         .ndo_get_stats64        = ip_tunnel_get_stats64,
1312         .ndo_get_iflink         = ip_tunnel_get_iflink,
1313         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1314 };
1315
1316 static void ipgre_tap_setup(struct net_device *dev)
1317 {
1318         ether_setup(dev);
1319         dev->max_mtu = 0;
1320         dev->netdev_ops = &gre_tap_netdev_ops;
1321         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1322         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1323         ip_tunnel_setup(dev, gre_tap_net_id);
1324 }
1325
1326 static int
1327 ipgre_newlink_encap_setup(struct net_device *dev, struct nlattr *data[])
1328 {
1329         struct ip_tunnel_encap ipencap;
1330
1331         if (ipgre_netlink_encap_parms(data, &ipencap)) {
1332                 struct ip_tunnel *t = netdev_priv(dev);
1333                 int err = ip_tunnel_encap_setup(t, &ipencap);
1334
1335                 if (err < 0)
1336                         return err;
1337         }
1338
1339         return 0;
1340 }
1341
1342 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
1343                          struct nlattr *tb[], struct nlattr *data[],
1344                          struct netlink_ext_ack *extack)
1345 {
1346         struct ip_tunnel_parm p;
1347         __u32 fwmark = 0;
1348         int err;
1349
1350         err = ipgre_newlink_encap_setup(dev, data);
1351         if (err)
1352                 return err;
1353
1354         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1355         if (err < 0)
1356                 return err;
1357         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1358 }
1359
1360 static int erspan_newlink(struct net *src_net, struct net_device *dev,
1361                           struct nlattr *tb[], struct nlattr *data[],
1362                           struct netlink_ext_ack *extack)
1363 {
1364         struct ip_tunnel_parm p;
1365         __u32 fwmark = 0;
1366         int err;
1367
1368         err = ipgre_newlink_encap_setup(dev, data);
1369         if (err)
1370                 return err;
1371
1372         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1373         if (err)
1374                 return err;
1375         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1376 }
1377
1378 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1379                             struct nlattr *data[],
1380                             struct netlink_ext_ack *extack)
1381 {
1382         struct ip_tunnel *t = netdev_priv(dev);
1383         __u32 fwmark = t->fwmark;
1384         struct ip_tunnel_parm p;
1385         int err;
1386
1387         err = ipgre_newlink_encap_setup(dev, data);
1388         if (err)
1389                 return err;
1390
1391         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1392         if (err < 0)
1393                 return err;
1394
1395         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1396         if (err < 0)
1397                 return err;
1398
1399         t->parms.i_flags = p.i_flags;
1400         t->parms.o_flags = p.o_flags;
1401
1402         ipgre_link_update(dev, !tb[IFLA_MTU]);
1403
1404         return 0;
1405 }
1406
1407 static int erspan_changelink(struct net_device *dev, struct nlattr *tb[],
1408                              struct nlattr *data[],
1409                              struct netlink_ext_ack *extack)
1410 {
1411         struct ip_tunnel *t = netdev_priv(dev);
1412         __u32 fwmark = t->fwmark;
1413         struct ip_tunnel_parm p;
1414         int err;
1415
1416         err = ipgre_newlink_encap_setup(dev, data);
1417         if (err)
1418                 return err;
1419
1420         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1421         if (err < 0)
1422                 return err;
1423
1424         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1425         if (err < 0)
1426                 return err;
1427
1428         t->parms.i_flags = p.i_flags;
1429         t->parms.o_flags = p.o_flags;
1430
1431         return 0;
1432 }
1433
1434 static size_t ipgre_get_size(const struct net_device *dev)
1435 {
1436         return
1437                 /* IFLA_GRE_LINK */
1438                 nla_total_size(4) +
1439                 /* IFLA_GRE_IFLAGS */
1440                 nla_total_size(2) +
1441                 /* IFLA_GRE_OFLAGS */
1442                 nla_total_size(2) +
1443                 /* IFLA_GRE_IKEY */
1444                 nla_total_size(4) +
1445                 /* IFLA_GRE_OKEY */
1446                 nla_total_size(4) +
1447                 /* IFLA_GRE_LOCAL */
1448                 nla_total_size(4) +
1449                 /* IFLA_GRE_REMOTE */
1450                 nla_total_size(4) +
1451                 /* IFLA_GRE_TTL */
1452                 nla_total_size(1) +
1453                 /* IFLA_GRE_TOS */
1454                 nla_total_size(1) +
1455                 /* IFLA_GRE_PMTUDISC */
1456                 nla_total_size(1) +
1457                 /* IFLA_GRE_ENCAP_TYPE */
1458                 nla_total_size(2) +
1459                 /* IFLA_GRE_ENCAP_FLAGS */
1460                 nla_total_size(2) +
1461                 /* IFLA_GRE_ENCAP_SPORT */
1462                 nla_total_size(2) +
1463                 /* IFLA_GRE_ENCAP_DPORT */
1464                 nla_total_size(2) +
1465                 /* IFLA_GRE_COLLECT_METADATA */
1466                 nla_total_size(0) +
1467                 /* IFLA_GRE_IGNORE_DF */
1468                 nla_total_size(1) +
1469                 /* IFLA_GRE_FWMARK */
1470                 nla_total_size(4) +
1471                 /* IFLA_GRE_ERSPAN_INDEX */
1472                 nla_total_size(4) +
1473                 /* IFLA_GRE_ERSPAN_VER */
1474                 nla_total_size(1) +
1475                 /* IFLA_GRE_ERSPAN_DIR */
1476                 nla_total_size(1) +
1477                 /* IFLA_GRE_ERSPAN_HWID */
1478                 nla_total_size(2) +
1479                 0;
1480 }
1481
1482 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1483 {
1484         struct ip_tunnel *t = netdev_priv(dev);
1485         struct ip_tunnel_parm *p = &t->parms;
1486         __be16 o_flags = p->o_flags;
1487
1488         if (t->erspan_ver <= 2) {
1489                 if (t->erspan_ver != 0 && !t->collect_md)
1490                         o_flags |= TUNNEL_KEY;
1491
1492                 if (nla_put_u8(skb, IFLA_GRE_ERSPAN_VER, t->erspan_ver))
1493                         goto nla_put_failure;
1494
1495                 if (t->erspan_ver == 1) {
1496                         if (nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, t->index))
1497                                 goto nla_put_failure;
1498                 } else if (t->erspan_ver == 2) {
1499                         if (nla_put_u8(skb, IFLA_GRE_ERSPAN_DIR, t->dir))
1500                                 goto nla_put_failure;
1501                         if (nla_put_u16(skb, IFLA_GRE_ERSPAN_HWID, t->hwid))
1502                                 goto nla_put_failure;
1503                 }
1504         }
1505
1506         if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1507             nla_put_be16(skb, IFLA_GRE_IFLAGS,
1508                          gre_tnl_flags_to_gre_flags(p->i_flags)) ||
1509             nla_put_be16(skb, IFLA_GRE_OFLAGS,
1510                          gre_tnl_flags_to_gre_flags(o_flags)) ||
1511             nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1512             nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1513             nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1514             nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1515             nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1516             nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1517             nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1518                        !!(p->iph.frag_off & htons(IP_DF))) ||
1519             nla_put_u32(skb, IFLA_GRE_FWMARK, t->fwmark))
1520                 goto nla_put_failure;
1521
1522         if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1523                         t->encap.type) ||
1524             nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1525                          t->encap.sport) ||
1526             nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1527                          t->encap.dport) ||
1528             nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1529                         t->encap.flags))
1530                 goto nla_put_failure;
1531
1532         if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
1533                 goto nla_put_failure;
1534
1535         if (t->collect_md) {
1536                 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1537                         goto nla_put_failure;
1538         }
1539
1540         return 0;
1541
1542 nla_put_failure:
1543         return -EMSGSIZE;
1544 }
1545
1546 static void erspan_setup(struct net_device *dev)
1547 {
1548         struct ip_tunnel *t = netdev_priv(dev);
1549
1550         ether_setup(dev);
1551         dev->max_mtu = 0;
1552         dev->netdev_ops = &erspan_netdev_ops;
1553         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1554         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1555         ip_tunnel_setup(dev, erspan_net_id);
1556         t->erspan_ver = 1;
1557 }
1558
1559 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1560         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
1561         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
1562         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
1563         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
1564         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
1565         [IFLA_GRE_LOCAL]        = { .len = sizeof_field(struct iphdr, saddr) },
1566         [IFLA_GRE_REMOTE]       = { .len = sizeof_field(struct iphdr, daddr) },
1567         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
1568         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
1569         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
1570         [IFLA_GRE_ENCAP_TYPE]   = { .type = NLA_U16 },
1571         [IFLA_GRE_ENCAP_FLAGS]  = { .type = NLA_U16 },
1572         [IFLA_GRE_ENCAP_SPORT]  = { .type = NLA_U16 },
1573         [IFLA_GRE_ENCAP_DPORT]  = { .type = NLA_U16 },
1574         [IFLA_GRE_COLLECT_METADATA]     = { .type = NLA_FLAG },
1575         [IFLA_GRE_IGNORE_DF]    = { .type = NLA_U8 },
1576         [IFLA_GRE_FWMARK]       = { .type = NLA_U32 },
1577         [IFLA_GRE_ERSPAN_INDEX] = { .type = NLA_U32 },
1578         [IFLA_GRE_ERSPAN_VER]   = { .type = NLA_U8 },
1579         [IFLA_GRE_ERSPAN_DIR]   = { .type = NLA_U8 },
1580         [IFLA_GRE_ERSPAN_HWID]  = { .type = NLA_U16 },
1581 };
1582
1583 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1584         .kind           = "gre",
1585         .maxtype        = IFLA_GRE_MAX,
1586         .policy         = ipgre_policy,
1587         .priv_size      = sizeof(struct ip_tunnel),
1588         .setup          = ipgre_tunnel_setup,
1589         .validate       = ipgre_tunnel_validate,
1590         .newlink        = ipgre_newlink,
1591         .changelink     = ipgre_changelink,
1592         .dellink        = ip_tunnel_dellink,
1593         .get_size       = ipgre_get_size,
1594         .fill_info      = ipgre_fill_info,
1595         .get_link_net   = ip_tunnel_get_link_net,
1596 };
1597
1598 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1599         .kind           = "gretap",
1600         .maxtype        = IFLA_GRE_MAX,
1601         .policy         = ipgre_policy,
1602         .priv_size      = sizeof(struct ip_tunnel),
1603         .setup          = ipgre_tap_setup,
1604         .validate       = ipgre_tap_validate,
1605         .newlink        = ipgre_newlink,
1606         .changelink     = ipgre_changelink,
1607         .dellink        = ip_tunnel_dellink,
1608         .get_size       = ipgre_get_size,
1609         .fill_info      = ipgre_fill_info,
1610         .get_link_net   = ip_tunnel_get_link_net,
1611 };
1612
1613 static struct rtnl_link_ops erspan_link_ops __read_mostly = {
1614         .kind           = "erspan",
1615         .maxtype        = IFLA_GRE_MAX,
1616         .policy         = ipgre_policy,
1617         .priv_size      = sizeof(struct ip_tunnel),
1618         .setup          = erspan_setup,
1619         .validate       = erspan_validate,
1620         .newlink        = erspan_newlink,
1621         .changelink     = erspan_changelink,
1622         .dellink        = ip_tunnel_dellink,
1623         .get_size       = ipgre_get_size,
1624         .fill_info      = ipgre_fill_info,
1625         .get_link_net   = ip_tunnel_get_link_net,
1626 };
1627
1628 struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1629                                         u8 name_assign_type)
1630 {
1631         struct nlattr *tb[IFLA_MAX + 1];
1632         struct net_device *dev;
1633         LIST_HEAD(list_kill);
1634         struct ip_tunnel *t;
1635         int err;
1636
1637         memset(&tb, 0, sizeof(tb));
1638
1639         dev = rtnl_create_link(net, name, name_assign_type,
1640                                &ipgre_tap_ops, tb, NULL);
1641         if (IS_ERR(dev))
1642                 return dev;
1643
1644         /* Configure flow based GRE device. */
1645         t = netdev_priv(dev);
1646         t->collect_md = true;
1647
1648         err = ipgre_newlink(net, dev, tb, NULL, NULL);
1649         if (err < 0) {
1650                 free_netdev(dev);
1651                 return ERR_PTR(err);
1652         }
1653
1654         /* openvswitch users expect packet sizes to be unrestricted,
1655          * so set the largest MTU we can.
1656          */
1657         err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
1658         if (err)
1659                 goto out;
1660
1661         err = rtnl_configure_link(dev, NULL);
1662         if (err < 0)
1663                 goto out;
1664
1665         return dev;
1666 out:
1667         ip_tunnel_dellink(dev, &list_kill);
1668         unregister_netdevice_many(&list_kill);
1669         return ERR_PTR(err);
1670 }
1671 EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1672
1673 static int __net_init ipgre_tap_init_net(struct net *net)
1674 {
1675         return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1676 }
1677
1678 static void __net_exit ipgre_tap_exit_batch_net(struct list_head *list_net)
1679 {
1680         ip_tunnel_delete_nets(list_net, gre_tap_net_id, &ipgre_tap_ops);
1681 }
1682
1683 static struct pernet_operations ipgre_tap_net_ops = {
1684         .init = ipgre_tap_init_net,
1685         .exit_batch = ipgre_tap_exit_batch_net,
1686         .id   = &gre_tap_net_id,
1687         .size = sizeof(struct ip_tunnel_net),
1688 };
1689
1690 static int __net_init erspan_init_net(struct net *net)
1691 {
1692         return ip_tunnel_init_net(net, erspan_net_id,
1693                                   &erspan_link_ops, "erspan0");
1694 }
1695
1696 static void __net_exit erspan_exit_batch_net(struct list_head *net_list)
1697 {
1698         ip_tunnel_delete_nets(net_list, erspan_net_id, &erspan_link_ops);
1699 }
1700
1701 static struct pernet_operations erspan_net_ops = {
1702         .init = erspan_init_net,
1703         .exit_batch = erspan_exit_batch_net,
1704         .id   = &erspan_net_id,
1705         .size = sizeof(struct ip_tunnel_net),
1706 };
1707
1708 static int __init ipgre_init(void)
1709 {
1710         int err;
1711
1712         pr_info("GRE over IPv4 tunneling driver\n");
1713
1714         err = register_pernet_device(&ipgre_net_ops);
1715         if (err < 0)
1716                 return err;
1717
1718         err = register_pernet_device(&ipgre_tap_net_ops);
1719         if (err < 0)
1720                 goto pnet_tap_failed;
1721
1722         err = register_pernet_device(&erspan_net_ops);
1723         if (err < 0)
1724                 goto pnet_erspan_failed;
1725
1726         err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1727         if (err < 0) {
1728                 pr_info("%s: can't add protocol\n", __func__);
1729                 goto add_proto_failed;
1730         }
1731
1732         err = rtnl_link_register(&ipgre_link_ops);
1733         if (err < 0)
1734                 goto rtnl_link_failed;
1735
1736         err = rtnl_link_register(&ipgre_tap_ops);
1737         if (err < 0)
1738                 goto tap_ops_failed;
1739
1740         err = rtnl_link_register(&erspan_link_ops);
1741         if (err < 0)
1742                 goto erspan_link_failed;
1743
1744         return 0;
1745
1746 erspan_link_failed:
1747         rtnl_link_unregister(&ipgre_tap_ops);
1748 tap_ops_failed:
1749         rtnl_link_unregister(&ipgre_link_ops);
1750 rtnl_link_failed:
1751         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1752 add_proto_failed:
1753         unregister_pernet_device(&erspan_net_ops);
1754 pnet_erspan_failed:
1755         unregister_pernet_device(&ipgre_tap_net_ops);
1756 pnet_tap_failed:
1757         unregister_pernet_device(&ipgre_net_ops);
1758         return err;
1759 }
1760
1761 static void __exit ipgre_fini(void)
1762 {
1763         rtnl_link_unregister(&ipgre_tap_ops);
1764         rtnl_link_unregister(&ipgre_link_ops);
1765         rtnl_link_unregister(&erspan_link_ops);
1766         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1767         unregister_pernet_device(&ipgre_tap_net_ops);
1768         unregister_pernet_device(&ipgre_net_ops);
1769         unregister_pernet_device(&erspan_net_ops);
1770 }
1771
1772 module_init(ipgre_init);
1773 module_exit(ipgre_fini);
1774 MODULE_LICENSE("GPL");
1775 MODULE_ALIAS_RTNL_LINK("gre");
1776 MODULE_ALIAS_RTNL_LINK("gretap");
1777 MODULE_ALIAS_RTNL_LINK("erspan");
1778 MODULE_ALIAS_NETDEV("gre0");
1779 MODULE_ALIAS_NETDEV("gretap0");
1780 MODULE_ALIAS_NETDEV("erspan0");