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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  22
  23 #include <linux/kernel.h>
  24 #include <linux/types.h>
  25 #include <linux/module.h>
  26 #include <linux/errno.h>
  27 #include <linux/slab.h>
  28 #include <linux/skbuff.h>
  29 #include <linux/rculist.h>
  30 #include <linux/netdevice.h>
  31 #include <linux/in.h>
  32 #include <linux/ip.h>
  33 #include <linux/udp.h>
  34 #include <linux/igmp.h>
  35 #include <linux/etherdevice.h>
  36 #include <linux/if_ether.h>
  37 #include <linux/if_vlan.h>
  38 #include <linux/hash.h>
  39 #include <linux/ethtool.h>
  40 #include <net/arp.h>
  41 #include <net/ndisc.h>
  42 #include <net/ip.h>
  43 #include <net/ip_tunnels.h>
  44 #include <net/icmp.h>
  45 #include <net/udp.h>
  46 #include <net/rtnetlink.h>
  47 #include <net/route.h>
  48 #include <net/dsfield.h>
  49 #include <net/inet_ecn.h>
  50 #include <net/net_namespace.h>
  51 #include <net/netns/generic.h>
  52 #include <net/vxlan.h>
  53
  54 #include "checksum.h"
  55 #include "compat.h"
  56 #include "gso.h"
  57 #include "vlan.h"
  58
  59 #define PORT_HASH_BITS  8
  60 #define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
  61
  62 #define VXLAN_N_VID     (1u << 24)
  63 #define VXLAN_VID_MASK  (VXLAN_N_VID - 1)
  64 /* IP header + UDP + VXLAN + Ethernet header */
  65 #define VXLAN_HEADROOM (20 + 8 + 8 + 14)
  66 #define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))
  67
  68 #define VXLAN_FLAGS 0x08000000  /* struct vxlanhdr.vx_flags required value. */
  69
  70 /* VXLAN protocol header */
  71 struct vxlanhdr {
  72         __be32 vx_flags;
  73         __be32 vx_vni;
  74 };
  75
  76 static int vxlan_net_id;
  77
  78 /* per-network namespace private data for this module */
  79 struct vxlan_net {
  80         struct hlist_head sock_list[PORT_HASH_SIZE];
  81         struct mutex      sock_lock;    /* RTNL lock nests inside this lock. */
  82 };
  83
  84 /* Socket hash table head */
  85 static inline struct hlist_head *vs_head(struct net *net, __be16 port)
  86 {
  87         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
  88
  89         return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
  90 }
  91
  92 /* Find VXLAN socket based on network namespace and UDP port */
  93 static struct vxlan_sock *vxlan_find_port(struct net *net, __be16 port)
  94 {
  95         struct vxlan_sock *vs;
  96
  97         hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
  98                 if (inet_sport(vs->sock->sk) == port)
  99                         return vs;
 100         }
 101         return NULL;
 102 }
 103
 104 /* Callback from net/ipv4/udp.c to receive packets */
 105 static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
 106 {
 107         struct vxlan_handler *vh;
 108         struct vxlan_sock *vs;
 109         struct vxlanhdr *vxh;
 110
 111         /* Need Vxlan and inner Ethernet header to be present */
 112         if (!pskb_may_pull(skb, VXLAN_HLEN))
 113                 goto error;
 114
 115         /* Return packets with reserved bits set */
 116         vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);
 117         if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||
 118             (vxh->vx_vni & htonl(0xff))) {
 119                 pr_warn("invalid vxlan flags=%#x vni=%#x\n",
 120                         ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));
 121                 goto error;
 122         }
 123
 124         if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))
 125                 goto drop;
 126
 127         vs = vxlan_find_port(sock_net(sk), inet_sport(sk));
 128         if (!vs)
 129                 goto drop;
 130
 131         list_for_each_entry_rcu(vh, &vs->handler_list, node) {
 132                 if (vh->rcv(vh, skb, vxh->vx_vni) == PACKET_RCVD)
 133                         return 0;
 134         }
 135
 136 drop:
 137         /* Consume bad packet */
 138         kfree_skb(skb);
 139         return 0;
 140
 141 error:
 142         /* Return non vxlan pkt */
 143         return 1;
 144 }
 145
 146 static void vxlan_sock_put(struct sk_buff *skb)
 147 {
 148         sock_put(skb->sk);
 149 }
 150
 151 /* On transmit, associate with the tunnel socket */
 152 static void vxlan_set_owner(struct sock *sk, struct sk_buff *skb)
 153 {
 154         skb_orphan(skb);
 155         sock_hold(sk);
 156         skb->sk = sk;
 157         skb->destructor = vxlan_sock_put;
 158 }
 159
 160 /* Compute source port for outgoing packet
 161  *   first choice to use L4 flow hash since it will spread
 162  *     better and maybe available from hardware
 163  *   secondary choice is to use jhash on the Ethernet header
 164  */
 165 __be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)
 166 {
 167         unsigned int range = (port_max - port_min) + 1;
 168         u32 hash;
 169
 170         hash = skb_get_rxhash(skb);
 171         if (!hash)
 172                 hash = jhash(skb->data, 2 * ETH_ALEN,
 173                              (__force u32) skb->protocol);
 174
 175         return htons((((u64) hash * range) >> 32) + port_min);
 176 }
 177
 178 static void vxlan_gso(struct sk_buff *skb)
 179 {
 180         int udp_offset = skb_transport_offset(skb);
 181         struct udphdr *uh;
 182
 183         uh = udp_hdr(skb);
 184         uh->len = htons(skb->len - udp_offset);
 185
 186         /* csum segment if tunnel sets skb with csum. */
 187         if (unlikely(uh->check)) {
 188                 struct iphdr *iph = ip_hdr(skb);
 189
 190                 uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
 191                                                skb->len - udp_offset,
 192                                                IPPROTO_UDP, 0);
 193                 uh->check = csum_fold(skb_checksum(skb, udp_offset,
 194                                       skb->len - udp_offset, 0));
 195
 196                 if (uh->check == 0)
 197                         uh->check = CSUM_MANGLED_0;
 198
 199         }
 200         skb->ip_summed = CHECKSUM_NONE;
 201 }
 202
 203 static int handle_offloads(struct sk_buff *skb)
 204 {
 205         if (skb_is_gso(skb)) {
 206                 OVS_GSO_CB(skb)->fix_segment = vxlan_gso;
 207         } else {
 208                 if (skb->ip_summed != CHECKSUM_PARTIAL)
 209                         skb->ip_summed = CHECKSUM_NONE;
 210         }
 211         return 0;
 212 }
 213
 214 int vxlan_xmit_skb(struct net *net, struct vxlan_handler *vh,
 215                    struct rtable *rt, struct sk_buff *skb,
 216                    __be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,
 217                    __be16 src_port, __be16 dst_port, __be32 vni)
 218 {
 219         struct vxlanhdr *vxh;
 220         struct udphdr *uh;
 221         int min_headroom;
 222         int err;
 223
 224         skb_reset_inner_headers(skb);
 225
 226         min_headroom = LL_RESERVED_SPACE(rt_dst(rt).dev) + rt_dst(rt).header_len
 227                         + VXLAN_HLEN + sizeof(struct iphdr)
 228                         + (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
 229
 230         /* Need space for new headers (invalidates iph ptr) */
 231         err = skb_cow_head(skb, min_headroom);
 232         if (unlikely(err))
 233                 return err;
 234
 235         if (unlikely(vlan_deaccel_tag(skb)))
 236                 return -ENOMEM;
 237
 238         vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
 239         vxh->vx_flags = htonl(VXLAN_FLAGS);
 240         vxh->vx_vni = vni;
 241
 242         __skb_push(skb, sizeof(*uh));
 243         skb_reset_transport_header(skb);
 244         uh = udp_hdr(skb);
 245
 246         uh->dest = dst_port;
 247         uh->source = src_port;
 248
 249         uh->len = htons(skb->len);
 250         uh->check = 0;
 251
 252         vxlan_set_owner(vh->vs->sock->sk, skb);
 253
 254         err = handle_offloads(skb);
 255         if (err)
 256                 return err;
 257
 258         return iptunnel_xmit(net, rt, skb, src, dst,
 259                         IPPROTO_UDP, tos, ttl, df);
 260 }
 261
 262 static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port)
 263 {
 264         struct vxlan_sock *vs;
 265         struct sock *sk;
 266         struct sockaddr_in vxlan_addr = {
 267                 .sin_family = AF_INET,
 268                 .sin_addr.s_addr = htonl(INADDR_ANY),
 269                 .sin_port = port,
 270         };
 271         int rc;
 272
 273         vs = kmalloc(sizeof(*vs), GFP_KERNEL);
 274         if (!vs)
 275                 return ERR_PTR(-ENOMEM);
 276
 277         /* Create UDP socket for encapsulation receive. */
 278         rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &vs->sock);
 279         if (rc < 0) {
 280                 pr_debug("UDP socket create failed\n");
 281                 kfree(vs);
 282                 return ERR_PTR(rc);
 283         }
 284
 285         /* Put in proper namespace */
 286         sk = vs->sock->sk;
 287         sk_change_net(sk, net);
 288
 289         rc = kernel_bind(vs->sock, (struct sockaddr *) &vxlan_addr,
 290                          sizeof(vxlan_addr));
 291         if (rc < 0) {
 292                 pr_debug("bind for UDP socket %pI4:%u (%d)\n",
 293                          &vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
 294                 sk_release_kernel(sk);
 295                 kfree(vs);
 296                 return ERR_PTR(rc);
 297         }
 298
 299         /* Disable multicast loopback */
 300         inet_sk(sk)->mc_loop = 0;
 301         INIT_LIST_HEAD(&vs->handler_list);
 302         hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
 303
 304         /* Mark socket as an encapsulation socket. */
 305         udp_sk(sk)->encap_type = 1;
 306         udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
 307         udp_encap_enable();
 308
 309         return vs;
 310 }
 311
 312 static void rcu_free_vs_callback(struct rcu_head *rcu)
 313 {
 314         struct vxlan_sock *vs = container_of(rcu, struct vxlan_sock, rcu);
 315
 316         kfree(vs);
 317 }
 318
 319 static void vxlan_socket_del(struct vxlan_sock *vs)
 320 {
 321         if (list_empty(&vs->handler_list)) {
 322                 hlist_del_rcu(&vs->hlist);
 323
 324                 sk_release_kernel(vs->sock->sk);
 325                 call_rcu(&vs->rcu, rcu_free_vs_callback);
 326         }
 327 }
 328
 329 static int vxlan_init_module(void);
 330 static void vxlan_cleanup_module(void);
 331
 332 static void rcu_free_vh_callback(struct rcu_head *rcu)
 333 {
 334         struct vxlan_handler *vh = container_of(rcu, struct vxlan_handler, rcu);
 335
 336         kfree(vh);
 337 }
 338
 339 static void vh_del_work(struct work_struct *work)
 340 {
 341         struct vxlan_handler *vh = container_of(work, struct vxlan_handler, del_work);
 342         struct vxlan_sock *vs = vh->vs;
 343         struct net *net = sock_net(vs->sock->sk);
 344         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 345
 346         mutex_lock(&vn->sock_lock);
 347
 348         list_del_rcu(&vh->node);
 349         call_rcu(&vh->rcu, rcu_free_vh_callback);
 350         vxlan_socket_del(vs);
 351
 352         mutex_unlock(&vn->sock_lock);
 353
 354         vxlan_cleanup_module();
 355 }
 356
 357 struct vxlan_handler *vxlan_handler_add(struct net *net,
 358                                         __be16 portno, vxlan_rcv_t *rcv,
 359                                         void *data, int priority, bool create)
 360 {
 361         struct vxlan_net *vn;
 362         struct vxlan_sock *vs;
 363         struct vxlan_handler *vh;
 364         struct vxlan_handler *new;
 365         int err;
 366
 367         err = vxlan_init_module();
 368         if (err)
 369                 return ERR_PTR(err);
 370
 371         vn = net_generic(net, vxlan_net_id);
 372         mutex_lock(&vn->sock_lock);
 373         /* Look to see if can reuse socket */
 374         vs = vxlan_find_port(net, portno);
 375         if (!vs) {
 376                 vs = vxlan_socket_create(net, portno);
 377                 if (IS_ERR(vs)) {
 378                         new = (void *) vs;
 379                         goto out;
 380                 }
 381         }
 382
 383         /* Try existing vxlan hanlders for this socket. */
 384         list_for_each_entry(vh, &vs->handler_list, node) {
 385                 if (vh->rcv == rcv) {
 386                         if (create) {
 387                                 vxlan_socket_del(vs);
 388                                 new = ERR_PTR(-EEXIST);
 389                                 goto out;
 390                         }
 391                         atomic_inc(&vh->refcnt);
 392                         new = vh;
 393                         goto out;
 394                 }
 395         }
 396
 397         new = kzalloc(sizeof(*new), GFP_KERNEL);
 398         if (!new) {
 399                 vxlan_socket_del(vs);
 400                 new = ERR_PTR(-ENOMEM);
 401                 goto out;
 402         }
 403
 404         new->rcv = rcv;
 405         new->vs = vs;
 406         atomic_set(&new->refcnt, 1);
 407         INIT_WORK(&new->del_work, vh_del_work);
 408         new->data = data;
 409         new->priority = priority;
 410
 411         list_for_each_entry(vh, &vs->handler_list, node) {
 412                 if (vh->priority > priority) {
 413                         list_add_tail_rcu(&new->node, &vh->node);
 414                         goto out;
 415                 }
 416         }
 417
 418         list_add_tail_rcu(&new->node, &vs->handler_list);
 419 out:
 420         mutex_unlock(&vn->sock_lock);
 421         return new;
 422 }
 423
 424 void vxlan_handler_put(struct vxlan_handler *vh)
 425 {
 426         BUG_ON(!vh->vs);
 427
 428         if (atomic_dec_and_test(&vh->refcnt))
 429                 queue_work(&vh->del_work);
 430 }
 431
 432 static int vxlan_init_net(struct net *net)
 433 {
 434         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 435         unsigned int h;
 436
 437         mutex_init(&vn->sock_lock);
 438
 439         for (h = 0; h < PORT_HASH_SIZE; ++h)
 440                 INIT_HLIST_HEAD(&vn->sock_list[h]);
 441
 442         return 0;
 443 }
 444
 445 static struct pernet_operations vxlan_net_ops = {
 446         .init = vxlan_init_net,
 447         .id   = &vxlan_net_id,
 448         .size = sizeof(struct vxlan_net),
 449 };
 450
 451 static int refcnt;
 452 static DEFINE_MUTEX(init_lock);
 453 DEFINE_COMPAT_PNET_REG_FUNC(device);
 454
 455 static int vxlan_init_module(void)
 456 {
 457         int err = 0;
 458
 459         mutex_lock(&init_lock);
 460         if (refcnt)
 461                 goto out;
 462         err = register_pernet_device(&vxlan_net_ops);
 463 out:
 464         if (!err)
 465                 refcnt++;
 466         mutex_unlock(&init_lock);
 467         return err;
 468 }
 469
 470 static void vxlan_cleanup_module(void)
 471 {
 472         mutex_lock(&init_lock);
 473         refcnt--;
 474         if (refcnt)
 475                 goto out;
 476         unregister_pernet_device(&vxlan_net_ops);
 477 out:
 478         mutex_unlock(&init_lock);
 479 }