xref: /openbmc/linux/net/openvswitch/vport.c (revision 151f4e2b)
1 /*
2  * Copyright (c) 2007-2014 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 
19 #include <linux/etherdevice.h>
20 #include <linux/if.h>
21 #include <linux/if_vlan.h>
22 #include <linux/jhash.h>
23 #include <linux/kernel.h>
24 #include <linux/list.h>
25 #include <linux/mutex.h>
26 #include <linux/percpu.h>
27 #include <linux/rcupdate.h>
28 #include <linux/rtnetlink.h>
29 #include <linux/compat.h>
30 #include <net/net_namespace.h>
31 #include <linux/module.h>
32 
33 #include "datapath.h"
34 #include "vport.h"
35 #include "vport-internal_dev.h"
36 
37 static LIST_HEAD(vport_ops_list);
38 
39 /* Protected by RCU read lock for reading, ovs_mutex for writing. */
40 static struct hlist_head *dev_table;
41 #define VPORT_HASH_BUCKETS 1024
42 
43 /**
44  *	ovs_vport_init - initialize vport subsystem
45  *
46  * Called at module load time to initialize the vport subsystem.
47  */
48 int ovs_vport_init(void)
49 {
50 	dev_table = kcalloc(VPORT_HASH_BUCKETS, sizeof(struct hlist_head),
51 			    GFP_KERNEL);
52 	if (!dev_table)
53 		return -ENOMEM;
54 
55 	return 0;
56 }
57 
58 /**
59  *	ovs_vport_exit - shutdown vport subsystem
60  *
61  * Called at module exit time to shutdown the vport subsystem.
62  */
63 void ovs_vport_exit(void)
64 {
65 	kfree(dev_table);
66 }
67 
68 static struct hlist_head *hash_bucket(const struct net *net, const char *name)
69 {
70 	unsigned int hash = jhash(name, strlen(name), (unsigned long) net);
71 	return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
72 }
73 
74 int __ovs_vport_ops_register(struct vport_ops *ops)
75 {
76 	int err = -EEXIST;
77 	struct vport_ops *o;
78 
79 	ovs_lock();
80 	list_for_each_entry(o, &vport_ops_list, list)
81 		if (ops->type == o->type)
82 			goto errout;
83 
84 	list_add_tail(&ops->list, &vport_ops_list);
85 	err = 0;
86 errout:
87 	ovs_unlock();
88 	return err;
89 }
90 EXPORT_SYMBOL_GPL(__ovs_vport_ops_register);
91 
92 void ovs_vport_ops_unregister(struct vport_ops *ops)
93 {
94 	ovs_lock();
95 	list_del(&ops->list);
96 	ovs_unlock();
97 }
98 EXPORT_SYMBOL_GPL(ovs_vport_ops_unregister);
99 
100 /**
101  *	ovs_vport_locate - find a port that has already been created
102  *
103  * @name: name of port to find
104  *
105  * Must be called with ovs or RCU read lock.
106  */
107 struct vport *ovs_vport_locate(const struct net *net, const char *name)
108 {
109 	struct hlist_head *bucket = hash_bucket(net, name);
110 	struct vport *vport;
111 
112 	hlist_for_each_entry_rcu(vport, bucket, hash_node)
113 		if (!strcmp(name, ovs_vport_name(vport)) &&
114 		    net_eq(ovs_dp_get_net(vport->dp), net))
115 			return vport;
116 
117 	return NULL;
118 }
119 
120 /**
121  *	ovs_vport_alloc - allocate and initialize new vport
122  *
123  * @priv_size: Size of private data area to allocate.
124  * @ops: vport device ops
125  *
126  * Allocate and initialize a new vport defined by @ops.  The vport will contain
127  * a private data area of size @priv_size that can be accessed using
128  * vport_priv().  vports that are no longer needed should be released with
129  * vport_free().
130  */
131 struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
132 			  const struct vport_parms *parms)
133 {
134 	struct vport *vport;
135 	size_t alloc_size;
136 
137 	alloc_size = sizeof(struct vport);
138 	if (priv_size) {
139 		alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
140 		alloc_size += priv_size;
141 	}
142 
143 	vport = kzalloc(alloc_size, GFP_KERNEL);
144 	if (!vport)
145 		return ERR_PTR(-ENOMEM);
146 
147 	vport->dp = parms->dp;
148 	vport->port_no = parms->port_no;
149 	vport->ops = ops;
150 	INIT_HLIST_NODE(&vport->dp_hash_node);
151 
152 	if (ovs_vport_set_upcall_portids(vport, parms->upcall_portids)) {
153 		kfree(vport);
154 		return ERR_PTR(-EINVAL);
155 	}
156 
157 	return vport;
158 }
159 EXPORT_SYMBOL_GPL(ovs_vport_alloc);
160 
161 /**
162  *	ovs_vport_free - uninitialize and free vport
163  *
164  * @vport: vport to free
165  *
166  * Frees a vport allocated with vport_alloc() when it is no longer needed.
167  *
168  * The caller must ensure that an RCU grace period has passed since the last
169  * time @vport was in a datapath.
170  */
171 void ovs_vport_free(struct vport *vport)
172 {
173 	/* vport is freed from RCU callback or error path, Therefore
174 	 * it is safe to use raw dereference.
175 	 */
176 	kfree(rcu_dereference_raw(vport->upcall_portids));
177 	kfree(vport);
178 }
179 EXPORT_SYMBOL_GPL(ovs_vport_free);
180 
181 static struct vport_ops *ovs_vport_lookup(const struct vport_parms *parms)
182 {
183 	struct vport_ops *ops;
184 
185 	list_for_each_entry(ops, &vport_ops_list, list)
186 		if (ops->type == parms->type)
187 			return ops;
188 
189 	return NULL;
190 }
191 
192 /**
193  *	ovs_vport_add - add vport device (for kernel callers)
194  *
195  * @parms: Information about new vport.
196  *
197  * Creates a new vport with the specified configuration (which is dependent on
198  * device type).  ovs_mutex must be held.
199  */
200 struct vport *ovs_vport_add(const struct vport_parms *parms)
201 {
202 	struct vport_ops *ops;
203 	struct vport *vport;
204 
205 	ops = ovs_vport_lookup(parms);
206 	if (ops) {
207 		struct hlist_head *bucket;
208 
209 		if (!try_module_get(ops->owner))
210 			return ERR_PTR(-EAFNOSUPPORT);
211 
212 		vport = ops->create(parms);
213 		if (IS_ERR(vport)) {
214 			module_put(ops->owner);
215 			return vport;
216 		}
217 
218 		bucket = hash_bucket(ovs_dp_get_net(vport->dp),
219 				     ovs_vport_name(vport));
220 		hlist_add_head_rcu(&vport->hash_node, bucket);
221 		return vport;
222 	}
223 
224 	/* Unlock to attempt module load and return -EAGAIN if load
225 	 * was successful as we need to restart the port addition
226 	 * workflow.
227 	 */
228 	ovs_unlock();
229 	request_module("vport-type-%d", parms->type);
230 	ovs_lock();
231 
232 	if (!ovs_vport_lookup(parms))
233 		return ERR_PTR(-EAFNOSUPPORT);
234 	else
235 		return ERR_PTR(-EAGAIN);
236 }
237 
238 /**
239  *	ovs_vport_set_options - modify existing vport device (for kernel callers)
240  *
241  * @vport: vport to modify.
242  * @options: New configuration.
243  *
244  * Modifies an existing device with the specified configuration (which is
245  * dependent on device type).  ovs_mutex must be held.
246  */
247 int ovs_vport_set_options(struct vport *vport, struct nlattr *options)
248 {
249 	if (!vport->ops->set_options)
250 		return -EOPNOTSUPP;
251 	return vport->ops->set_options(vport, options);
252 }
253 
254 /**
255  *	ovs_vport_del - delete existing vport device
256  *
257  * @vport: vport to delete.
258  *
259  * Detaches @vport from its datapath and destroys it.  ovs_mutex must
260  * be held.
261  */
262 void ovs_vport_del(struct vport *vport)
263 {
264 	ASSERT_OVSL();
265 
266 	hlist_del_rcu(&vport->hash_node);
267 	module_put(vport->ops->owner);
268 	vport->ops->destroy(vport);
269 }
270 
271 /**
272  *	ovs_vport_get_stats - retrieve device stats
273  *
274  * @vport: vport from which to retrieve the stats
275  * @stats: location to store stats
276  *
277  * Retrieves transmit, receive, and error stats for the given device.
278  *
279  * Must be called with ovs_mutex or rcu_read_lock.
280  */
281 void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats)
282 {
283 	const struct rtnl_link_stats64 *dev_stats;
284 	struct rtnl_link_stats64 temp;
285 
286 	dev_stats = dev_get_stats(vport->dev, &temp);
287 	stats->rx_errors  = dev_stats->rx_errors;
288 	stats->tx_errors  = dev_stats->tx_errors;
289 	stats->tx_dropped = dev_stats->tx_dropped;
290 	stats->rx_dropped = dev_stats->rx_dropped;
291 
292 	stats->rx_bytes	  = dev_stats->rx_bytes;
293 	stats->rx_packets = dev_stats->rx_packets;
294 	stats->tx_bytes	  = dev_stats->tx_bytes;
295 	stats->tx_packets = dev_stats->tx_packets;
296 }
297 
298 /**
299  *	ovs_vport_get_options - retrieve device options
300  *
301  * @vport: vport from which to retrieve the options.
302  * @skb: sk_buff where options should be appended.
303  *
304  * Retrieves the configuration of the given device, appending an
305  * %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested
306  * vport-specific attributes to @skb.
307  *
308  * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another
309  * negative error code if a real error occurred.  If an error occurs, @skb is
310  * left unmodified.
311  *
312  * Must be called with ovs_mutex or rcu_read_lock.
313  */
314 int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb)
315 {
316 	struct nlattr *nla;
317 	int err;
318 
319 	if (!vport->ops->get_options)
320 		return 0;
321 
322 	nla = nla_nest_start_noflag(skb, OVS_VPORT_ATTR_OPTIONS);
323 	if (!nla)
324 		return -EMSGSIZE;
325 
326 	err = vport->ops->get_options(vport, skb);
327 	if (err) {
328 		nla_nest_cancel(skb, nla);
329 		return err;
330 	}
331 
332 	nla_nest_end(skb, nla);
333 	return 0;
334 }
335 
336 /**
337  *	ovs_vport_set_upcall_portids - set upcall portids of @vport.
338  *
339  * @vport: vport to modify.
340  * @ids: new configuration, an array of port ids.
341  *
342  * Sets the vport's upcall_portids to @ids.
343  *
344  * Returns 0 if successful, -EINVAL if @ids is zero length or cannot be parsed
345  * as an array of U32.
346  *
347  * Must be called with ovs_mutex.
348  */
349 int ovs_vport_set_upcall_portids(struct vport *vport, const struct nlattr *ids)
350 {
351 	struct vport_portids *old, *vport_portids;
352 
353 	if (!nla_len(ids) || nla_len(ids) % sizeof(u32))
354 		return -EINVAL;
355 
356 	old = ovsl_dereference(vport->upcall_portids);
357 
358 	vport_portids = kmalloc(sizeof(*vport_portids) + nla_len(ids),
359 				GFP_KERNEL);
360 	if (!vport_portids)
361 		return -ENOMEM;
362 
363 	vport_portids->n_ids = nla_len(ids) / sizeof(u32);
364 	vport_portids->rn_ids = reciprocal_value(vport_portids->n_ids);
365 	nla_memcpy(vport_portids->ids, ids, nla_len(ids));
366 
367 	rcu_assign_pointer(vport->upcall_portids, vport_portids);
368 
369 	if (old)
370 		kfree_rcu(old, rcu);
371 	return 0;
372 }
373 
374 /**
375  *	ovs_vport_get_upcall_portids - get the upcall_portids of @vport.
376  *
377  * @vport: vport from which to retrieve the portids.
378  * @skb: sk_buff where portids should be appended.
379  *
380  * Retrieves the configuration of the given vport, appending the
381  * %OVS_VPORT_ATTR_UPCALL_PID attribute which is the array of upcall
382  * portids to @skb.
383  *
384  * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room.
385  * If an error occurs, @skb is left unmodified.  Must be called with
386  * ovs_mutex or rcu_read_lock.
387  */
388 int ovs_vport_get_upcall_portids(const struct vport *vport,
389 				 struct sk_buff *skb)
390 {
391 	struct vport_portids *ids;
392 
393 	ids = rcu_dereference_ovsl(vport->upcall_portids);
394 
395 	if (vport->dp->user_features & OVS_DP_F_VPORT_PIDS)
396 		return nla_put(skb, OVS_VPORT_ATTR_UPCALL_PID,
397 			       ids->n_ids * sizeof(u32), (void *)ids->ids);
398 	else
399 		return nla_put_u32(skb, OVS_VPORT_ATTR_UPCALL_PID, ids->ids[0]);
400 }
401 
402 /**
403  *	ovs_vport_find_upcall_portid - find the upcall portid to send upcall.
404  *
405  * @vport: vport from which the missed packet is received.
406  * @skb: skb that the missed packet was received.
407  *
408  * Uses the skb_get_hash() to select the upcall portid to send the
409  * upcall.
410  *
411  * Returns the portid of the target socket.  Must be called with rcu_read_lock.
412  */
413 u32 ovs_vport_find_upcall_portid(const struct vport *vport, struct sk_buff *skb)
414 {
415 	struct vport_portids *ids;
416 	u32 ids_index;
417 	u32 hash;
418 
419 	ids = rcu_dereference(vport->upcall_portids);
420 
421 	if (ids->n_ids == 1 && ids->ids[0] == 0)
422 		return 0;
423 
424 	hash = skb_get_hash(skb);
425 	ids_index = hash - ids->n_ids * reciprocal_divide(hash, ids->rn_ids);
426 	return ids->ids[ids_index];
427 }
428 
429 /**
430  *	ovs_vport_receive - pass up received packet to the datapath for processing
431  *
432  * @vport: vport that received the packet
433  * @skb: skb that was received
434  * @tun_key: tunnel (if any) that carried packet
435  *
436  * Must be called with rcu_read_lock.  The packet cannot be shared and
437  * skb->data should point to the Ethernet header.
438  */
439 int ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
440 		      const struct ip_tunnel_info *tun_info)
441 {
442 	struct sw_flow_key key;
443 	int error;
444 
445 	OVS_CB(skb)->input_vport = vport;
446 	OVS_CB(skb)->mru = 0;
447 	OVS_CB(skb)->cutlen = 0;
448 	if (unlikely(dev_net(skb->dev) != ovs_dp_get_net(vport->dp))) {
449 		u32 mark;
450 
451 		mark = skb->mark;
452 		skb_scrub_packet(skb, true);
453 		skb->mark = mark;
454 		tun_info = NULL;
455 	}
456 
457 	/* Extract flow from 'skb' into 'key'. */
458 	error = ovs_flow_key_extract(tun_info, skb, &key);
459 	if (unlikely(error)) {
460 		kfree_skb(skb);
461 		return error;
462 	}
463 	ovs_dp_process_packet(skb, &key);
464 	return 0;
465 }
466 
467 static int packet_length(const struct sk_buff *skb,
468 			 struct net_device *dev)
469 {
470 	int length = skb->len - dev->hard_header_len;
471 
472 	if (!skb_vlan_tag_present(skb) &&
473 	    eth_type_vlan(skb->protocol))
474 		length -= VLAN_HLEN;
475 
476 	/* Don't subtract for multiple VLAN tags. Most (all?) drivers allow
477 	 * (ETH_LEN + VLAN_HLEN) in addition to the mtu value, but almost none
478 	 * account for 802.1ad. e.g. is_skb_forwardable().
479 	 */
480 
481 	return length > 0 ? length : 0;
482 }
483 
484 void ovs_vport_send(struct vport *vport, struct sk_buff *skb, u8 mac_proto)
485 {
486 	int mtu = vport->dev->mtu;
487 
488 	switch (vport->dev->type) {
489 	case ARPHRD_NONE:
490 		if (mac_proto == MAC_PROTO_ETHERNET) {
491 			skb_reset_network_header(skb);
492 			skb_reset_mac_len(skb);
493 			skb->protocol = htons(ETH_P_TEB);
494 		} else if (mac_proto != MAC_PROTO_NONE) {
495 			WARN_ON_ONCE(1);
496 			goto drop;
497 		}
498 		break;
499 	case ARPHRD_ETHER:
500 		if (mac_proto != MAC_PROTO_ETHERNET)
501 			goto drop;
502 		break;
503 	default:
504 		goto drop;
505 	}
506 
507 	if (unlikely(packet_length(skb, vport->dev) > mtu &&
508 		     !skb_is_gso(skb))) {
509 		net_warn_ratelimited("%s: dropped over-mtu packet: %d > %d\n",
510 				     vport->dev->name,
511 				     packet_length(skb, vport->dev), mtu);
512 		vport->dev->stats.tx_errors++;
513 		goto drop;
514 	}
515 
516 	skb->dev = vport->dev;
517 	vport->ops->send(skb);
518 	return;
519 
520 drop:
521 	kfree_skb(skb);
522 }
523