netdev-dummy: Fix reconnecting.
[sliver-openvswitch.git] / datapath / vport-vxlan.c
1 /*
2  * Copyright (c) 2013 Nicira, Inc.
3  * Copyright (c) 2013 Cisco Systems, Inc.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of version 2 of the GNU General Public
7  * License as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA
18  */
19
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
22 #include <linux/version.h>
23
24 #include <linux/in.h>
25 #include <linux/ip.h>
26 #include <linux/net.h>
27 #include <linux/rculist.h>
28 #include <linux/udp.h>
29
30 #include <net/icmp.h>
31 #include <net/ip.h>
32 #include <net/udp.h>
33 #include <net/ip_tunnels.h>
34 #include <net/rtnetlink.h>
35 #include <net/route.h>
36 #include <net/dsfield.h>
37 #include <net/inet_ecn.h>
38 #include <net/net_namespace.h>
39 #include <net/netns/generic.h>
40 #include <net/vxlan.h>
41
42 #include "datapath.h"
43 #include "vport.h"
44
45 /**
46  * struct vxlan_port - Keeps track of open UDP ports
47  * @vs: vxlan_sock created for the port.
48  * @name: vport name.
49  */
50 struct vxlan_port {
51         struct vxlan_sock *vs;
52         char name[IFNAMSIZ];
53 };
54
55 static inline struct vxlan_port *vxlan_vport(const struct vport *vport)
56 {
57         return vport_priv(vport);
58 }
59
60 /* Called with rcu_read_lock and BH disabled. */
61 static void vxlan_rcv(struct vxlan_sock *vs, struct sk_buff *skb, __be32 vx_vni)
62 {
63         struct ovs_key_ipv4_tunnel tun_key;
64         struct vport *vport = vs->data;
65         struct iphdr *iph;
66         __be64 key;
67
68         /* Save outer tunnel values */
69         iph = ip_hdr(skb);
70         key = cpu_to_be64(ntohl(vx_vni) >> 8);
71         ovs_flow_tun_key_init(&tun_key, iph, key, TUNNEL_KEY);
72
73         ovs_vport_receive(vport, skb, &tun_key);
74 }
75
76 static int vxlan_get_options(const struct vport *vport, struct sk_buff *skb)
77 {
78         struct vxlan_port *vxlan_port = vxlan_vport(vport);
79         __be16 dst_port = inet_sport(vxlan_port->vs->sock->sk);
80
81         if (nla_put_u16(skb, OVS_TUNNEL_ATTR_DST_PORT, ntohs(dst_port)))
82                 return -EMSGSIZE;
83         return 0;
84 }
85
86 static void vxlan_tnl_destroy(struct vport *vport)
87 {
88         struct vxlan_port *vxlan_port = vxlan_vport(vport);
89
90         vxlan_sock_release(vxlan_port->vs);
91
92         ovs_vport_deferred_free(vport);
93 }
94
95 static struct vport *vxlan_tnl_create(const struct vport_parms *parms)
96 {
97         struct net *net = ovs_dp_get_net(parms->dp);
98         struct nlattr *options = parms->options;
99         struct vxlan_port *vxlan_port;
100         struct vxlan_sock *vs;
101         struct vport *vport;
102         struct nlattr *a;
103         u16 dst_port;
104         int err;
105
106         if (!options) {
107                 err = -EINVAL;
108                 goto error;
109         }
110         a = nla_find_nested(options, OVS_TUNNEL_ATTR_DST_PORT);
111         if (a && nla_len(a) == sizeof(u16)) {
112                 dst_port = nla_get_u16(a);
113         } else {
114                 /* Require destination port from userspace. */
115                 err = -EINVAL;
116                 goto error;
117         }
118
119         vport = ovs_vport_alloc(sizeof(struct vxlan_port),
120                                 &ovs_vxlan_vport_ops, parms);
121         if (IS_ERR(vport))
122                 return vport;
123
124         vxlan_port = vxlan_vport(vport);
125         strncpy(vxlan_port->name, parms->name, IFNAMSIZ);
126
127         vs = vxlan_sock_add(net, htons(dst_port), vxlan_rcv, vport, true);
128         if (IS_ERR(vs)) {
129                 ovs_vport_free(vport);
130                 return (void *)vs;
131         }
132         vxlan_port->vs = vs;
133
134         return vport;
135
136 error:
137         return ERR_PTR(err);
138 }
139
140 static int vxlan_tnl_send(struct vport *vport, struct sk_buff *skb)
141 {
142         struct vxlan_port *vxlan_port = vxlan_vport(vport);
143         __be16 dst_port = inet_sport(vxlan_port->vs->sock->sk);
144         struct rtable *rt;
145         __be16 src_port;
146         __be32 saddr;
147         __be16 df;
148         int port_min;
149         int port_max;
150         int err;
151
152         if (unlikely(!OVS_CB(skb)->tun_key)) {
153                 err = -EINVAL;
154                 goto error;
155         }
156
157         /* Route lookup */
158         saddr = OVS_CB(skb)->tun_key->ipv4_src;
159         rt = find_route(ovs_dp_get_net(vport->dp),
160                         &saddr,
161                         OVS_CB(skb)->tun_key->ipv4_dst,
162                         IPPROTO_UDP,
163                         OVS_CB(skb)->tun_key->ipv4_tos,
164                         skb->mark);
165         if (IS_ERR(rt)) {
166                 err = PTR_ERR(rt);
167                 goto error;
168         }
169
170         df = OVS_CB(skb)->tun_key->tun_flags & TUNNEL_DONT_FRAGMENT ?
171                 htons(IP_DF) : 0;
172
173         skb->local_df = 1;
174
175         inet_get_local_port_range(&port_min, &port_max);
176         src_port = vxlan_src_port(port_min, port_max, skb);
177
178         err = vxlan_xmit_skb(vxlan_port->vs, rt, skb,
179                              saddr, OVS_CB(skb)->tun_key->ipv4_dst,
180                              OVS_CB(skb)->tun_key->ipv4_tos,
181                              OVS_CB(skb)->tun_key->ipv4_ttl, df,
182                              src_port, dst_port,
183                              htonl(be64_to_cpu(OVS_CB(skb)->tun_key->tun_id) << 8));
184         if (err < 0)
185                 ip_rt_put(rt);
186 error:
187         return err;
188 }
189
190 static const char *vxlan_get_name(const struct vport *vport)
191 {
192         struct vxlan_port *vxlan_port = vxlan_vport(vport);
193         return vxlan_port->name;
194 }
195
196 const struct vport_ops ovs_vxlan_vport_ops = {
197         .type           = OVS_VPORT_TYPE_VXLAN,
198         .create         = vxlan_tnl_create,
199         .destroy        = vxlan_tnl_destroy,
200         .get_name       = vxlan_get_name,
201         .get_options    = vxlan_get_options,
202         .send           = vxlan_tnl_send,
203 };