datapath/linux/compat/vxlan.c

   1 /*
   2  * Copyright (c) 2007-2013 Nicira, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of version 2 of the GNU General Public
   6  * License as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  16  * 02110-1301, USA
  17  *
  18  * This code is derived from kernel vxlan module.
  19  */
  20
  21 #include <linux/version.h>
  22
  23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24
  25 #include <linux/kernel.h>
  26 #include <linux/types.h>
  27 #include <linux/module.h>
  28 #include <linux/errno.h>
  29 #include <linux/slab.h>
  30 #include <linux/skbuff.h>
  31 #include <linux/rculist.h>
  32 #include <linux/netdevice.h>
  33 #include <linux/in.h>
  34 #include <linux/ip.h>
  35 #include <linux/udp.h>
  36 #include <linux/igmp.h>
  37 #include <linux/etherdevice.h>
  38 #include <linux/if_ether.h>
  39 #include <linux/if_vlan.h>
  40 #include <linux/hash.h>
  41 #include <linux/ethtool.h>
  42 #include <net/arp.h>
  43 #include <net/ndisc.h>
  44 #include <net/ip.h>
  45 #include <net/gre.h>
  46 #include <net/ip_tunnels.h>
  47 #include <net/icmp.h>
  48 #include <net/udp.h>
  49 #include <net/rtnetlink.h>
  50 #include <net/route.h>
  51 #include <net/dsfield.h>
  52 #include <net/inet_ecn.h>
  53 #include <net/net_namespace.h>
  54 #include <net/netns/generic.h>
  55 #include <net/vxlan.h>
  56
  57 #include "compat.h"
  58 #include "datapath.h"
  59 #include "gso.h"
  60 #include "vlan.h"
  61 #ifndef USE_KERNEL_TUNNEL_API
  62
  63 #define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))
  64
  65 #define VXLAN_FLAGS 0x08000000  /* struct vxlanhdr.vx_flags required value. */
  66
  67 /* VXLAN protocol header */
  68 struct vxlanhdr {
  69         __be32 vx_flags;
  70         __be32 vx_vni;
  71 };
  72
  73 /* Callback from net/ipv4/udp.c to receive packets */
  74 static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
  75 {
  76         struct vxlan_sock *vs;
  77         struct vxlanhdr *vxh;
  78
  79         /* Need Vxlan and inner Ethernet header to be present */
  80         if (!pskb_may_pull(skb, VXLAN_HLEN))
  81                 goto error;
  82
  83         /* Return packets with reserved bits set */
  84         vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);
  85         if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||
  86             (vxh->vx_vni & htonl(0xff))) {
  87                 pr_warn("invalid vxlan flags=%#x vni=%#x\n",
  88                         ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));
  89                 goto error;
  90         }
  91
  92         if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))
  93                 goto drop;
  94
  95         vs = rcu_dereference_sk_user_data(sk);
  96         if (!vs)
  97                 goto drop;
  98
  99         vs->rcv(vs, skb, vxh->vx_vni);
 100         return 0;
 101
 102 drop:
 103         /* Consume bad packet */
 104         kfree_skb(skb);
 105         return 0;
 106
 107 error:
 108         /* Return non vxlan pkt */
 109         return 1;
 110 }
 111
 112 static void vxlan_sock_put(struct sk_buff *skb)
 113 {
 114         sock_put(skb->sk);
 115 }
 116
 117 /* On transmit, associate with the tunnel socket */
 118 static void vxlan_set_owner(struct sock *sk, struct sk_buff *skb)
 119 {
 120         skb_orphan(skb);
 121         sock_hold(sk);
 122         skb->sk = sk;
 123         skb->destructor = vxlan_sock_put;
 124 }
 125
 126 /* Compute source port for outgoing packet
 127  *   first choice to use L4 flow hash since it will spread
 128  *     better and maybe available from hardware
 129  *   secondary choice is to use jhash on the Ethernet header
 130  */
 131 __be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)
 132 {
 133         unsigned int range = (port_max - port_min) + 1;
 134         u32 hash;
 135
 136         hash = skb_get_hash(skb);
 137         if (!hash)
 138                 hash = jhash(skb->data, 2 * ETH_ALEN,
 139                              (__force u32) skb->protocol);
 140
 141         return htons((((u64) hash * range) >> 32) + port_min);
 142 }
 143
 144 static void vxlan_gso(struct sk_buff *skb)
 145 {
 146         int udp_offset = skb_transport_offset(skb);
 147         struct udphdr *uh;
 148
 149         uh = udp_hdr(skb);
 150         uh->len = htons(skb->len - udp_offset);
 151
 152         /* csum segment if tunnel sets skb with csum. */
 153         if (unlikely(uh->check)) {
 154                 struct iphdr *iph = ip_hdr(skb);
 155
 156                 uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
 157                                                skb->len - udp_offset,
 158                                                IPPROTO_UDP, 0);
 159                 uh->check = csum_fold(skb_checksum(skb, udp_offset,
 160                                       skb->len - udp_offset, 0));
 161
 162                 if (uh->check == 0)
 163                         uh->check = CSUM_MANGLED_0;
 164
 165         }
 166         skb->ip_summed = CHECKSUM_NONE;
 167 }
 168
 169 static int handle_offloads(struct sk_buff *skb)
 170 {
 171         if (skb_is_gso(skb)) {
 172                 if (skb_is_encapsulated(skb))
 173                         return -ENOSYS;
 174
 175                 OVS_GSO_CB(skb)->fix_segment = vxlan_gso;
 176         } else {
 177                 if (skb->ip_summed != CHECKSUM_PARTIAL)
 178                         skb->ip_summed = CHECKSUM_NONE;
 179         }
 180         return 0;
 181 }
 182
 183 int vxlan_xmit_skb(struct vxlan_sock *vs,
 184                    struct rtable *rt, struct sk_buff *skb,
 185                    __be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,
 186                    __be16 src_port, __be16 dst_port, __be32 vni)
 187 {
 188         struct vxlanhdr *vxh;
 189         struct udphdr *uh;
 190         int min_headroom;
 191         int err;
 192
 193         min_headroom = LL_RESERVED_SPACE(rt_dst(rt).dev) + rt_dst(rt).header_len
 194                         + VXLAN_HLEN + sizeof(struct iphdr)
 195                         + (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
 196
 197         /* Need space for new headers (invalidates iph ptr) */
 198         err = skb_cow_head(skb, min_headroom);
 199         if (unlikely(err))
 200                 return err;
 201
 202         if (vlan_tx_tag_present(skb)) {
 203                 if (unlikely(!__vlan_put_tag(skb,
 204                                                 skb->vlan_proto,
 205                                                 vlan_tx_tag_get(skb))))
 206                         return -ENOMEM;
 207
 208                 vlan_set_tci(skb, 0);
 209         }
 210
 211         skb_reset_inner_headers(skb);
 212
 213         vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
 214         vxh->vx_flags = htonl(VXLAN_FLAGS);
 215         vxh->vx_vni = vni;
 216
 217         __skb_push(skb, sizeof(*uh));
 218         skb_reset_transport_header(skb);
 219         uh = udp_hdr(skb);
 220
 221         uh->dest = dst_port;
 222         uh->source = src_port;
 223
 224         uh->len = htons(skb->len);
 225         uh->check = 0;
 226
 227         vxlan_set_owner(vs->sock->sk, skb);
 228
 229         err = handle_offloads(skb);
 230         if (err)
 231                 return err;
 232
 233         return iptunnel_xmit(vs->sock->sk, rt, skb, src, dst, IPPROTO_UDP,
 234                              tos, ttl, df, false);
 235 }
 236
 237 static void rcu_free_vs(struct rcu_head *rcu)
 238 {
 239         struct vxlan_sock *vs = container_of(rcu, struct vxlan_sock, rcu);
 240
 241         kfree(vs);
 242 }
 243
 244 static void vxlan_del_work(struct work_struct *work)
 245 {
 246         struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);
 247
 248         sk_release_kernel(vs->sock->sk);
 249         call_rcu(&vs->rcu, rcu_free_vs);
 250 }
 251
 252 static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,
 253                                               vxlan_rcv_t *rcv, void *data)
 254 {
 255         struct vxlan_sock *vs;
 256         struct sock *sk;
 257         struct sockaddr_in vxlan_addr = {
 258                 .sin_family = AF_INET,
 259                 .sin_addr.s_addr = htonl(INADDR_ANY),
 260                 .sin_port = port,
 261         };
 262         int rc;
 263
 264         vs = kmalloc(sizeof(*vs), GFP_KERNEL);
 265         if (!vs) {
 266                 pr_debug("memory alocation failure\n");
 267                 return ERR_PTR(-ENOMEM);
 268         }
 269
 270         INIT_WORK(&vs->del_work, vxlan_del_work);
 271
 272         /* Create UDP socket for encapsulation receive. */
 273         rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &vs->sock);
 274         if (rc < 0) {
 275                 pr_debug("UDP socket create failed\n");
 276                 kfree(vs);
 277                 return ERR_PTR(rc);
 278         }
 279
 280         /* Put in proper namespace */
 281         sk = vs->sock->sk;
 282         sk_change_net(sk, net);
 283
 284         rc = kernel_bind(vs->sock, (struct sockaddr *) &vxlan_addr,
 285                         sizeof(vxlan_addr));
 286         if (rc < 0) {
 287                 pr_debug("bind for UDP socket %pI4:%u (%d)\n",
 288                                 &vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
 289                 sk_release_kernel(sk);
 290                 kfree(vs);
 291                 return ERR_PTR(rc);
 292         }
 293         vs->rcv = rcv;
 294         vs->data = data;
 295
 296         /* Disable multicast loopback */
 297         inet_sk(sk)->mc_loop = 0;
 298         rcu_assign_sk_user_data(vs->sock->sk, vs);
 299
 300         /* Mark socket as an encapsulation socket. */
 301         udp_sk(sk)->encap_type = 1;
 302         udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
 303         udp_encap_enable();
 304         return vs;
 305 }
 306
 307 struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
 308                                   vxlan_rcv_t *rcv, void *data,
 309                                   bool no_share, bool ipv6)
 310 {
 311         return vxlan_socket_create(net, port, rcv, data);
 312 }
 313
 314 void vxlan_sock_release(struct vxlan_sock *vs)
 315 {
 316         ASSERT_OVSL();
 317         rcu_assign_sk_user_data(vs->sock->sk, NULL);
 318
 319         queue_work(system_wq, &vs->del_work);
 320 }
 321
 322 #endif /* 3.12 */