datapath/linux/compat/ip_gre.c

   1 /*
   2  *      Linux NET3:     GRE over IP protocol decoder.
   3  *
   4  *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License
   8  *      as published by the Free Software Foundation; either version
   9  *      2 of the License, or (at your option) any later version.
  10  *
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/capability.h>
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/kconfig.h>
  20 #include <linux/slab.h>
  21 #include <asm/uaccess.h>
  22 #include <linux/skbuff.h>
  23 #include <linux/netdevice.h>
  24 #include <linux/netdev_features.h>
  25 #include <linux/in.h>
  26 #include <linux/tcp.h>
  27 #include <linux/udp.h>
  28 #include <linux/if_arp.h>
  29 #include <linux/mroute.h>
  30 #include <linux/if_vlan.h>
  31 #include <linux/init.h>
  32 #include <linux/in6.h>
  33 #include <linux/inetdevice.h>
  34 #include <linux/igmp.h>
  35 #include <linux/netfilter_ipv4.h>
  36 #include <linux/etherdevice.h>
  37 #include <linux/if_ether.h>
  38
  39 #include <net/sock.h>
  40 #include <net/ip.h>
  41 #include <net/icmp.h>
  42 #include <net/protocol.h>
  43 #include <net/ip_tunnels.h>
  44 #include <net/arp.h>
  45 #include <net/checksum.h>
  46 #include <net/dsfield.h>
  47 #include <net/inet_ecn.h>
  48 #include <net/xfrm.h>
  49 #include <net/net_namespace.h>
  50 #include <net/netns/generic.h>
  51 #include <net/rtnetlink.h>
  52 #include <net/gre.h>
  53 #include <net/dst_metadata.h>
  54
  55 #ifndef USE_UPSTREAM_TUNNEL
  56 #if IS_ENABLED(CONFIG_IPV6)
  57 #include <net/ipv6.h>
  58 #include <net/ip6_fib.h>
  59 #include <net/ip6_route.h>
  60 #endif
  61
  62 #include "gso.h"
  63 #include "vport-netdev.h"
  64
  65 static int gre_tap_net_id __read_mostly;
  66
  67 #define ip_gre_calc_hlen rpl_ip_gre_calc_hlen
  68 static int ip_gre_calc_hlen(__be16 o_flags)
  69 {
  70         int addend = 4;
  71
  72         if (o_flags & TUNNEL_CSUM)
  73                 addend += 4;
  74         if (o_flags & TUNNEL_KEY)
  75                 addend += 4;
  76         if (o_flags & TUNNEL_SEQ)
  77                 addend += 4;
  78         return addend;
  79 }
  80
  81 #define tnl_flags_to_gre_flags rpl_tnl_flags_to_gre_flags
  82 static __be16 tnl_flags_to_gre_flags(__be16 tflags)
  83 {
  84         __be16 flags = 0;
  85
  86         if (tflags & TUNNEL_CSUM)
  87                 flags |= GRE_CSUM;
  88         if (tflags & TUNNEL_ROUTING)
  89                 flags |= GRE_ROUTING;
  90         if (tflags & TUNNEL_KEY)
  91                 flags |= GRE_KEY;
  92         if (tflags & TUNNEL_SEQ)
  93                 flags |= GRE_SEQ;
  94         if (tflags & TUNNEL_STRICT)
  95                 flags |= GRE_STRICT;
  96         if (tflags & TUNNEL_REC)
  97                 flags |= GRE_REC;
  98         if (tflags & TUNNEL_VERSION)
  99                 flags |= GRE_VERSION;
 100
 101         return flags;
 102 }
 103
 104 static __be64 key_to_tunnel_id(__be32 key)
 105 {
 106 #ifdef __BIG_ENDIAN
 107         return (__force __be64)((__force u32)key);
 108 #else
 109         return (__force __be64)((__force u64)key << 32);
 110 #endif
 111 }
 112
 113 /* Returns the least-significant 32 bits of a __be64. */
 114 static __be32 tunnel_id_to_key(__be64 x)
 115 {
 116 #ifdef __BIG_ENDIAN
 117         return (__force __be32)x;
 118 #else
 119         return (__force __be32)((__force u64)x >> 32);
 120 #endif
 121 }
 122
 123 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
 124 {
 125         struct net *net = dev_net(skb->dev);
 126         struct metadata_dst tun_dst;
 127         struct ip_tunnel_net *itn;
 128         const struct iphdr *iph;
 129         struct ip_tunnel *tunnel;
 130
 131         if (tpi->proto != htons(ETH_P_TEB))
 132                 return PACKET_REJECT;
 133
 134         itn = net_generic(net, gre_tap_net_id);
 135
 136         iph = ip_hdr(skb);
 137         tunnel = rcu_dereference(itn->collect_md_tun);
 138         if (tunnel) {
 139                 __be16 flags;
 140                 __be64 tun_id;
 141                 int err;
 142
 143
 144                 skb_pop_mac_header(skb);
 145                 flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
 146                 tun_id = key_to_tunnel_id(tpi->key);
 147                 ovs_ip_tun_rx_dst(&tun_dst.u.tun_info, skb, flags, tun_id, 0);
 148
 149                 skb_reset_network_header(skb);
 150                 err = IP_ECN_decapsulate(iph, skb);
 151                 if (unlikely(err)) {
 152                         if (err > 1) {
 153                                 ++tunnel->dev->stats.rx_frame_errors;
 154                                 ++tunnel->dev->stats.rx_errors;
 155                                 return PACKET_REJECT;
 156                         }
 157                 }
 158
 159                 ovs_ip_tunnel_rcv(tunnel->dev, skb, &tun_dst);
 160                 return PACKET_RCVD;
 161         }
 162         return PACKET_REJECT;
 163 }
 164
 165 static int gre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
 166 {
 167         if (ipgre_rcv(skb, tpi) == PACKET_RCVD)
 168                 return 0;
 169
 170         kfree_skb(skb);
 171         return 0;
 172 }
 173
 174 #if LINUX_VERSION_CODE < KERNEL_VERSION(4,7,0)
 175 /* gre_handle_offloads() has different return type on older kernsl. */
 176 static void gre_nop_fix(struct sk_buff *skb) { }
 177
 178 static void gre_csum_fix(struct sk_buff *skb)
 179 {
 180         struct gre_base_hdr *greh;
 181         __be32 *options;
 182         int gre_offset = skb_transport_offset(skb);
 183
 184         greh = (struct gre_base_hdr *)skb_transport_header(skb);
 185         options = ((__be32 *)greh + 1);
 186
 187         *options = 0;
 188         *(__sum16 *)options = csum_fold(skb_checksum(skb, gre_offset,
 189                                                      skb->len - gre_offset, 0));
 190 }
 191
 192 static bool is_gre_gso(struct sk_buff *skb)
 193 {
 194         return skb_is_gso(skb);
 195 }
 196
 197 static int rpl_gre_handle_offloads(struct sk_buff *skb, bool gre_csum)
 198 {
 199         int type = gre_csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE;
 200         gso_fix_segment_t fix_segment;
 201
 202         if (gre_csum)
 203                 fix_segment = gre_csum_fix;
 204         else
 205                 fix_segment = gre_nop_fix;
 206
 207         return ovs_iptunnel_handle_offloads(skb, gre_csum, type, fix_segment);
 208 }
 209 #else
 210
 211 static bool is_gre_gso(struct sk_buff *skb)
 212 {
 213         return skb_shinfo(skb)->gso_type &
 214                 (SKB_GSO_GRE | SKB_GSO_GRE_CSUM);
 215 }
 216
 217 static int rpl_gre_handle_offloads(struct sk_buff *skb, bool gre_csum)
 218 {
 219         if (skb_is_gso(skb) && skb_is_encapsulated(skb))
 220                 return -ENOSYS;
 221
 222 #undef gre_handle_offloads
 223         return gre_handle_offloads(skb, gre_csum);
 224 }
 225 #endif
 226
 227 static void build_header(struct sk_buff *skb, int hdr_len, __be16 flags,
 228                          __be16 proto, __be32 key, __be32 seq)
 229 {
 230         struct gre_base_hdr *greh;
 231
 232         skb_push(skb, hdr_len);
 233
 234         skb_reset_transport_header(skb);
 235         greh = (struct gre_base_hdr *)skb->data;
 236         greh->flags = tnl_flags_to_gre_flags(flags);
 237         greh->protocol = proto;
 238
 239         if (flags & (TUNNEL_KEY | TUNNEL_CSUM | TUNNEL_SEQ)) {
 240                 __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
 241
 242                 if (flags & TUNNEL_SEQ) {
 243                         *ptr = seq;
 244                         ptr--;
 245                 }
 246                 if (flags & TUNNEL_KEY) {
 247                         *ptr = key;
 248                         ptr--;
 249                 }
 250                 if (flags & TUNNEL_CSUM && !is_gre_gso(skb)) {
 251                         *ptr = 0;
 252                         *(__sum16 *)ptr = csum_fold(skb_checksum(skb, 0,
 253                                                                  skb->len, 0));
 254                 }
 255         }
 256         ovs_skb_set_inner_protocol(skb, proto);
 257 }
 258
 259 static struct rtable *gre_get_rt(struct sk_buff *skb,
 260                                  struct net_device *dev,
 261                                  struct flowi4 *fl,
 262                                  const struct ip_tunnel_key *key)
 263 {
 264         struct net *net = dev_net(dev);
 265
 266         memset(fl, 0, sizeof(*fl));
 267         fl->daddr = key->u.ipv4.dst;
 268         fl->saddr = key->u.ipv4.src;
 269         fl->flowi4_tos = RT_TOS(key->tos);
 270         fl->flowi4_mark = skb->mark;
 271         fl->flowi4_proto = IPPROTO_GRE;
 272
 273         return ip_route_output_key(net, fl);
 274 }
 275
 276 netdev_tx_t rpl_gre_fb_xmit(struct sk_buff *skb)
 277 {
 278         struct net_device *dev = skb->dev;
 279         struct ip_tunnel_info *tun_info;
 280         const struct ip_tunnel_key *key;
 281         struct flowi4 fl;
 282         struct rtable *rt;
 283         int min_headroom;
 284         int tunnel_hlen;
 285         __be16 df, flags;
 286         int err;
 287
 288         tun_info = skb_tunnel_info(skb);
 289         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 290                      ip_tunnel_info_af(tun_info) != AF_INET))
 291                 goto err_free_skb;
 292
 293         key = &tun_info->key;
 294
 295         rt = gre_get_rt(skb, dev, &fl, key);
 296         if (IS_ERR(rt))
 297                 goto err_free_skb;
 298
 299         tunnel_hlen = ip_gre_calc_hlen(key->tun_flags);
 300
 301         min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
 302                         + tunnel_hlen + sizeof(struct iphdr)
 303                         + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
 304         if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
 305                 int head_delta = SKB_DATA_ALIGN(min_headroom -
 306                                                 skb_headroom(skb) +
 307                                                 16);
 308                 err = pskb_expand_head(skb, max_t(int, head_delta, 0),
 309                                        0, GFP_ATOMIC);
 310                 if (unlikely(err))
 311                         goto err_free_rt;
 312         }
 313
 314         skb = vlan_hwaccel_push_inside(skb);
 315         if (unlikely(!skb)) {
 316                 err = -ENOMEM;
 317                 goto err_free_rt;
 318         }
 319
 320         /* Push Tunnel header. */
 321         err = rpl_gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM));
 322         if (err)
 323                 goto err_free_rt;
 324
 325         flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
 326         build_header(skb, tunnel_hlen, flags, htons(ETH_P_TEB),
 327                      tunnel_id_to_key(tun_info->key.tun_id), 0);
 328
 329         df = key->tun_flags & TUNNEL_DONT_FRAGMENT ?  htons(IP_DF) : 0;
 330         err = iptunnel_xmit(skb->sk, rt, skb, fl.saddr,
 331                             key->u.ipv4.dst, IPPROTO_GRE,
 332                             key->tos, key->ttl, df, false);
 333         iptunnel_xmit_stats(err, &dev->stats, (struct pcpu_sw_netstats __percpu *)dev->tstats);
 334         return NETDEV_TX_OK;
 335
 336 err_free_rt:
 337         ip_rt_put(rt);
 338 err_free_skb:
 339         kfree_skb(skb);
 340         dev->stats.tx_dropped++;
 341         return NETDEV_TX_OK;
 342 }
 343 EXPORT_SYMBOL(rpl_gre_fb_xmit);
 344
 345 #define GRE_FEATURES    (NETIF_F_SG |           \
 346                          NETIF_F_FRAGLIST |     \
 347                          NETIF_F_HIGHDMA |      \
 348                          NETIF_F_HW_CSUM |      \
 349                          NETIF_F_NETNS_LOCAL)
 350
 351 static void __gre_tunnel_init(struct net_device *dev)
 352 {
 353         struct ip_tunnel *tunnel;
 354         int t_hlen;
 355
 356         tunnel = netdev_priv(dev);
 357         tunnel->parms.iph.protocol = IPPROTO_GRE;
 358         tunnel->tun_hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
 359
 360         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 361
 362         t_hlen = tunnel->hlen + sizeof(struct iphdr);
 363
 364         dev->needed_headroom    = LL_MAX_HEADER + t_hlen + 4;
 365         dev->mtu                = ETH_DATA_LEN - t_hlen - 4;
 366
 367         dev->features           |= GRE_FEATURES;
 368 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
 369         dev->hw_features        |= GRE_FEATURES;
 370 #endif
 371
 372         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 373                 /* TCP offload with GRE SEQ is not supported. */
 374                 dev->features    |= NETIF_F_GSO_SOFTWARE;
 375 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
 376                 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 377 #endif
 378                 /* Can use a lockless transmit, unless we generate
 379                  * output sequences
 380                  */
 381                 dev->features |= NETIF_F_LLTX;
 382         }
 383 }
 384
 385 /* Called with rcu_read_lock and BH disabled. */
 386 static int gre_err(struct sk_buff *skb, u32 info,
 387                    const struct tnl_ptk_info *tpi)
 388 {
 389         return PACKET_REJECT;
 390 }
 391
 392 static struct gre_cisco_protocol ipgre_protocol = {
 393         .handler        = gre_rcv,
 394         .err_handler    = gre_err,
 395         .priority       = 1,
 396 };
 397
 398 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
 399 {
 400         __be16 flags;
 401
 402         if (!data)
 403                 return 0;
 404
 405         flags = 0;
 406         if (data[IFLA_GRE_IFLAGS])
 407                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
 408         if (data[IFLA_GRE_OFLAGS])
 409                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
 410         if (flags & (GRE_VERSION|GRE_ROUTING))
 411                 return -EINVAL;
 412
 413         return 0;
 414 }
 415
 416 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
 417 {
 418         __be32 daddr;
 419
 420         if (tb[IFLA_ADDRESS]) {
 421                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 422                         return -EINVAL;
 423                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 424                         return -EADDRNOTAVAIL;
 425         }
 426
 427         if (!data)
 428                 goto out;
 429
 430         if (data[IFLA_GRE_REMOTE]) {
 431                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
 432                 if (!daddr)
 433                         return -EINVAL;
 434         }
 435
 436 out:
 437         return ipgre_tunnel_validate(tb, data);
 438 }
 439
 440 static void ipgre_netlink_parms(struct net_device *dev,
 441                                 struct nlattr *data[],
 442                                 struct nlattr *tb[],
 443                                 struct ip_tunnel_parm *parms)
 444 {
 445         memset(parms, 0, sizeof(*parms));
 446
 447         parms->iph.protocol = IPPROTO_GRE;
 448 }
 449
 450 static int gre_tap_init(struct net_device *dev)
 451 {
 452         __gre_tunnel_init(dev);
 453         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 454
 455         return ip_tunnel_init(dev);
 456 }
 457
 458 static netdev_tx_t gre_dev_xmit(struct sk_buff *skb, struct net_device *dev)
 459 {
 460         /* Drop All packets coming from networking stack. OVS-CB is
 461          * not initialized for these packets.
 462          */
 463
 464         dev_kfree_skb(skb);
 465         dev->stats.tx_dropped++;
 466         return NETDEV_TX_OK;
 467 }
 468
 469 int ovs_gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
 470 {
 471         struct ip_tunnel_info *info = skb_tunnel_info(skb);
 472         struct rtable *rt;
 473         struct flowi4 fl4;
 474
 475         if (ip_tunnel_info_af(info) != AF_INET)
 476                 return -EINVAL;
 477
 478         rt = gre_get_rt(skb, dev, &fl4, &info->key);
 479         if (IS_ERR(rt))
 480                 return PTR_ERR(rt);
 481
 482         ip_rt_put(rt);
 483         info->key.u.ipv4.src = fl4.saddr;
 484         return 0;
 485 }
 486 EXPORT_SYMBOL_GPL(ovs_gre_fill_metadata_dst);
 487
 488 static const struct net_device_ops gre_tap_netdev_ops = {
 489         .ndo_init               = gre_tap_init,
 490         .ndo_uninit             = ip_tunnel_uninit,
 491         .ndo_start_xmit         = gre_dev_xmit,
 492         .ndo_set_mac_address    = eth_mac_addr,
 493         .ndo_validate_addr      = eth_validate_addr,
 494         .ndo_change_mtu         = ip_tunnel_change_mtu,
 495 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
 496         .ndo_get_stats64        = ip_tunnel_get_stats64,
 497 #endif
 498 #ifdef HAVE_NDO_GET_IFLINK
 499         .ndo_get_iflink         = ip_tunnel_get_iflink,
 500 #endif
 501 #ifdef HAVE_NDO_FILL_METADATA_DST
 502         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
 503 #endif
 504 };
 505
 506 static void ipgre_tap_setup(struct net_device *dev)
 507 {
 508         ether_setup(dev);
 509         dev->netdev_ops         = &gre_tap_netdev_ops;
 510         dev->priv_flags         |= IFF_LIVE_ADDR_CHANGE;
 511         ip_tunnel_setup(dev, gre_tap_net_id);
 512 }
 513
 514 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
 515 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
 516                          struct nlattr *tb[], struct nlattr *data[])
 517 #else
 518 static int ipgre_newlink(struct net_device *dev,
 519                          struct nlattr *tb[], struct nlattr *data[])
 520 #endif
 521 {
 522         struct ip_tunnel_parm p;
 523         int err;
 524
 525         ipgre_netlink_parms(dev, data, tb, &p);
 526         err = ip_tunnel_newlink(dev, tb, &p);
 527         return err;
 528
 529 }
 530
 531 static size_t ipgre_get_size(const struct net_device *dev)
 532 {
 533         return
 534                 /* IFLA_GRE_LINK */
 535                 nla_total_size(4) +
 536                 /* IFLA_GRE_IFLAGS */
 537                 nla_total_size(2) +
 538                 /* IFLA_GRE_OFLAGS */
 539                 nla_total_size(2) +
 540                 /* IFLA_GRE_IKEY */
 541                 nla_total_size(4) +
 542                 /* IFLA_GRE_OKEY */
 543                 nla_total_size(4) +
 544                 /* IFLA_GRE_LOCAL */
 545                 nla_total_size(4) +
 546                 /* IFLA_GRE_REMOTE */
 547                 nla_total_size(4) +
 548                 /* IFLA_GRE_TTL */
 549                 nla_total_size(1) +
 550                 /* IFLA_GRE_TOS */
 551                 nla_total_size(1) +
 552                 /* IFLA_GRE_PMTUDISC */
 553                 nla_total_size(1) +
 554                 /* IFLA_GRE_ENCAP_TYPE */
 555                 nla_total_size(2) +
 556                 /* IFLA_GRE_ENCAP_FLAGS */
 557                 nla_total_size(2) +
 558                 /* IFLA_GRE_ENCAP_SPORT */
 559                 nla_total_size(2) +
 560                 /* IFLA_GRE_ENCAP_DPORT */
 561                 nla_total_size(2) +
 562                 /* IFLA_GRE_COLLECT_METADATA */
 563                 nla_total_size(0) +
 564                 0;
 565 }
 566
 567 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
 568 {
 569         struct ip_tunnel *t = netdev_priv(dev);
 570         struct ip_tunnel_parm *p = &t->parms;
 571
 572         if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
 573             nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
 574             nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
 575             nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
 576             nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
 577             nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
 578             nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
 579             nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
 580             nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
 581             nla_put_u8(skb, IFLA_GRE_PMTUDISC,
 582                        !!(p->iph.frag_off & htons(IP_DF))))
 583                 goto nla_put_failure;
 584
 585         return 0;
 586
 587 nla_put_failure:
 588         return -EMSGSIZE;
 589 }
 590
 591 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
 592         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
 593         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
 594         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
 595         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
 596         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
 597         [IFLA_GRE_LOCAL]        = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
 598         [IFLA_GRE_REMOTE]       = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
 599         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
 600         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
 601         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
 602 };
 603
 604 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
 605         .kind           = "ovs_gretap",
 606         .maxtype        = IFLA_GRE_MAX,
 607         .policy         = ipgre_policy,
 608         .priv_size      = sizeof(struct ip_tunnel),
 609         .setup          = ipgre_tap_setup,
 610         .validate       = ipgre_tap_validate,
 611         .newlink        = ipgre_newlink,
 612         .dellink        = ip_tunnel_dellink,
 613         .get_size       = ipgre_get_size,
 614         .fill_info      = ipgre_fill_info,
 615 #ifdef HAVE_GET_LINK_NET
 616         .get_link_net   = ip_tunnel_get_link_net,
 617 #endif
 618 };
 619
 620 struct net_device *rpl_gretap_fb_dev_create(struct net *net, const char *name,
 621                                         u8 name_assign_type)
 622 {
 623         struct nlattr *tb[IFLA_MAX + 1];
 624         struct net_device *dev;
 625         struct ip_tunnel *t;
 626         int err;
 627
 628         memset(&tb, 0, sizeof(tb));
 629
 630         dev = rtnl_create_link(net, (char *)name, name_assign_type,
 631                                &ipgre_tap_ops, tb);
 632         if (IS_ERR(dev))
 633                 return dev;
 634
 635         t = netdev_priv(dev);
 636         t->collect_md = true;
 637         /* Configure flow based GRE device. */
 638 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
 639         err = ipgre_newlink(net, dev, tb, NULL);
 640 #else
 641         err = ipgre_newlink(dev, tb, NULL);
 642 #endif
 643         if (err < 0)
 644                 goto out;
 645
 646         /* openvswitch users expect packet sizes to be unrestricted,
 647          * so set the largest MTU we can.
 648          */
 649         err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
 650         if (err)
 651                 goto out;
 652
 653         return dev;
 654 out:
 655         free_netdev(dev);
 656         return ERR_PTR(err);
 657 }
 658 EXPORT_SYMBOL_GPL(rpl_gretap_fb_dev_create);
 659
 660 static int __net_init ipgre_tap_init_net(struct net *net)
 661 {
 662         return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
 663 }
 664
 665 static void __net_exit ipgre_tap_exit_net(struct net *net)
 666 {
 667         struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
 668
 669         ip_tunnel_delete_net(itn, &ipgre_tap_ops);
 670 }
 671
 672 static struct pernet_operations ipgre_tap_net_ops = {
 673         .init = ipgre_tap_init_net,
 674         .exit = ipgre_tap_exit_net,
 675         .id   = &gre_tap_net_id,
 676         .size = sizeof(struct ip_tunnel_net),
 677 };
 678
 679 int rpl_ipgre_init(void)
 680 {
 681         int err;
 682
 683         err = register_pernet_device(&ipgre_tap_net_ops);
 684         if (err < 0)
 685                 goto pnet_tap_faied;
 686
 687         err = gre_cisco_register(&ipgre_protocol);
 688         if (err < 0) {
 689                 pr_info("%s: can't add protocol\n", __func__);
 690                 goto add_proto_failed;
 691         }
 692
 693         err = rtnl_link_register(&ipgre_tap_ops);
 694         if (err < 0)
 695                 goto tap_ops_failed;
 696
 697         pr_info("GRE over IPv4 tunneling driver\n");
 698         return 0;
 699
 700 tap_ops_failed:
 701         gre_cisco_unregister(&ipgre_protocol);
 702 add_proto_failed:
 703         unregister_pernet_device(&ipgre_tap_net_ops);
 704 pnet_tap_faied:
 705         return err;
 706 }
 707
 708 void rpl_ipgre_fini(void)
 709 {
 710         rtnl_link_unregister(&ipgre_tap_ops);
 711         gre_cisco_unregister(&ipgre_protocol);
 712         unregister_pernet_device(&ipgre_tap_net_ops);
 713 }
 714
 715 #endif