Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * GENEVE: Generic Network Virtualization Encapsulation
0004  *
0005  * Copyright (c) 2015 Red Hat, Inc.
0006  */
0007 
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 
0010 #include <linux/ethtool.h>
0011 #include <linux/kernel.h>
0012 #include <linux/module.h>
0013 #include <linux/etherdevice.h>
0014 #include <linux/hash.h>
0015 #include <net/ipv6_stubs.h>
0016 #include <net/dst_metadata.h>
0017 #include <net/gro_cells.h>
0018 #include <net/rtnetlink.h>
0019 #include <net/geneve.h>
0020 #include <net/gro.h>
0021 #include <net/protocol.h>
0022 
0023 #define GENEVE_NETDEV_VER   "0.6"
0024 
0025 #define GENEVE_N_VID        (1u << 24)
0026 #define GENEVE_VID_MASK     (GENEVE_N_VID - 1)
0027 
0028 #define VNI_HASH_BITS       10
0029 #define VNI_HASH_SIZE       (1<<VNI_HASH_BITS)
0030 
0031 static bool log_ecn_error = true;
0032 module_param(log_ecn_error, bool, 0644);
0033 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
0034 
0035 #define GENEVE_VER 0
0036 #define GENEVE_BASE_HLEN (sizeof(struct udphdr) + sizeof(struct genevehdr))
0037 #define GENEVE_IPV4_HLEN (ETH_HLEN + sizeof(struct iphdr) + GENEVE_BASE_HLEN)
0038 #define GENEVE_IPV6_HLEN (ETH_HLEN + sizeof(struct ipv6hdr) + GENEVE_BASE_HLEN)
0039 
0040 /* per-network namespace private data for this module */
0041 struct geneve_net {
0042     struct list_head    geneve_list;
0043     struct list_head    sock_list;
0044 };
0045 
0046 static unsigned int geneve_net_id;
0047 
0048 struct geneve_dev_node {
0049     struct hlist_node hlist;
0050     struct geneve_dev *geneve;
0051 };
0052 
0053 struct geneve_config {
0054     struct ip_tunnel_info   info;
0055     bool            collect_md;
0056     bool            use_udp6_rx_checksums;
0057     bool            ttl_inherit;
0058     enum ifla_geneve_df df;
0059     bool            inner_proto_inherit;
0060 };
0061 
0062 /* Pseudo network device */
0063 struct geneve_dev {
0064     struct geneve_dev_node hlist4;  /* vni hash table for IPv4 socket */
0065 #if IS_ENABLED(CONFIG_IPV6)
0066     struct geneve_dev_node hlist6;  /* vni hash table for IPv6 socket */
0067 #endif
0068     struct net     *net;    /* netns for packet i/o */
0069     struct net_device  *dev;    /* netdev for geneve tunnel */
0070     struct geneve_sock __rcu *sock4;    /* IPv4 socket used for geneve tunnel */
0071 #if IS_ENABLED(CONFIG_IPV6)
0072     struct geneve_sock __rcu *sock6;    /* IPv6 socket used for geneve tunnel */
0073 #endif
0074     struct list_head   next;    /* geneve's per namespace list */
0075     struct gro_cells   gro_cells;
0076     struct geneve_config cfg;
0077 };
0078 
0079 struct geneve_sock {
0080     bool            collect_md;
0081     struct list_head    list;
0082     struct socket       *sock;
0083     struct rcu_head     rcu;
0084     int         refcnt;
0085     struct hlist_head   vni_list[VNI_HASH_SIZE];
0086 };
0087 
0088 static inline __u32 geneve_net_vni_hash(u8 vni[3])
0089 {
0090     __u32 vnid;
0091 
0092     vnid = (vni[0] << 16) | (vni[1] << 8) | vni[2];
0093     return hash_32(vnid, VNI_HASH_BITS);
0094 }
0095 
0096 static __be64 vni_to_tunnel_id(const __u8 *vni)
0097 {
0098 #ifdef __BIG_ENDIAN
0099     return (vni[0] << 16) | (vni[1] << 8) | vni[2];
0100 #else
0101     return (__force __be64)(((__force u64)vni[0] << 40) |
0102                 ((__force u64)vni[1] << 48) |
0103                 ((__force u64)vni[2] << 56));
0104 #endif
0105 }
0106 
0107 /* Convert 64 bit tunnel ID to 24 bit VNI. */
0108 static void tunnel_id_to_vni(__be64 tun_id, __u8 *vni)
0109 {
0110 #ifdef __BIG_ENDIAN
0111     vni[0] = (__force __u8)(tun_id >> 16);
0112     vni[1] = (__force __u8)(tun_id >> 8);
0113     vni[2] = (__force __u8)tun_id;
0114 #else
0115     vni[0] = (__force __u8)((__force u64)tun_id >> 40);
0116     vni[1] = (__force __u8)((__force u64)tun_id >> 48);
0117     vni[2] = (__force __u8)((__force u64)tun_id >> 56);
0118 #endif
0119 }
0120 
0121 static bool eq_tun_id_and_vni(u8 *tun_id, u8 *vni)
0122 {
0123     return !memcmp(vni, &tun_id[5], 3);
0124 }
0125 
0126 static sa_family_t geneve_get_sk_family(struct geneve_sock *gs)
0127 {
0128     return gs->sock->sk->sk_family;
0129 }
0130 
0131 static struct geneve_dev *geneve_lookup(struct geneve_sock *gs,
0132                     __be32 addr, u8 vni[])
0133 {
0134     struct hlist_head *vni_list_head;
0135     struct geneve_dev_node *node;
0136     __u32 hash;
0137 
0138     /* Find the device for this VNI */
0139     hash = geneve_net_vni_hash(vni);
0140     vni_list_head = &gs->vni_list[hash];
0141     hlist_for_each_entry_rcu(node, vni_list_head, hlist) {
0142         if (eq_tun_id_and_vni((u8 *)&node->geneve->cfg.info.key.tun_id, vni) &&
0143             addr == node->geneve->cfg.info.key.u.ipv4.dst)
0144             return node->geneve;
0145     }
0146     return NULL;
0147 }
0148 
0149 #if IS_ENABLED(CONFIG_IPV6)
0150 static struct geneve_dev *geneve6_lookup(struct geneve_sock *gs,
0151                      struct in6_addr addr6, u8 vni[])
0152 {
0153     struct hlist_head *vni_list_head;
0154     struct geneve_dev_node *node;
0155     __u32 hash;
0156 
0157     /* Find the device for this VNI */
0158     hash = geneve_net_vni_hash(vni);
0159     vni_list_head = &gs->vni_list[hash];
0160     hlist_for_each_entry_rcu(node, vni_list_head, hlist) {
0161         if (eq_tun_id_and_vni((u8 *)&node->geneve->cfg.info.key.tun_id, vni) &&
0162             ipv6_addr_equal(&addr6, &node->geneve->cfg.info.key.u.ipv6.dst))
0163             return node->geneve;
0164     }
0165     return NULL;
0166 }
0167 #endif
0168 
0169 static inline struct genevehdr *geneve_hdr(const struct sk_buff *skb)
0170 {
0171     return (struct genevehdr *)(udp_hdr(skb) + 1);
0172 }
0173 
0174 static struct geneve_dev *geneve_lookup_skb(struct geneve_sock *gs,
0175                         struct sk_buff *skb)
0176 {
0177     static u8 zero_vni[3];
0178     u8 *vni;
0179 
0180     if (geneve_get_sk_family(gs) == AF_INET) {
0181         struct iphdr *iph;
0182         __be32 addr;
0183 
0184         iph = ip_hdr(skb); /* outer IP header... */
0185 
0186         if (gs->collect_md) {
0187             vni = zero_vni;
0188             addr = 0;
0189         } else {
0190             vni = geneve_hdr(skb)->vni;
0191             addr = iph->saddr;
0192         }
0193 
0194         return geneve_lookup(gs, addr, vni);
0195 #if IS_ENABLED(CONFIG_IPV6)
0196     } else if (geneve_get_sk_family(gs) == AF_INET6) {
0197         static struct in6_addr zero_addr6;
0198         struct ipv6hdr *ip6h;
0199         struct in6_addr addr6;
0200 
0201         ip6h = ipv6_hdr(skb); /* outer IPv6 header... */
0202 
0203         if (gs->collect_md) {
0204             vni = zero_vni;
0205             addr6 = zero_addr6;
0206         } else {
0207             vni = geneve_hdr(skb)->vni;
0208             addr6 = ip6h->saddr;
0209         }
0210 
0211         return geneve6_lookup(gs, addr6, vni);
0212 #endif
0213     }
0214     return NULL;
0215 }
0216 
0217 /* geneve receive/decap routine */
0218 static void geneve_rx(struct geneve_dev *geneve, struct geneve_sock *gs,
0219               struct sk_buff *skb)
0220 {
0221     struct genevehdr *gnvh = geneve_hdr(skb);
0222     struct metadata_dst *tun_dst = NULL;
0223     unsigned int len;
0224     int err = 0;
0225     void *oiph;
0226 
0227     if (ip_tunnel_collect_metadata() || gs->collect_md) {
0228         __be16 flags;
0229 
0230         flags = TUNNEL_KEY | (gnvh->oam ? TUNNEL_OAM : 0) |
0231             (gnvh->critical ? TUNNEL_CRIT_OPT : 0);
0232 
0233         tun_dst = udp_tun_rx_dst(skb, geneve_get_sk_family(gs), flags,
0234                      vni_to_tunnel_id(gnvh->vni),
0235                      gnvh->opt_len * 4);
0236         if (!tun_dst) {
0237             geneve->dev->stats.rx_dropped++;
0238             goto drop;
0239         }
0240         /* Update tunnel dst according to Geneve options. */
0241         ip_tunnel_info_opts_set(&tun_dst->u.tun_info,
0242                     gnvh->options, gnvh->opt_len * 4,
0243                     TUNNEL_GENEVE_OPT);
0244     } else {
0245         /* Drop packets w/ critical options,
0246          * since we don't support any...
0247          */
0248         if (gnvh->critical) {
0249             geneve->dev->stats.rx_frame_errors++;
0250             geneve->dev->stats.rx_errors++;
0251             goto drop;
0252         }
0253     }
0254 
0255     if (tun_dst)
0256         skb_dst_set(skb, &tun_dst->dst);
0257 
0258     if (gnvh->proto_type == htons(ETH_P_TEB)) {
0259         skb_reset_mac_header(skb);
0260         skb->protocol = eth_type_trans(skb, geneve->dev);
0261         skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
0262 
0263         /* Ignore packet loops (and multicast echo) */
0264         if (ether_addr_equal(eth_hdr(skb)->h_source,
0265                      geneve->dev->dev_addr)) {
0266             geneve->dev->stats.rx_errors++;
0267             goto drop;
0268         }
0269     } else {
0270         skb_reset_mac_header(skb);
0271         skb->dev = geneve->dev;
0272         skb->pkt_type = PACKET_HOST;
0273     }
0274 
0275     oiph = skb_network_header(skb);
0276     skb_reset_network_header(skb);
0277 
0278     if (geneve_get_sk_family(gs) == AF_INET)
0279         err = IP_ECN_decapsulate(oiph, skb);
0280 #if IS_ENABLED(CONFIG_IPV6)
0281     else
0282         err = IP6_ECN_decapsulate(oiph, skb);
0283 #endif
0284 
0285     if (unlikely(err)) {
0286         if (log_ecn_error) {
0287             if (geneve_get_sk_family(gs) == AF_INET)
0288                 net_info_ratelimited("non-ECT from %pI4 "
0289                              "with TOS=%#x\n",
0290                              &((struct iphdr *)oiph)->saddr,
0291                              ((struct iphdr *)oiph)->tos);
0292 #if IS_ENABLED(CONFIG_IPV6)
0293             else
0294                 net_info_ratelimited("non-ECT from %pI6\n",
0295                              &((struct ipv6hdr *)oiph)->saddr);
0296 #endif
0297         }
0298         if (err > 1) {
0299             ++geneve->dev->stats.rx_frame_errors;
0300             ++geneve->dev->stats.rx_errors;
0301             goto drop;
0302         }
0303     }
0304 
0305     len = skb->len;
0306     err = gro_cells_receive(&geneve->gro_cells, skb);
0307     if (likely(err == NET_RX_SUCCESS))
0308         dev_sw_netstats_rx_add(geneve->dev, len);
0309 
0310     return;
0311 drop:
0312     /* Consume bad packet */
0313     kfree_skb(skb);
0314 }
0315 
0316 /* Setup stats when device is created */
0317 static int geneve_init(struct net_device *dev)
0318 {
0319     struct geneve_dev *geneve = netdev_priv(dev);
0320     int err;
0321 
0322     dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
0323     if (!dev->tstats)
0324         return -ENOMEM;
0325 
0326     err = gro_cells_init(&geneve->gro_cells, dev);
0327     if (err) {
0328         free_percpu(dev->tstats);
0329         return err;
0330     }
0331 
0332     err = dst_cache_init(&geneve->cfg.info.dst_cache, GFP_KERNEL);
0333     if (err) {
0334         free_percpu(dev->tstats);
0335         gro_cells_destroy(&geneve->gro_cells);
0336         return err;
0337     }
0338     return 0;
0339 }
0340 
0341 static void geneve_uninit(struct net_device *dev)
0342 {
0343     struct geneve_dev *geneve = netdev_priv(dev);
0344 
0345     dst_cache_destroy(&geneve->cfg.info.dst_cache);
0346     gro_cells_destroy(&geneve->gro_cells);
0347     free_percpu(dev->tstats);
0348 }
0349 
0350 /* Callback from net/ipv4/udp.c to receive packets */
0351 static int geneve_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
0352 {
0353     struct genevehdr *geneveh;
0354     struct geneve_dev *geneve;
0355     struct geneve_sock *gs;
0356     __be16 inner_proto;
0357     int opts_len;
0358 
0359     /* Need UDP and Geneve header to be present */
0360     if (unlikely(!pskb_may_pull(skb, GENEVE_BASE_HLEN)))
0361         goto drop;
0362 
0363     /* Return packets with reserved bits set */
0364     geneveh = geneve_hdr(skb);
0365     if (unlikely(geneveh->ver != GENEVE_VER))
0366         goto drop;
0367 
0368     inner_proto = geneveh->proto_type;
0369 
0370     if (unlikely((inner_proto != htons(ETH_P_TEB) &&
0371               inner_proto != htons(ETH_P_IP) &&
0372               inner_proto != htons(ETH_P_IPV6))))
0373         goto drop;
0374 
0375     gs = rcu_dereference_sk_user_data(sk);
0376     if (!gs)
0377         goto drop;
0378 
0379     geneve = geneve_lookup_skb(gs, skb);
0380     if (!geneve)
0381         goto drop;
0382 
0383     if (unlikely((!geneve->cfg.inner_proto_inherit &&
0384               inner_proto != htons(ETH_P_TEB)))) {
0385         geneve->dev->stats.rx_dropped++;
0386         goto drop;
0387     }
0388 
0389     opts_len = geneveh->opt_len * 4;
0390     if (iptunnel_pull_header(skb, GENEVE_BASE_HLEN + opts_len, inner_proto,
0391                  !net_eq(geneve->net, dev_net(geneve->dev)))) {
0392         geneve->dev->stats.rx_dropped++;
0393         goto drop;
0394     }
0395 
0396     geneve_rx(geneve, gs, skb);
0397     return 0;
0398 
0399 drop:
0400     /* Consume bad packet */
0401     kfree_skb(skb);
0402     return 0;
0403 }
0404 
0405 /* Callback from net/ipv{4,6}/udp.c to check that we have a tunnel for errors */
0406 static int geneve_udp_encap_err_lookup(struct sock *sk, struct sk_buff *skb)
0407 {
0408     struct genevehdr *geneveh;
0409     struct geneve_sock *gs;
0410     u8 zero_vni[3] = { 0 };
0411     u8 *vni = zero_vni;
0412 
0413     if (!pskb_may_pull(skb, skb_transport_offset(skb) + GENEVE_BASE_HLEN))
0414         return -EINVAL;
0415 
0416     geneveh = geneve_hdr(skb);
0417     if (geneveh->ver != GENEVE_VER)
0418         return -EINVAL;
0419 
0420     if (geneveh->proto_type != htons(ETH_P_TEB))
0421         return -EINVAL;
0422 
0423     gs = rcu_dereference_sk_user_data(sk);
0424     if (!gs)
0425         return -ENOENT;
0426 
0427     if (geneve_get_sk_family(gs) == AF_INET) {
0428         struct iphdr *iph = ip_hdr(skb);
0429         __be32 addr4 = 0;
0430 
0431         if (!gs->collect_md) {
0432             vni = geneve_hdr(skb)->vni;
0433             addr4 = iph->daddr;
0434         }
0435 
0436         return geneve_lookup(gs, addr4, vni) ? 0 : -ENOENT;
0437     }
0438 
0439 #if IS_ENABLED(CONFIG_IPV6)
0440     if (geneve_get_sk_family(gs) == AF_INET6) {
0441         struct ipv6hdr *ip6h = ipv6_hdr(skb);
0442         struct in6_addr addr6;
0443 
0444         memset(&addr6, 0, sizeof(struct in6_addr));
0445 
0446         if (!gs->collect_md) {
0447             vni = geneve_hdr(skb)->vni;
0448             addr6 = ip6h->daddr;
0449         }
0450 
0451         return geneve6_lookup(gs, addr6, vni) ? 0 : -ENOENT;
0452     }
0453 #endif
0454 
0455     return -EPFNOSUPPORT;
0456 }
0457 
0458 static struct socket *geneve_create_sock(struct net *net, bool ipv6,
0459                      __be16 port, bool ipv6_rx_csum)
0460 {
0461     struct socket *sock;
0462     struct udp_port_cfg udp_conf;
0463     int err;
0464 
0465     memset(&udp_conf, 0, sizeof(udp_conf));
0466 
0467     if (ipv6) {
0468         udp_conf.family = AF_INET6;
0469         udp_conf.ipv6_v6only = 1;
0470         udp_conf.use_udp6_rx_checksums = ipv6_rx_csum;
0471     } else {
0472         udp_conf.family = AF_INET;
0473         udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
0474     }
0475 
0476     udp_conf.local_udp_port = port;
0477 
0478     /* Open UDP socket */
0479     err = udp_sock_create(net, &udp_conf, &sock);
0480     if (err < 0)
0481         return ERR_PTR(err);
0482 
0483     udp_allow_gso(sock->sk);
0484     return sock;
0485 }
0486 
0487 static int geneve_hlen(struct genevehdr *gh)
0488 {
0489     return sizeof(*gh) + gh->opt_len * 4;
0490 }
0491 
0492 static struct sk_buff *geneve_gro_receive(struct sock *sk,
0493                       struct list_head *head,
0494                       struct sk_buff *skb)
0495 {
0496     struct sk_buff *pp = NULL;
0497     struct sk_buff *p;
0498     struct genevehdr *gh, *gh2;
0499     unsigned int hlen, gh_len, off_gnv;
0500     const struct packet_offload *ptype;
0501     __be16 type;
0502     int flush = 1;
0503 
0504     off_gnv = skb_gro_offset(skb);
0505     hlen = off_gnv + sizeof(*gh);
0506     gh = skb_gro_header_fast(skb, off_gnv);
0507     if (skb_gro_header_hard(skb, hlen)) {
0508         gh = skb_gro_header_slow(skb, hlen, off_gnv);
0509         if (unlikely(!gh))
0510             goto out;
0511     }
0512 
0513     if (gh->ver != GENEVE_VER || gh->oam)
0514         goto out;
0515     gh_len = geneve_hlen(gh);
0516 
0517     hlen = off_gnv + gh_len;
0518     if (skb_gro_header_hard(skb, hlen)) {
0519         gh = skb_gro_header_slow(skb, hlen, off_gnv);
0520         if (unlikely(!gh))
0521             goto out;
0522     }
0523 
0524     list_for_each_entry(p, head, list) {
0525         if (!NAPI_GRO_CB(p)->same_flow)
0526             continue;
0527 
0528         gh2 = (struct genevehdr *)(p->data + off_gnv);
0529         if (gh->opt_len != gh2->opt_len ||
0530             memcmp(gh, gh2, gh_len)) {
0531             NAPI_GRO_CB(p)->same_flow = 0;
0532             continue;
0533         }
0534     }
0535 
0536     skb_gro_pull(skb, gh_len);
0537     skb_gro_postpull_rcsum(skb, gh, gh_len);
0538     type = gh->proto_type;
0539     if (likely(type == htons(ETH_P_TEB)))
0540         return call_gro_receive(eth_gro_receive, head, skb);
0541 
0542     ptype = gro_find_receive_by_type(type);
0543     if (!ptype)
0544         goto out;
0545 
0546     pp = call_gro_receive(ptype->callbacks.gro_receive, head, skb);
0547     flush = 0;
0548 
0549 out:
0550     skb_gro_flush_final(skb, pp, flush);
0551 
0552     return pp;
0553 }
0554 
0555 static int geneve_gro_complete(struct sock *sk, struct sk_buff *skb,
0556                    int nhoff)
0557 {
0558     struct genevehdr *gh;
0559     struct packet_offload *ptype;
0560     __be16 type;
0561     int gh_len;
0562     int err = -ENOSYS;
0563 
0564     gh = (struct genevehdr *)(skb->data + nhoff);
0565     gh_len = geneve_hlen(gh);
0566     type = gh->proto_type;
0567 
0568     /* since skb->encapsulation is set, eth_gro_complete() sets the inner mac header */
0569     if (likely(type == htons(ETH_P_TEB)))
0570         return eth_gro_complete(skb, nhoff + gh_len);
0571 
0572     ptype = gro_find_complete_by_type(type);
0573     if (ptype)
0574         err = ptype->callbacks.gro_complete(skb, nhoff + gh_len);
0575 
0576     skb_set_inner_mac_header(skb, nhoff + gh_len);
0577 
0578     return err;
0579 }
0580 
0581 /* Create new listen socket if needed */
0582 static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port,
0583                         bool ipv6, bool ipv6_rx_csum)
0584 {
0585     struct geneve_net *gn = net_generic(net, geneve_net_id);
0586     struct geneve_sock *gs;
0587     struct socket *sock;
0588     struct udp_tunnel_sock_cfg tunnel_cfg;
0589     int h;
0590 
0591     gs = kzalloc(sizeof(*gs), GFP_KERNEL);
0592     if (!gs)
0593         return ERR_PTR(-ENOMEM);
0594 
0595     sock = geneve_create_sock(net, ipv6, port, ipv6_rx_csum);
0596     if (IS_ERR(sock)) {
0597         kfree(gs);
0598         return ERR_CAST(sock);
0599     }
0600 
0601     gs->sock = sock;
0602     gs->refcnt = 1;
0603     for (h = 0; h < VNI_HASH_SIZE; ++h)
0604         INIT_HLIST_HEAD(&gs->vni_list[h]);
0605 
0606     /* Initialize the geneve udp offloads structure */
0607     udp_tunnel_notify_add_rx_port(gs->sock, UDP_TUNNEL_TYPE_GENEVE);
0608 
0609     /* Mark socket as an encapsulation socket */
0610     memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
0611     tunnel_cfg.sk_user_data = gs;
0612     tunnel_cfg.encap_type = 1;
0613     tunnel_cfg.gro_receive = geneve_gro_receive;
0614     tunnel_cfg.gro_complete = geneve_gro_complete;
0615     tunnel_cfg.encap_rcv = geneve_udp_encap_recv;
0616     tunnel_cfg.encap_err_lookup = geneve_udp_encap_err_lookup;
0617     tunnel_cfg.encap_destroy = NULL;
0618     setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
0619     list_add(&gs->list, &gn->sock_list);
0620     return gs;
0621 }
0622 
0623 static void __geneve_sock_release(struct geneve_sock *gs)
0624 {
0625     if (!gs || --gs->refcnt)
0626         return;
0627 
0628     list_del(&gs->list);
0629     udp_tunnel_notify_del_rx_port(gs->sock, UDP_TUNNEL_TYPE_GENEVE);
0630     udp_tunnel_sock_release(gs->sock);
0631     kfree_rcu(gs, rcu);
0632 }
0633 
0634 static void geneve_sock_release(struct geneve_dev *geneve)
0635 {
0636     struct geneve_sock *gs4 = rtnl_dereference(geneve->sock4);
0637 #if IS_ENABLED(CONFIG_IPV6)
0638     struct geneve_sock *gs6 = rtnl_dereference(geneve->sock6);
0639 
0640     rcu_assign_pointer(geneve->sock6, NULL);
0641 #endif
0642 
0643     rcu_assign_pointer(geneve->sock4, NULL);
0644     synchronize_net();
0645 
0646     __geneve_sock_release(gs4);
0647 #if IS_ENABLED(CONFIG_IPV6)
0648     __geneve_sock_release(gs6);
0649 #endif
0650 }
0651 
0652 static struct geneve_sock *geneve_find_sock(struct geneve_net *gn,
0653                         sa_family_t family,
0654                         __be16 dst_port)
0655 {
0656     struct geneve_sock *gs;
0657 
0658     list_for_each_entry(gs, &gn->sock_list, list) {
0659         if (inet_sk(gs->sock->sk)->inet_sport == dst_port &&
0660             geneve_get_sk_family(gs) == family) {
0661             return gs;
0662         }
0663     }
0664     return NULL;
0665 }
0666 
0667 static int geneve_sock_add(struct geneve_dev *geneve, bool ipv6)
0668 {
0669     struct net *net = geneve->net;
0670     struct geneve_net *gn = net_generic(net, geneve_net_id);
0671     struct geneve_dev_node *node;
0672     struct geneve_sock *gs;
0673     __u8 vni[3];
0674     __u32 hash;
0675 
0676     gs = geneve_find_sock(gn, ipv6 ? AF_INET6 : AF_INET, geneve->cfg.info.key.tp_dst);
0677     if (gs) {
0678         gs->refcnt++;
0679         goto out;
0680     }
0681 
0682     gs = geneve_socket_create(net, geneve->cfg.info.key.tp_dst, ipv6,
0683                   geneve->cfg.use_udp6_rx_checksums);
0684     if (IS_ERR(gs))
0685         return PTR_ERR(gs);
0686 
0687 out:
0688     gs->collect_md = geneve->cfg.collect_md;
0689 #if IS_ENABLED(CONFIG_IPV6)
0690     if (ipv6) {
0691         rcu_assign_pointer(geneve->sock6, gs);
0692         node = &geneve->hlist6;
0693     } else
0694 #endif
0695     {
0696         rcu_assign_pointer(geneve->sock4, gs);
0697         node = &geneve->hlist4;
0698     }
0699     node->geneve = geneve;
0700 
0701     tunnel_id_to_vni(geneve->cfg.info.key.tun_id, vni);
0702     hash = geneve_net_vni_hash(vni);
0703     hlist_add_head_rcu(&node->hlist, &gs->vni_list[hash]);
0704     return 0;
0705 }
0706 
0707 static int geneve_open(struct net_device *dev)
0708 {
0709     struct geneve_dev *geneve = netdev_priv(dev);
0710     bool metadata = geneve->cfg.collect_md;
0711     bool ipv4, ipv6;
0712     int ret = 0;
0713 
0714     ipv6 = geneve->cfg.info.mode & IP_TUNNEL_INFO_IPV6 || metadata;
0715     ipv4 = !ipv6 || metadata;
0716 #if IS_ENABLED(CONFIG_IPV6)
0717     if (ipv6) {
0718         ret = geneve_sock_add(geneve, true);
0719         if (ret < 0 && ret != -EAFNOSUPPORT)
0720             ipv4 = false;
0721     }
0722 #endif
0723     if (ipv4)
0724         ret = geneve_sock_add(geneve, false);
0725     if (ret < 0)
0726         geneve_sock_release(geneve);
0727 
0728     return ret;
0729 }
0730 
0731 static int geneve_stop(struct net_device *dev)
0732 {
0733     struct geneve_dev *geneve = netdev_priv(dev);
0734 
0735     hlist_del_init_rcu(&geneve->hlist4.hlist);
0736 #if IS_ENABLED(CONFIG_IPV6)
0737     hlist_del_init_rcu(&geneve->hlist6.hlist);
0738 #endif
0739     geneve_sock_release(geneve);
0740     return 0;
0741 }
0742 
0743 static void geneve_build_header(struct genevehdr *geneveh,
0744                 const struct ip_tunnel_info *info,
0745                 __be16 inner_proto)
0746 {
0747     geneveh->ver = GENEVE_VER;
0748     geneveh->opt_len = info->options_len / 4;
0749     geneveh->oam = !!(info->key.tun_flags & TUNNEL_OAM);
0750     geneveh->critical = !!(info->key.tun_flags & TUNNEL_CRIT_OPT);
0751     geneveh->rsvd1 = 0;
0752     tunnel_id_to_vni(info->key.tun_id, geneveh->vni);
0753     geneveh->proto_type = inner_proto;
0754     geneveh->rsvd2 = 0;
0755 
0756     if (info->key.tun_flags & TUNNEL_GENEVE_OPT)
0757         ip_tunnel_info_opts_get(geneveh->options, info);
0758 }
0759 
0760 static int geneve_build_skb(struct dst_entry *dst, struct sk_buff *skb,
0761                 const struct ip_tunnel_info *info,
0762                 bool xnet, int ip_hdr_len,
0763                 bool inner_proto_inherit)
0764 {
0765     bool udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
0766     struct genevehdr *gnvh;
0767     __be16 inner_proto;
0768     int min_headroom;
0769     int err;
0770 
0771     skb_reset_mac_header(skb);
0772     skb_scrub_packet(skb, xnet);
0773 
0774     min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +
0775                GENEVE_BASE_HLEN + info->options_len + ip_hdr_len;
0776     err = skb_cow_head(skb, min_headroom);
0777     if (unlikely(err))
0778         goto free_dst;
0779 
0780     err = udp_tunnel_handle_offloads(skb, udp_sum);
0781     if (err)
0782         goto free_dst;
0783 
0784     gnvh = __skb_push(skb, sizeof(*gnvh) + info->options_len);
0785     inner_proto = inner_proto_inherit ? skb->protocol : htons(ETH_P_TEB);
0786     geneve_build_header(gnvh, info, inner_proto);
0787     skb_set_inner_protocol(skb, inner_proto);
0788     return 0;
0789 
0790 free_dst:
0791     dst_release(dst);
0792     return err;
0793 }
0794 
0795 static struct rtable *geneve_get_v4_rt(struct sk_buff *skb,
0796                        struct net_device *dev,
0797                        struct geneve_sock *gs4,
0798                        struct flowi4 *fl4,
0799                        const struct ip_tunnel_info *info,
0800                        __be16 dport, __be16 sport,
0801                        __u8 *full_tos)
0802 {
0803     bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
0804     struct geneve_dev *geneve = netdev_priv(dev);
0805     struct dst_cache *dst_cache;
0806     struct rtable *rt = NULL;
0807     __u8 tos;
0808 
0809     if (!gs4)
0810         return ERR_PTR(-EIO);
0811 
0812     memset(fl4, 0, sizeof(*fl4));
0813     fl4->flowi4_mark = skb->mark;
0814     fl4->flowi4_proto = IPPROTO_UDP;
0815     fl4->daddr = info->key.u.ipv4.dst;
0816     fl4->saddr = info->key.u.ipv4.src;
0817     fl4->fl4_dport = dport;
0818     fl4->fl4_sport = sport;
0819     fl4->flowi4_flags = info->key.flow_flags;
0820 
0821     tos = info->key.tos;
0822     if ((tos == 1) && !geneve->cfg.collect_md) {
0823         tos = ip_tunnel_get_dsfield(ip_hdr(skb), skb);
0824         use_cache = false;
0825     }
0826     fl4->flowi4_tos = RT_TOS(tos);
0827     if (full_tos)
0828         *full_tos = tos;
0829 
0830     dst_cache = (struct dst_cache *)&info->dst_cache;
0831     if (use_cache) {
0832         rt = dst_cache_get_ip4(dst_cache, &fl4->saddr);
0833         if (rt)
0834             return rt;
0835     }
0836     rt = ip_route_output_key(geneve->net, fl4);
0837     if (IS_ERR(rt)) {
0838         netdev_dbg(dev, "no route to %pI4\n", &fl4->daddr);
0839         return ERR_PTR(-ENETUNREACH);
0840     }
0841     if (rt->dst.dev == dev) { /* is this necessary? */
0842         netdev_dbg(dev, "circular route to %pI4\n", &fl4->daddr);
0843         ip_rt_put(rt);
0844         return ERR_PTR(-ELOOP);
0845     }
0846     if (use_cache)
0847         dst_cache_set_ip4(dst_cache, &rt->dst, fl4->saddr);
0848     return rt;
0849 }
0850 
0851 #if IS_ENABLED(CONFIG_IPV6)
0852 static struct dst_entry *geneve_get_v6_dst(struct sk_buff *skb,
0853                        struct net_device *dev,
0854                        struct geneve_sock *gs6,
0855                        struct flowi6 *fl6,
0856                        const struct ip_tunnel_info *info,
0857                        __be16 dport, __be16 sport)
0858 {
0859     bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
0860     struct geneve_dev *geneve = netdev_priv(dev);
0861     struct dst_entry *dst = NULL;
0862     struct dst_cache *dst_cache;
0863     __u8 prio;
0864 
0865     if (!gs6)
0866         return ERR_PTR(-EIO);
0867 
0868     memset(fl6, 0, sizeof(*fl6));
0869     fl6->flowi6_mark = skb->mark;
0870     fl6->flowi6_proto = IPPROTO_UDP;
0871     fl6->daddr = info->key.u.ipv6.dst;
0872     fl6->saddr = info->key.u.ipv6.src;
0873     fl6->fl6_dport = dport;
0874     fl6->fl6_sport = sport;
0875 
0876     prio = info->key.tos;
0877     if ((prio == 1) && !geneve->cfg.collect_md) {
0878         prio = ip_tunnel_get_dsfield(ip_hdr(skb), skb);
0879         use_cache = false;
0880     }
0881 
0882     fl6->flowlabel = ip6_make_flowinfo(prio, info->key.label);
0883     dst_cache = (struct dst_cache *)&info->dst_cache;
0884     if (use_cache) {
0885         dst = dst_cache_get_ip6(dst_cache, &fl6->saddr);
0886         if (dst)
0887             return dst;
0888     }
0889     dst = ipv6_stub->ipv6_dst_lookup_flow(geneve->net, gs6->sock->sk, fl6,
0890                           NULL);
0891     if (IS_ERR(dst)) {
0892         netdev_dbg(dev, "no route to %pI6\n", &fl6->daddr);
0893         return ERR_PTR(-ENETUNREACH);
0894     }
0895     if (dst->dev == dev) { /* is this necessary? */
0896         netdev_dbg(dev, "circular route to %pI6\n", &fl6->daddr);
0897         dst_release(dst);
0898         return ERR_PTR(-ELOOP);
0899     }
0900 
0901     if (use_cache)
0902         dst_cache_set_ip6(dst_cache, dst, &fl6->saddr);
0903     return dst;
0904 }
0905 #endif
0906 
0907 static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev,
0908                struct geneve_dev *geneve,
0909                const struct ip_tunnel_info *info)
0910 {
0911     bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
0912     struct geneve_sock *gs4 = rcu_dereference(geneve->sock4);
0913     const struct ip_tunnel_key *key = &info->key;
0914     struct rtable *rt;
0915     struct flowi4 fl4;
0916     __u8 full_tos;
0917     __u8 tos, ttl;
0918     __be16 df = 0;
0919     __be16 sport;
0920     int err;
0921 
0922     if (!pskb_inet_may_pull(skb))
0923         return -EINVAL;
0924 
0925     sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
0926     rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info,
0927                   geneve->cfg.info.key.tp_dst, sport, &full_tos);
0928     if (IS_ERR(rt))
0929         return PTR_ERR(rt);
0930 
0931     err = skb_tunnel_check_pmtu(skb, &rt->dst,
0932                     GENEVE_IPV4_HLEN + info->options_len,
0933                     netif_is_any_bridge_port(dev));
0934     if (err < 0) {
0935         dst_release(&rt->dst);
0936         return err;
0937     } else if (err) {
0938         struct ip_tunnel_info *info;
0939 
0940         info = skb_tunnel_info(skb);
0941         if (info) {
0942             struct ip_tunnel_info *unclone;
0943 
0944             unclone = skb_tunnel_info_unclone(skb);
0945             if (unlikely(!unclone)) {
0946                 dst_release(&rt->dst);
0947                 return -ENOMEM;
0948             }
0949 
0950             unclone->key.u.ipv4.dst = fl4.saddr;
0951             unclone->key.u.ipv4.src = fl4.daddr;
0952         }
0953 
0954         if (!pskb_may_pull(skb, ETH_HLEN)) {
0955             dst_release(&rt->dst);
0956             return -EINVAL;
0957         }
0958 
0959         skb->protocol = eth_type_trans(skb, geneve->dev);
0960         __netif_rx(skb);
0961         dst_release(&rt->dst);
0962         return -EMSGSIZE;
0963     }
0964 
0965     if (geneve->cfg.collect_md) {
0966         tos = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
0967         ttl = key->ttl;
0968 
0969         df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
0970     } else {
0971         tos = ip_tunnel_ecn_encap(full_tos, ip_hdr(skb), skb);
0972         if (geneve->cfg.ttl_inherit)
0973             ttl = ip_tunnel_get_ttl(ip_hdr(skb), skb);
0974         else
0975             ttl = key->ttl;
0976         ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
0977 
0978         if (geneve->cfg.df == GENEVE_DF_SET) {
0979             df = htons(IP_DF);
0980         } else if (geneve->cfg.df == GENEVE_DF_INHERIT) {
0981             struct ethhdr *eth = eth_hdr(skb);
0982 
0983             if (ntohs(eth->h_proto) == ETH_P_IPV6) {
0984                 df = htons(IP_DF);
0985             } else if (ntohs(eth->h_proto) == ETH_P_IP) {
0986                 struct iphdr *iph = ip_hdr(skb);
0987 
0988                 if (iph->frag_off & htons(IP_DF))
0989                     df = htons(IP_DF);
0990             }
0991         }
0992     }
0993 
0994     err = geneve_build_skb(&rt->dst, skb, info, xnet, sizeof(struct iphdr),
0995                    geneve->cfg.inner_proto_inherit);
0996     if (unlikely(err))
0997         return err;
0998 
0999     udp_tunnel_xmit_skb(rt, gs4->sock->sk, skb, fl4.saddr, fl4.daddr,
1000                 tos, ttl, df, sport, geneve->cfg.info.key.tp_dst,
1001                 !net_eq(geneve->net, dev_net(geneve->dev)),
1002                 !(info->key.tun_flags & TUNNEL_CSUM));
1003     return 0;
1004 }
1005 
1006 #if IS_ENABLED(CONFIG_IPV6)
1007 static int geneve6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
1008                 struct geneve_dev *geneve,
1009                 const struct ip_tunnel_info *info)
1010 {
1011     bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
1012     struct geneve_sock *gs6 = rcu_dereference(geneve->sock6);
1013     const struct ip_tunnel_key *key = &info->key;
1014     struct dst_entry *dst = NULL;
1015     struct flowi6 fl6;
1016     __u8 prio, ttl;
1017     __be16 sport;
1018     int err;
1019 
1020     if (!pskb_inet_may_pull(skb))
1021         return -EINVAL;
1022 
1023     sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
1024     dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info,
1025                 geneve->cfg.info.key.tp_dst, sport);
1026     if (IS_ERR(dst))
1027         return PTR_ERR(dst);
1028 
1029     err = skb_tunnel_check_pmtu(skb, dst,
1030                     GENEVE_IPV6_HLEN + info->options_len,
1031                     netif_is_any_bridge_port(dev));
1032     if (err < 0) {
1033         dst_release(dst);
1034         return err;
1035     } else if (err) {
1036         struct ip_tunnel_info *info = skb_tunnel_info(skb);
1037 
1038         if (info) {
1039             struct ip_tunnel_info *unclone;
1040 
1041             unclone = skb_tunnel_info_unclone(skb);
1042             if (unlikely(!unclone)) {
1043                 dst_release(dst);
1044                 return -ENOMEM;
1045             }
1046 
1047             unclone->key.u.ipv6.dst = fl6.saddr;
1048             unclone->key.u.ipv6.src = fl6.daddr;
1049         }
1050 
1051         if (!pskb_may_pull(skb, ETH_HLEN)) {
1052             dst_release(dst);
1053             return -EINVAL;
1054         }
1055 
1056         skb->protocol = eth_type_trans(skb, geneve->dev);
1057         __netif_rx(skb);
1058         dst_release(dst);
1059         return -EMSGSIZE;
1060     }
1061 
1062     if (geneve->cfg.collect_md) {
1063         prio = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
1064         ttl = key->ttl;
1065     } else {
1066         prio = ip_tunnel_ecn_encap(ip6_tclass(fl6.flowlabel),
1067                        ip_hdr(skb), skb);
1068         if (geneve->cfg.ttl_inherit)
1069             ttl = ip_tunnel_get_ttl(ip_hdr(skb), skb);
1070         else
1071             ttl = key->ttl;
1072         ttl = ttl ? : ip6_dst_hoplimit(dst);
1073     }
1074     err = geneve_build_skb(dst, skb, info, xnet, sizeof(struct ipv6hdr),
1075                    geneve->cfg.inner_proto_inherit);
1076     if (unlikely(err))
1077         return err;
1078 
1079     udp_tunnel6_xmit_skb(dst, gs6->sock->sk, skb, dev,
1080                  &fl6.saddr, &fl6.daddr, prio, ttl,
1081                  info->key.label, sport, geneve->cfg.info.key.tp_dst,
1082                  !(info->key.tun_flags & TUNNEL_CSUM));
1083     return 0;
1084 }
1085 #endif
1086 
1087 static netdev_tx_t geneve_xmit(struct sk_buff *skb, struct net_device *dev)
1088 {
1089     struct geneve_dev *geneve = netdev_priv(dev);
1090     struct ip_tunnel_info *info = NULL;
1091     int err;
1092 
1093     if (geneve->cfg.collect_md) {
1094         info = skb_tunnel_info(skb);
1095         if (unlikely(!info || !(info->mode & IP_TUNNEL_INFO_TX))) {
1096             netdev_dbg(dev, "no tunnel metadata\n");
1097             dev_kfree_skb(skb);
1098             dev->stats.tx_dropped++;
1099             return NETDEV_TX_OK;
1100         }
1101     } else {
1102         info = &geneve->cfg.info;
1103     }
1104 
1105     rcu_read_lock();
1106 #if IS_ENABLED(CONFIG_IPV6)
1107     if (info->mode & IP_TUNNEL_INFO_IPV6)
1108         err = geneve6_xmit_skb(skb, dev, geneve, info);
1109     else
1110 #endif
1111         err = geneve_xmit_skb(skb, dev, geneve, info);
1112     rcu_read_unlock();
1113 
1114     if (likely(!err))
1115         return NETDEV_TX_OK;
1116 
1117     if (err != -EMSGSIZE)
1118         dev_kfree_skb(skb);
1119 
1120     if (err == -ELOOP)
1121         dev->stats.collisions++;
1122     else if (err == -ENETUNREACH)
1123         dev->stats.tx_carrier_errors++;
1124 
1125     dev->stats.tx_errors++;
1126     return NETDEV_TX_OK;
1127 }
1128 
1129 static int geneve_change_mtu(struct net_device *dev, int new_mtu)
1130 {
1131     if (new_mtu > dev->max_mtu)
1132         new_mtu = dev->max_mtu;
1133     else if (new_mtu < dev->min_mtu)
1134         new_mtu = dev->min_mtu;
1135 
1136     dev->mtu = new_mtu;
1137     return 0;
1138 }
1139 
1140 static int geneve_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
1141 {
1142     struct ip_tunnel_info *info = skb_tunnel_info(skb);
1143     struct geneve_dev *geneve = netdev_priv(dev);
1144     __be16 sport;
1145 
1146     if (ip_tunnel_info_af(info) == AF_INET) {
1147         struct rtable *rt;
1148         struct flowi4 fl4;
1149 
1150         struct geneve_sock *gs4 = rcu_dereference(geneve->sock4);
1151         sport = udp_flow_src_port(geneve->net, skb,
1152                       1, USHRT_MAX, true);
1153 
1154         rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info,
1155                       geneve->cfg.info.key.tp_dst, sport, NULL);
1156         if (IS_ERR(rt))
1157             return PTR_ERR(rt);
1158 
1159         ip_rt_put(rt);
1160         info->key.u.ipv4.src = fl4.saddr;
1161 #if IS_ENABLED(CONFIG_IPV6)
1162     } else if (ip_tunnel_info_af(info) == AF_INET6) {
1163         struct dst_entry *dst;
1164         struct flowi6 fl6;
1165 
1166         struct geneve_sock *gs6 = rcu_dereference(geneve->sock6);
1167         sport = udp_flow_src_port(geneve->net, skb,
1168                       1, USHRT_MAX, true);
1169 
1170         dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info,
1171                     geneve->cfg.info.key.tp_dst, sport);
1172         if (IS_ERR(dst))
1173             return PTR_ERR(dst);
1174 
1175         dst_release(dst);
1176         info->key.u.ipv6.src = fl6.saddr;
1177 #endif
1178     } else {
1179         return -EINVAL;
1180     }
1181 
1182     info->key.tp_src = sport;
1183     info->key.tp_dst = geneve->cfg.info.key.tp_dst;
1184     return 0;
1185 }
1186 
1187 static const struct net_device_ops geneve_netdev_ops = {
1188     .ndo_init       = geneve_init,
1189     .ndo_uninit     = geneve_uninit,
1190     .ndo_open       = geneve_open,
1191     .ndo_stop       = geneve_stop,
1192     .ndo_start_xmit     = geneve_xmit,
1193     .ndo_get_stats64    = dev_get_tstats64,
1194     .ndo_change_mtu     = geneve_change_mtu,
1195     .ndo_validate_addr  = eth_validate_addr,
1196     .ndo_set_mac_address    = eth_mac_addr,
1197     .ndo_fill_metadata_dst  = geneve_fill_metadata_dst,
1198 };
1199 
1200 static void geneve_get_drvinfo(struct net_device *dev,
1201                    struct ethtool_drvinfo *drvinfo)
1202 {
1203     strlcpy(drvinfo->version, GENEVE_NETDEV_VER, sizeof(drvinfo->version));
1204     strlcpy(drvinfo->driver, "geneve", sizeof(drvinfo->driver));
1205 }
1206 
1207 static const struct ethtool_ops geneve_ethtool_ops = {
1208     .get_drvinfo    = geneve_get_drvinfo,
1209     .get_link   = ethtool_op_get_link,
1210 };
1211 
1212 /* Info for udev, that this is a virtual tunnel endpoint */
1213 static struct device_type geneve_type = {
1214     .name = "geneve",
1215 };
1216 
1217 /* Calls the ndo_udp_tunnel_add of the caller in order to
1218  * supply the listening GENEVE udp ports. Callers are expected
1219  * to implement the ndo_udp_tunnel_add.
1220  */
1221 static void geneve_offload_rx_ports(struct net_device *dev, bool push)
1222 {
1223     struct net *net = dev_net(dev);
1224     struct geneve_net *gn = net_generic(net, geneve_net_id);
1225     struct geneve_sock *gs;
1226 
1227     rcu_read_lock();
1228     list_for_each_entry_rcu(gs, &gn->sock_list, list) {
1229         if (push) {
1230             udp_tunnel_push_rx_port(dev, gs->sock,
1231                         UDP_TUNNEL_TYPE_GENEVE);
1232         } else {
1233             udp_tunnel_drop_rx_port(dev, gs->sock,
1234                         UDP_TUNNEL_TYPE_GENEVE);
1235         }
1236     }
1237     rcu_read_unlock();
1238 }
1239 
1240 /* Initialize the device structure. */
1241 static void geneve_setup(struct net_device *dev)
1242 {
1243     ether_setup(dev);
1244 
1245     dev->netdev_ops = &geneve_netdev_ops;
1246     dev->ethtool_ops = &geneve_ethtool_ops;
1247     dev->needs_free_netdev = true;
1248 
1249     SET_NETDEV_DEVTYPE(dev, &geneve_type);
1250 
1251     dev->features    |= NETIF_F_LLTX;
1252     dev->features    |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;
1253     dev->features    |= NETIF_F_RXCSUM;
1254     dev->features    |= NETIF_F_GSO_SOFTWARE;
1255 
1256     dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;
1257     dev->hw_features |= NETIF_F_RXCSUM;
1258     dev->hw_features |= NETIF_F_GSO_SOFTWARE;
1259 
1260     /* MTU range: 68 - (something less than 65535) */
1261     dev->min_mtu = ETH_MIN_MTU;
1262     /* The max_mtu calculation does not take account of GENEVE
1263      * options, to avoid excluding potentially valid
1264      * configurations. This will be further reduced by IPvX hdr size.
1265      */
1266     dev->max_mtu = IP_MAX_MTU - GENEVE_BASE_HLEN - dev->hard_header_len;
1267 
1268     netif_keep_dst(dev);
1269     dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1270     dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
1271     eth_hw_addr_random(dev);
1272 }
1273 
1274 static const struct nla_policy geneve_policy[IFLA_GENEVE_MAX + 1] = {
1275     [IFLA_GENEVE_UNSPEC]        = { .strict_start_type = IFLA_GENEVE_INNER_PROTO_INHERIT },
1276     [IFLA_GENEVE_ID]        = { .type = NLA_U32 },
1277     [IFLA_GENEVE_REMOTE]        = { .len = sizeof_field(struct iphdr, daddr) },
1278     [IFLA_GENEVE_REMOTE6]       = { .len = sizeof(struct in6_addr) },
1279     [IFLA_GENEVE_TTL]       = { .type = NLA_U8 },
1280     [IFLA_GENEVE_TOS]       = { .type = NLA_U8 },
1281     [IFLA_GENEVE_LABEL]     = { .type = NLA_U32 },
1282     [IFLA_GENEVE_PORT]      = { .type = NLA_U16 },
1283     [IFLA_GENEVE_COLLECT_METADATA]  = { .type = NLA_FLAG },
1284     [IFLA_GENEVE_UDP_CSUM]      = { .type = NLA_U8 },
1285     [IFLA_GENEVE_UDP_ZERO_CSUM6_TX] = { .type = NLA_U8 },
1286     [IFLA_GENEVE_UDP_ZERO_CSUM6_RX] = { .type = NLA_U8 },
1287     [IFLA_GENEVE_TTL_INHERIT]   = { .type = NLA_U8 },
1288     [IFLA_GENEVE_DF]        = { .type = NLA_U8 },
1289     [IFLA_GENEVE_INNER_PROTO_INHERIT]   = { .type = NLA_FLAG },
1290 };
1291 
1292 static int geneve_validate(struct nlattr *tb[], struct nlattr *data[],
1293                struct netlink_ext_ack *extack)
1294 {
1295     if (tb[IFLA_ADDRESS]) {
1296         if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {
1297             NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],
1298                         "Provided link layer address is not Ethernet");
1299             return -EINVAL;
1300         }
1301 
1302         if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {
1303             NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],
1304                         "Provided Ethernet address is not unicast");
1305             return -EADDRNOTAVAIL;
1306         }
1307     }
1308 
1309     if (!data) {
1310         NL_SET_ERR_MSG(extack,
1311                    "Not enough attributes provided to perform the operation");
1312         return -EINVAL;
1313     }
1314 
1315     if (data[IFLA_GENEVE_ID]) {
1316         __u32 vni =  nla_get_u32(data[IFLA_GENEVE_ID]);
1317 
1318         if (vni >= GENEVE_N_VID) {
1319             NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_ID],
1320                         "Geneve ID must be lower than 16777216");
1321             return -ERANGE;
1322         }
1323     }
1324 
1325     if (data[IFLA_GENEVE_DF]) {
1326         enum ifla_geneve_df df = nla_get_u8(data[IFLA_GENEVE_DF]);
1327 
1328         if (df < 0 || df > GENEVE_DF_MAX) {
1329             NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_DF],
1330                         "Invalid DF attribute");
1331             return -EINVAL;
1332         }
1333     }
1334 
1335     return 0;
1336 }
1337 
1338 static struct geneve_dev *geneve_find_dev(struct geneve_net *gn,
1339                       const struct ip_tunnel_info *info,
1340                       bool *tun_on_same_port,
1341                       bool *tun_collect_md)
1342 {
1343     struct geneve_dev *geneve, *t = NULL;
1344 
1345     *tun_on_same_port = false;
1346     *tun_collect_md = false;
1347     list_for_each_entry(geneve, &gn->geneve_list, next) {
1348         if (info->key.tp_dst == geneve->cfg.info.key.tp_dst) {
1349             *tun_collect_md = geneve->cfg.collect_md;
1350             *tun_on_same_port = true;
1351         }
1352         if (info->key.tun_id == geneve->cfg.info.key.tun_id &&
1353             info->key.tp_dst == geneve->cfg.info.key.tp_dst &&
1354             !memcmp(&info->key.u, &geneve->cfg.info.key.u, sizeof(info->key.u)))
1355             t = geneve;
1356     }
1357     return t;
1358 }
1359 
1360 static bool is_tnl_info_zero(const struct ip_tunnel_info *info)
1361 {
1362     return !(info->key.tun_id || info->key.tun_flags || info->key.tos ||
1363          info->key.ttl || info->key.label || info->key.tp_src ||
1364          memchr_inv(&info->key.u, 0, sizeof(info->key.u)));
1365 }
1366 
1367 static bool geneve_dst_addr_equal(struct ip_tunnel_info *a,
1368                   struct ip_tunnel_info *b)
1369 {
1370     if (ip_tunnel_info_af(a) == AF_INET)
1371         return a->key.u.ipv4.dst == b->key.u.ipv4.dst;
1372     else
1373         return ipv6_addr_equal(&a->key.u.ipv6.dst, &b->key.u.ipv6.dst);
1374 }
1375 
1376 static int geneve_configure(struct net *net, struct net_device *dev,
1377                 struct netlink_ext_ack *extack,
1378                 const struct geneve_config *cfg)
1379 {
1380     struct geneve_net *gn = net_generic(net, geneve_net_id);
1381     struct geneve_dev *t, *geneve = netdev_priv(dev);
1382     const struct ip_tunnel_info *info = &cfg->info;
1383     bool tun_collect_md, tun_on_same_port;
1384     int err, encap_len;
1385 
1386     if (cfg->collect_md && !is_tnl_info_zero(info)) {
1387         NL_SET_ERR_MSG(extack,
1388                    "Device is externally controlled, so attributes (VNI, Port, and so on) must not be specified");
1389         return -EINVAL;
1390     }
1391 
1392     geneve->net = net;
1393     geneve->dev = dev;
1394 
1395     t = geneve_find_dev(gn, info, &tun_on_same_port, &tun_collect_md);
1396     if (t)
1397         return -EBUSY;
1398 
1399     /* make enough headroom for basic scenario */
1400     encap_len = GENEVE_BASE_HLEN + ETH_HLEN;
1401     if (!cfg->collect_md && ip_tunnel_info_af(info) == AF_INET) {
1402         encap_len += sizeof(struct iphdr);
1403         dev->max_mtu -= sizeof(struct iphdr);
1404     } else {
1405         encap_len += sizeof(struct ipv6hdr);
1406         dev->max_mtu -= sizeof(struct ipv6hdr);
1407     }
1408     dev->needed_headroom = encap_len + ETH_HLEN;
1409 
1410     if (cfg->collect_md) {
1411         if (tun_on_same_port) {
1412             NL_SET_ERR_MSG(extack,
1413                        "There can be only one externally controlled device on a destination port");
1414             return -EPERM;
1415         }
1416     } else {
1417         if (tun_collect_md) {
1418             NL_SET_ERR_MSG(extack,
1419                        "There already exists an externally controlled device on this destination port");
1420             return -EPERM;
1421         }
1422     }
1423 
1424     dst_cache_reset(&geneve->cfg.info.dst_cache);
1425     memcpy(&geneve->cfg, cfg, sizeof(*cfg));
1426 
1427     if (geneve->cfg.inner_proto_inherit) {
1428         dev->header_ops = NULL;
1429         dev->type = ARPHRD_NONE;
1430         dev->hard_header_len = 0;
1431         dev->addr_len = 0;
1432         dev->flags = IFF_NOARP;
1433     }
1434 
1435     err = register_netdevice(dev);
1436     if (err)
1437         return err;
1438 
1439     list_add(&geneve->next, &gn->geneve_list);
1440     return 0;
1441 }
1442 
1443 static void init_tnl_info(struct ip_tunnel_info *info, __u16 dst_port)
1444 {
1445     memset(info, 0, sizeof(*info));
1446     info->key.tp_dst = htons(dst_port);
1447 }
1448 
1449 static int geneve_nl2info(struct nlattr *tb[], struct nlattr *data[],
1450               struct netlink_ext_ack *extack,
1451               struct geneve_config *cfg, bool changelink)
1452 {
1453     struct ip_tunnel_info *info = &cfg->info;
1454     int attrtype;
1455 
1456     if (data[IFLA_GENEVE_REMOTE] && data[IFLA_GENEVE_REMOTE6]) {
1457         NL_SET_ERR_MSG(extack,
1458                    "Cannot specify both IPv4 and IPv6 Remote addresses");
1459         return -EINVAL;
1460     }
1461 
1462     if (data[IFLA_GENEVE_REMOTE]) {
1463         if (changelink && (ip_tunnel_info_af(info) == AF_INET6)) {
1464             attrtype = IFLA_GENEVE_REMOTE;
1465             goto change_notsup;
1466         }
1467 
1468         info->key.u.ipv4.dst =
1469             nla_get_in_addr(data[IFLA_GENEVE_REMOTE]);
1470 
1471         if (ipv4_is_multicast(info->key.u.ipv4.dst)) {
1472             NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE],
1473                         "Remote IPv4 address cannot be Multicast");
1474             return -EINVAL;
1475         }
1476     }
1477 
1478     if (data[IFLA_GENEVE_REMOTE6]) {
1479 #if IS_ENABLED(CONFIG_IPV6)
1480         if (changelink && (ip_tunnel_info_af(info) == AF_INET)) {
1481             attrtype = IFLA_GENEVE_REMOTE6;
1482             goto change_notsup;
1483         }
1484 
1485         info->mode = IP_TUNNEL_INFO_IPV6;
1486         info->key.u.ipv6.dst =
1487             nla_get_in6_addr(data[IFLA_GENEVE_REMOTE6]);
1488 
1489         if (ipv6_addr_type(&info->key.u.ipv6.dst) &
1490             IPV6_ADDR_LINKLOCAL) {
1491             NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE6],
1492                         "Remote IPv6 address cannot be link-local");
1493             return -EINVAL;
1494         }
1495         if (ipv6_addr_is_multicast(&info->key.u.ipv6.dst)) {
1496             NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE6],
1497                         "Remote IPv6 address cannot be Multicast");
1498             return -EINVAL;
1499         }
1500         info->key.tun_flags |= TUNNEL_CSUM;
1501         cfg->use_udp6_rx_checksums = true;
1502 #else
1503         NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_REMOTE6],
1504                     "IPv6 support not enabled in the kernel");
1505         return -EPFNOSUPPORT;
1506 #endif
1507     }
1508 
1509     if (data[IFLA_GENEVE_ID]) {
1510         __u32 vni;
1511         __u8 tvni[3];
1512         __be64 tunid;
1513 
1514         vni = nla_get_u32(data[IFLA_GENEVE_ID]);
1515         tvni[0] = (vni & 0x00ff0000) >> 16;
1516         tvni[1] = (vni & 0x0000ff00) >> 8;
1517         tvni[2] =  vni & 0x000000ff;
1518 
1519         tunid = vni_to_tunnel_id(tvni);
1520         if (changelink && (tunid != info->key.tun_id)) {
1521             attrtype = IFLA_GENEVE_ID;
1522             goto change_notsup;
1523         }
1524         info->key.tun_id = tunid;
1525     }
1526 
1527     if (data[IFLA_GENEVE_TTL_INHERIT]) {
1528         if (nla_get_u8(data[IFLA_GENEVE_TTL_INHERIT]))
1529             cfg->ttl_inherit = true;
1530         else
1531             cfg->ttl_inherit = false;
1532     } else if (data[IFLA_GENEVE_TTL]) {
1533         info->key.ttl = nla_get_u8(data[IFLA_GENEVE_TTL]);
1534         cfg->ttl_inherit = false;
1535     }
1536 
1537     if (data[IFLA_GENEVE_TOS])
1538         info->key.tos = nla_get_u8(data[IFLA_GENEVE_TOS]);
1539 
1540     if (data[IFLA_GENEVE_DF])
1541         cfg->df = nla_get_u8(data[IFLA_GENEVE_DF]);
1542 
1543     if (data[IFLA_GENEVE_LABEL]) {
1544         info->key.label = nla_get_be32(data[IFLA_GENEVE_LABEL]) &
1545                   IPV6_FLOWLABEL_MASK;
1546         if (info->key.label && (!(info->mode & IP_TUNNEL_INFO_IPV6))) {
1547             NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_LABEL],
1548                         "Label attribute only applies for IPv6 Geneve devices");
1549             return -EINVAL;
1550         }
1551     }
1552 
1553     if (data[IFLA_GENEVE_PORT]) {
1554         if (changelink) {
1555             attrtype = IFLA_GENEVE_PORT;
1556             goto change_notsup;
1557         }
1558         info->key.tp_dst = nla_get_be16(data[IFLA_GENEVE_PORT]);
1559     }
1560 
1561     if (data[IFLA_GENEVE_COLLECT_METADATA]) {
1562         if (changelink) {
1563             attrtype = IFLA_GENEVE_COLLECT_METADATA;
1564             goto change_notsup;
1565         }
1566         cfg->collect_md = true;
1567     }
1568 
1569     if (data[IFLA_GENEVE_UDP_CSUM]) {
1570         if (changelink) {
1571             attrtype = IFLA_GENEVE_UDP_CSUM;
1572             goto change_notsup;
1573         }
1574         if (nla_get_u8(data[IFLA_GENEVE_UDP_CSUM]))
1575             info->key.tun_flags |= TUNNEL_CSUM;
1576     }
1577 
1578     if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]) {
1579 #if IS_ENABLED(CONFIG_IPV6)
1580         if (changelink) {
1581             attrtype = IFLA_GENEVE_UDP_ZERO_CSUM6_TX;
1582             goto change_notsup;
1583         }
1584         if (nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]))
1585             info->key.tun_flags &= ~TUNNEL_CSUM;
1586 #else
1587         NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX],
1588                     "IPv6 support not enabled in the kernel");
1589         return -EPFNOSUPPORT;
1590 #endif
1591     }
1592 
1593     if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]) {
1594 #if IS_ENABLED(CONFIG_IPV6)
1595         if (changelink) {
1596             attrtype = IFLA_GENEVE_UDP_ZERO_CSUM6_RX;
1597             goto change_notsup;
1598         }
1599         if (nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]))
1600             cfg->use_udp6_rx_checksums = false;
1601 #else
1602         NL_SET_ERR_MSG_ATTR(extack, data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX],
1603                     "IPv6 support not enabled in the kernel");
1604         return -EPFNOSUPPORT;
1605 #endif
1606     }
1607 
1608     if (data[IFLA_GENEVE_INNER_PROTO_INHERIT]) {
1609         if (changelink) {
1610             attrtype = IFLA_GENEVE_INNER_PROTO_INHERIT;
1611             goto change_notsup;
1612         }
1613         cfg->inner_proto_inherit = true;
1614     }
1615 
1616     return 0;
1617 change_notsup:
1618     NL_SET_ERR_MSG_ATTR(extack, data[attrtype],
1619                 "Changing VNI, Port, endpoint IP address family, external, inner_proto_inherit, and UDP checksum attributes are not supported");
1620     return -EOPNOTSUPP;
1621 }
1622 
1623 static void geneve_link_config(struct net_device *dev,
1624                    struct ip_tunnel_info *info, struct nlattr *tb[])
1625 {
1626     struct geneve_dev *geneve = netdev_priv(dev);
1627     int ldev_mtu = 0;
1628 
1629     if (tb[IFLA_MTU]) {
1630         geneve_change_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
1631         return;
1632     }
1633 
1634     switch (ip_tunnel_info_af(info)) {
1635     case AF_INET: {
1636         struct flowi4 fl4 = { .daddr = info->key.u.ipv4.dst };
1637         struct rtable *rt = ip_route_output_key(geneve->net, &fl4);
1638 
1639         if (!IS_ERR(rt) && rt->dst.dev) {
1640             ldev_mtu = rt->dst.dev->mtu - GENEVE_IPV4_HLEN;
1641             ip_rt_put(rt);
1642         }
1643         break;
1644     }
1645 #if IS_ENABLED(CONFIG_IPV6)
1646     case AF_INET6: {
1647         struct rt6_info *rt;
1648 
1649         if (!__in6_dev_get(dev))
1650             break;
1651 
1652         rt = rt6_lookup(geneve->net, &info->key.u.ipv6.dst, NULL, 0,
1653                 NULL, 0);
1654 
1655         if (rt && rt->dst.dev)
1656             ldev_mtu = rt->dst.dev->mtu - GENEVE_IPV6_HLEN;
1657         ip6_rt_put(rt);
1658         break;
1659     }
1660 #endif
1661     }
1662 
1663     if (ldev_mtu <= 0)
1664         return;
1665 
1666     geneve_change_mtu(dev, ldev_mtu - info->options_len);
1667 }
1668 
1669 static int geneve_newlink(struct net *net, struct net_device *dev,
1670               struct nlattr *tb[], struct nlattr *data[],
1671               struct netlink_ext_ack *extack)
1672 {
1673     struct geneve_config cfg = {
1674         .df = GENEVE_DF_UNSET,
1675         .use_udp6_rx_checksums = false,
1676         .ttl_inherit = false,
1677         .collect_md = false,
1678     };
1679     int err;
1680 
1681     init_tnl_info(&cfg.info, GENEVE_UDP_PORT);
1682     err = geneve_nl2info(tb, data, extack, &cfg, false);
1683     if (err)
1684         return err;
1685 
1686     err = geneve_configure(net, dev, extack, &cfg);
1687     if (err)
1688         return err;
1689 
1690     geneve_link_config(dev, &cfg.info, tb);
1691 
1692     return 0;
1693 }
1694 
1695 /* Quiesces the geneve device data path for both TX and RX.
1696  *
1697  * On transmit geneve checks for non-NULL geneve_sock before it proceeds.
1698  * So, if we set that socket to NULL under RCU and wait for synchronize_net()
1699  * to complete for the existing set of in-flight packets to be transmitted,
1700  * then we would have quiesced the transmit data path. All the future packets
1701  * will get dropped until we unquiesce the data path.
1702  *
1703  * On receive geneve dereference the geneve_sock stashed in the socket. So,
1704  * if we set that to NULL under RCU and wait for synchronize_net() to
1705  * complete, then we would have quiesced the receive data path.
1706  */
1707 static void geneve_quiesce(struct geneve_dev *geneve, struct geneve_sock **gs4,
1708                struct geneve_sock **gs6)
1709 {
1710     *gs4 = rtnl_dereference(geneve->sock4);
1711     rcu_assign_pointer(geneve->sock4, NULL);
1712     if (*gs4)
1713         rcu_assign_sk_user_data((*gs4)->sock->sk, NULL);
1714 #if IS_ENABLED(CONFIG_IPV6)
1715     *gs6 = rtnl_dereference(geneve->sock6);
1716     rcu_assign_pointer(geneve->sock6, NULL);
1717     if (*gs6)
1718         rcu_assign_sk_user_data((*gs6)->sock->sk, NULL);
1719 #else
1720     *gs6 = NULL;
1721 #endif
1722     synchronize_net();
1723 }
1724 
1725 /* Resumes the geneve device data path for both TX and RX. */
1726 static void geneve_unquiesce(struct geneve_dev *geneve, struct geneve_sock *gs4,
1727                  struct geneve_sock __maybe_unused *gs6)
1728 {
1729     rcu_assign_pointer(geneve->sock4, gs4);
1730     if (gs4)
1731         rcu_assign_sk_user_data(gs4->sock->sk, gs4);
1732 #if IS_ENABLED(CONFIG_IPV6)
1733     rcu_assign_pointer(geneve->sock6, gs6);
1734     if (gs6)
1735         rcu_assign_sk_user_data(gs6->sock->sk, gs6);
1736 #endif
1737     synchronize_net();
1738 }
1739 
1740 static int geneve_changelink(struct net_device *dev, struct nlattr *tb[],
1741                  struct nlattr *data[],
1742                  struct netlink_ext_ack *extack)
1743 {
1744     struct geneve_dev *geneve = netdev_priv(dev);
1745     struct geneve_sock *gs4, *gs6;
1746     struct geneve_config cfg;
1747     int err;
1748 
1749     /* If the geneve device is configured for metadata (or externally
1750      * controlled, for example, OVS), then nothing can be changed.
1751      */
1752     if (geneve->cfg.collect_md)
1753         return -EOPNOTSUPP;
1754 
1755     /* Start with the existing info. */
1756     memcpy(&cfg, &geneve->cfg, sizeof(cfg));
1757     err = geneve_nl2info(tb, data, extack, &cfg, true);
1758     if (err)
1759         return err;
1760 
1761     if (!geneve_dst_addr_equal(&geneve->cfg.info, &cfg.info)) {
1762         dst_cache_reset(&cfg.info.dst_cache);
1763         geneve_link_config(dev, &cfg.info, tb);
1764     }
1765 
1766     geneve_quiesce(geneve, &gs4, &gs6);
1767     memcpy(&geneve->cfg, &cfg, sizeof(cfg));
1768     geneve_unquiesce(geneve, gs4, gs6);
1769 
1770     return 0;
1771 }
1772 
1773 static void geneve_dellink(struct net_device *dev, struct list_head *head)
1774 {
1775     struct geneve_dev *geneve = netdev_priv(dev);
1776 
1777     list_del(&geneve->next);
1778     unregister_netdevice_queue(dev, head);
1779 }
1780 
1781 static size_t geneve_get_size(const struct net_device *dev)
1782 {
1783     return nla_total_size(sizeof(__u32)) +  /* IFLA_GENEVE_ID */
1784         nla_total_size(sizeof(struct in6_addr)) + /* IFLA_GENEVE_REMOTE{6} */
1785         nla_total_size(sizeof(__u8)) +  /* IFLA_GENEVE_TTL */
1786         nla_total_size(sizeof(__u8)) +  /* IFLA_GENEVE_TOS */
1787         nla_total_size(sizeof(__u8)) +  /* IFLA_GENEVE_DF */
1788         nla_total_size(sizeof(__be32)) +  /* IFLA_GENEVE_LABEL */
1789         nla_total_size(sizeof(__be16)) +  /* IFLA_GENEVE_PORT */
1790         nla_total_size(0) +  /* IFLA_GENEVE_COLLECT_METADATA */
1791         nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_CSUM */
1792         nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_TX */
1793         nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_RX */
1794         nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_TTL_INHERIT */
1795         nla_total_size(0) +  /* IFLA_GENEVE_INNER_PROTO_INHERIT */
1796         0;
1797 }
1798 
1799 static int geneve_fill_info(struct sk_buff *skb, const struct net_device *dev)
1800 {
1801     struct geneve_dev *geneve = netdev_priv(dev);
1802     struct ip_tunnel_info *info = &geneve->cfg.info;
1803     bool ttl_inherit = geneve->cfg.ttl_inherit;
1804     bool metadata = geneve->cfg.collect_md;
1805     __u8 tmp_vni[3];
1806     __u32 vni;
1807 
1808     tunnel_id_to_vni(info->key.tun_id, tmp_vni);
1809     vni = (tmp_vni[0] << 16) | (tmp_vni[1] << 8) | tmp_vni[2];
1810     if (nla_put_u32(skb, IFLA_GENEVE_ID, vni))
1811         goto nla_put_failure;
1812 
1813     if (!metadata && ip_tunnel_info_af(info) == AF_INET) {
1814         if (nla_put_in_addr(skb, IFLA_GENEVE_REMOTE,
1815                     info->key.u.ipv4.dst))
1816             goto nla_put_failure;
1817         if (nla_put_u8(skb, IFLA_GENEVE_UDP_CSUM,
1818                    !!(info->key.tun_flags & TUNNEL_CSUM)))
1819             goto nla_put_failure;
1820 
1821 #if IS_ENABLED(CONFIG_IPV6)
1822     } else if (!metadata) {
1823         if (nla_put_in6_addr(skb, IFLA_GENEVE_REMOTE6,
1824                      &info->key.u.ipv6.dst))
1825             goto nla_put_failure;
1826         if (nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_TX,
1827                    !(info->key.tun_flags & TUNNEL_CSUM)))
1828             goto nla_put_failure;
1829 #endif
1830     }
1831 
1832     if (nla_put_u8(skb, IFLA_GENEVE_TTL, info->key.ttl) ||
1833         nla_put_u8(skb, IFLA_GENEVE_TOS, info->key.tos) ||
1834         nla_put_be32(skb, IFLA_GENEVE_LABEL, info->key.label))
1835         goto nla_put_failure;
1836 
1837     if (nla_put_u8(skb, IFLA_GENEVE_DF, geneve->cfg.df))
1838         goto nla_put_failure;
1839 
1840     if (nla_put_be16(skb, IFLA_GENEVE_PORT, info->key.tp_dst))
1841         goto nla_put_failure;
1842 
1843     if (metadata && nla_put_flag(skb, IFLA_GENEVE_COLLECT_METADATA))
1844         goto nla_put_failure;
1845 
1846 #if IS_ENABLED(CONFIG_IPV6)
1847     if (nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_RX,
1848                !geneve->cfg.use_udp6_rx_checksums))
1849         goto nla_put_failure;
1850 #endif
1851 
1852     if (nla_put_u8(skb, IFLA_GENEVE_TTL_INHERIT, ttl_inherit))
1853         goto nla_put_failure;
1854 
1855     if (geneve->cfg.inner_proto_inherit &&
1856         nla_put_flag(skb, IFLA_GENEVE_INNER_PROTO_INHERIT))
1857         goto nla_put_failure;
1858 
1859     return 0;
1860 
1861 nla_put_failure:
1862     return -EMSGSIZE;
1863 }
1864 
1865 static struct rtnl_link_ops geneve_link_ops __read_mostly = {
1866     .kind       = "geneve",
1867     .maxtype    = IFLA_GENEVE_MAX,
1868     .policy     = geneve_policy,
1869     .priv_size  = sizeof(struct geneve_dev),
1870     .setup      = geneve_setup,
1871     .validate   = geneve_validate,
1872     .newlink    = geneve_newlink,
1873     .changelink = geneve_changelink,
1874     .dellink    = geneve_dellink,
1875     .get_size   = geneve_get_size,
1876     .fill_info  = geneve_fill_info,
1877 };
1878 
1879 struct net_device *geneve_dev_create_fb(struct net *net, const char *name,
1880                     u8 name_assign_type, u16 dst_port)
1881 {
1882     struct nlattr *tb[IFLA_MAX + 1];
1883     struct net_device *dev;
1884     LIST_HEAD(list_kill);
1885     int err;
1886     struct geneve_config cfg = {
1887         .df = GENEVE_DF_UNSET,
1888         .use_udp6_rx_checksums = true,
1889         .ttl_inherit = false,
1890         .collect_md = true,
1891     };
1892 
1893     memset(tb, 0, sizeof(tb));
1894     dev = rtnl_create_link(net, name, name_assign_type,
1895                    &geneve_link_ops, tb, NULL);
1896     if (IS_ERR(dev))
1897         return dev;
1898 
1899     init_tnl_info(&cfg.info, dst_port);
1900     err = geneve_configure(net, dev, NULL, &cfg);
1901     if (err) {
1902         free_netdev(dev);
1903         return ERR_PTR(err);
1904     }
1905 
1906     /* openvswitch users expect packet sizes to be unrestricted,
1907      * so set the largest MTU we can.
1908      */
1909     err = geneve_change_mtu(dev, IP_MAX_MTU);
1910     if (err)
1911         goto err;
1912 
1913     err = rtnl_configure_link(dev, NULL);
1914     if (err < 0)
1915         goto err;
1916 
1917     return dev;
1918 err:
1919     geneve_dellink(dev, &list_kill);
1920     unregister_netdevice_many(&list_kill);
1921     return ERR_PTR(err);
1922 }
1923 EXPORT_SYMBOL_GPL(geneve_dev_create_fb);
1924 
1925 static int geneve_netdevice_event(struct notifier_block *unused,
1926                   unsigned long event, void *ptr)
1927 {
1928     struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1929 
1930     if (event == NETDEV_UDP_TUNNEL_PUSH_INFO)
1931         geneve_offload_rx_ports(dev, true);
1932     else if (event == NETDEV_UDP_TUNNEL_DROP_INFO)
1933         geneve_offload_rx_ports(dev, false);
1934 
1935     return NOTIFY_DONE;
1936 }
1937 
1938 static struct notifier_block geneve_notifier_block __read_mostly = {
1939     .notifier_call = geneve_netdevice_event,
1940 };
1941 
1942 static __net_init int geneve_init_net(struct net *net)
1943 {
1944     struct geneve_net *gn = net_generic(net, geneve_net_id);
1945 
1946     INIT_LIST_HEAD(&gn->geneve_list);
1947     INIT_LIST_HEAD(&gn->sock_list);
1948     return 0;
1949 }
1950 
1951 static void geneve_destroy_tunnels(struct net *net, struct list_head *head)
1952 {
1953     struct geneve_net *gn = net_generic(net, geneve_net_id);
1954     struct geneve_dev *geneve, *next;
1955     struct net_device *dev, *aux;
1956 
1957     /* gather any geneve devices that were moved into this ns */
1958     for_each_netdev_safe(net, dev, aux)
1959         if (dev->rtnl_link_ops == &geneve_link_ops)
1960             unregister_netdevice_queue(dev, head);
1961 
1962     /* now gather any other geneve devices that were created in this ns */
1963     list_for_each_entry_safe(geneve, next, &gn->geneve_list, next) {
1964         /* If geneve->dev is in the same netns, it was already added
1965          * to the list by the previous loop.
1966          */
1967         if (!net_eq(dev_net(geneve->dev), net))
1968             unregister_netdevice_queue(geneve->dev, head);
1969     }
1970 }
1971 
1972 static void __net_exit geneve_exit_batch_net(struct list_head *net_list)
1973 {
1974     struct net *net;
1975     LIST_HEAD(list);
1976 
1977     rtnl_lock();
1978     list_for_each_entry(net, net_list, exit_list)
1979         geneve_destroy_tunnels(net, &list);
1980 
1981     /* unregister the devices gathered above */
1982     unregister_netdevice_many(&list);
1983     rtnl_unlock();
1984 
1985     list_for_each_entry(net, net_list, exit_list) {
1986         const struct geneve_net *gn = net_generic(net, geneve_net_id);
1987 
1988         WARN_ON_ONCE(!list_empty(&gn->sock_list));
1989     }
1990 }
1991 
1992 static struct pernet_operations geneve_net_ops = {
1993     .init = geneve_init_net,
1994     .exit_batch = geneve_exit_batch_net,
1995     .id   = &geneve_net_id,
1996     .size = sizeof(struct geneve_net),
1997 };
1998 
1999 static int __init geneve_init_module(void)
2000 {
2001     int rc;
2002 
2003     rc = register_pernet_subsys(&geneve_net_ops);
2004     if (rc)
2005         goto out1;
2006 
2007     rc = register_netdevice_notifier(&geneve_notifier_block);
2008     if (rc)
2009         goto out2;
2010 
2011     rc = rtnl_link_register(&geneve_link_ops);
2012     if (rc)
2013         goto out3;
2014 
2015     return 0;
2016 out3:
2017     unregister_netdevice_notifier(&geneve_notifier_block);
2018 out2:
2019     unregister_pernet_subsys(&geneve_net_ops);
2020 out1:
2021     return rc;
2022 }
2023 late_initcall(geneve_init_module);
2024 
2025 static void __exit geneve_cleanup_module(void)
2026 {
2027     rtnl_link_unregister(&geneve_link_ops);
2028     unregister_netdevice_notifier(&geneve_notifier_block);
2029     unregister_pernet_subsys(&geneve_net_ops);
2030 }
2031 module_exit(geneve_cleanup_module);
2032 
2033 MODULE_LICENSE("GPL");
2034 MODULE_VERSION(GENEVE_NETDEV_VER);
2035 MODULE_AUTHOR("John W. Linville <linville@tuxdriver.com>");
2036 MODULE_DESCRIPTION("Interface driver for GENEVE encapsulated traffic");
2037 MODULE_ALIAS_RTNL_LINK("geneve");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!