[mirror_ubuntu-bionic-kernel.git] / net / openvswitch / vport.c

/*
 * Copyright (c) 2007-2014 Nicira, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 */

#include <linux/etherdevice.h>
#include <linux/if.h>
#include <linux/if_vlan.h>
#include <linux/jhash.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/percpu.h>
#include <linux/rcupdate.h>
#include <linux/rtnetlink.h>
#include <linux/compat.h>
#include <net/net_namespace.h>
#include <linux/module.h>

#include "datapath.h"
#include "vport.h"
#include "vport-internal_dev.h"

static LIST_HEAD(vport_ops_list);

/* Protected by RCU read lock for reading, ovs_mutex for writing. */
static struct hlist_head *dev_table;
#define VPORT_HASH_BUCKETS 1024

/**
 *	ovs_vport_init - initialize vport subsystem
 *
 * Called at module load time to initialize the vport subsystem.
 */
int ovs_vport_init(void)
{
	dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
			    GFP_KERNEL);
	if (!dev_table)
		return -ENOMEM;

	return 0;
}

/**
 *	ovs_vport_exit - shutdown vport subsystem
 *
 * Called at module exit time to shutdown the vport subsystem.
 */
void ovs_vport_exit(void)
{
	kfree(dev_table);
}

static struct hlist_head *hash_bucket(const struct net *net, const char *name)
{
	unsigned int hash = jhash(name, strlen(name), (unsigned long) net);
	return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
}

int __ovs_vport_ops_register(struct vport_ops *ops)
{
	int err = -EEXIST;
	struct vport_ops *o;

	ovs_lock();
	list_for_each_entry(o, &vport_ops_list, list)
		if (ops->type == o->type)
			goto errout;

	list_add_tail(&ops->list, &vport_ops_list);
	err = 0;
errout:
	ovs_unlock();
	return err;
}
EXPORT_SYMBOL_GPL(__ovs_vport_ops_register);

void ovs_vport_ops_unregister(struct vport_ops *ops)
{
	ovs_lock();
	list_del(&ops->list);
	ovs_unlock();
}
EXPORT_SYMBOL_GPL(ovs_vport_ops_unregister);

/**
 *	ovs_vport_locate - find a port that has already been created
 *
 * @name: name of port to find
 *
 * Must be called with ovs or RCU read lock.
 */
struct vport *ovs_vport_locate(const struct net *net, const char *name)
{
	struct hlist_head *bucket = hash_bucket(net, name);
	struct vport *vport;

	hlist_for_each_entry_rcu(vport, bucket, hash_node)
		if (!strcmp(name, ovs_vport_name(vport)) &&
		    net_eq(ovs_dp_get_net(vport->dp), net))
			return vport;

	return NULL;
}

/**
 *	ovs_vport_alloc - allocate and initialize new vport
 *
 * @priv_size: Size of private data area to allocate.
 * @ops: vport device ops
 *
 * Allocate and initialize a new vport defined by @ops.  The vport will contain
 * a private data area of size @priv_size that can be accessed using
 * vport_priv().  vports that are no longer needed should be released with
 * vport_free().
 */
struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
			  const struct vport_parms *parms)
{
	struct vport *vport;
	size_t alloc_size;

	alloc_size = sizeof(struct vport);
	if (priv_size) {
		alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
		alloc_size += priv_size;
	}

	vport = kzalloc(alloc_size, GFP_KERNEL);
	if (!vport)
		return ERR_PTR(-ENOMEM);

	vport->dp = parms->dp;
	vport->port_no = parms->port_no;
	vport->ops = ops;
	INIT_HLIST_NODE(&vport->dp_hash_node);

	if (ovs_vport_set_upcall_portids(vport, parms->upcall_portids)) {
		kfree(vport);
		return ERR_PTR(-EINVAL);
	}

	return vport;
}
EXPORT_SYMBOL_GPL(ovs_vport_alloc);

/**
 *	ovs_vport_free - uninitialize and free vport
 *
 * @vport: vport to free
 *
 * Frees a vport allocated with vport_alloc() when it is no longer needed.
 *
 * The caller must ensure that an RCU grace period has passed since the last
 * time @vport was in a datapath.
 */
void ovs_vport_free(struct vport *vport)
{
	/* vport is freed from RCU callback or error path, Therefore
	 * it is safe to use raw dereference.
	 */
	kfree(rcu_dereference_raw(vport->upcall_portids));
	kfree(vport);
}
EXPORT_SYMBOL_GPL(ovs_vport_free);

static struct vport_ops *ovs_vport_lookup(const struct vport_parms *parms)
{
	struct vport_ops *ops;

	list_for_each_entry(ops, &vport_ops_list, list)
		if (ops->type == parms->type)
			return ops;

	return NULL;
}

/**
 *	ovs_vport_add - add vport device (for kernel callers)
 *
 * @parms: Information about new vport.
 *
 * Creates a new vport with the specified configuration (which is dependent on
 * device type).  ovs_mutex must be held.
 */
struct vport *ovs_vport_add(const struct vport_parms *parms)
{
	struct vport_ops *ops;
	struct vport *vport;

	ops = ovs_vport_lookup(parms);
	if (ops) {
		struct hlist_head *bucket;

		if (!try_module_get(ops->owner))
			return ERR_PTR(-EAFNOSUPPORT);

		vport = ops->create(parms);
		if (IS_ERR(vport)) {
			module_put(ops->owner);
			return vport;
		}

		bucket = hash_bucket(ovs_dp_get_net(vport->dp),
				     ovs_vport_name(vport));
		hlist_add_head_rcu(&vport->hash_node, bucket);
		return vport;
	}

	/* Unlock to attempt module load and return -EAGAIN if load
	 * was successful as we need to restart the port addition
	 * workflow.
	 */
	ovs_unlock();
	request_module("vport-type-%d", parms->type);
	ovs_lock();

	if (!ovs_vport_lookup(parms))
		return ERR_PTR(-EAFNOSUPPORT);
	else
		return ERR_PTR(-EAGAIN);
}

/**
 *	ovs_vport_set_options - modify existing vport device (for kernel callers)
 *
 * @vport: vport to modify.
 * @options: New configuration.
 *
 * Modifies an existing device with the specified configuration (which is
 * dependent on device type).  ovs_mutex must be held.
 */
int ovs_vport_set_options(struct vport *vport, struct nlattr *options)
{
	if (!vport->ops->set_options)
		return -EOPNOTSUPP;
	return vport->ops->set_options(vport, options);
}

/**
 *	ovs_vport_del - delete existing vport device
 *
 * @vport: vport to delete.
 *
 * Detaches @vport from its datapath and destroys it.  ovs_mutex must
 * be held.
 */
void ovs_vport_del(struct vport *vport)
{
	ASSERT_OVSL();

	hlist_del_rcu(&vport->hash_node);
	module_put(vport->ops->owner);
	vport->ops->destroy(vport);
}

/**
 *	ovs_vport_get_stats - retrieve device stats
 *
 * @vport: vport from which to retrieve the stats
 * @stats: location to store stats
 *
 * Retrieves transmit, receive, and error stats for the given device.
 *
 * Must be called with ovs_mutex or rcu_read_lock.
 */
void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats)
{
	const struct rtnl_link_stats64 *dev_stats;
	struct rtnl_link_stats64 temp;

	dev_stats = dev_get_stats(vport->dev, &temp);
	stats->rx_errors  = dev_stats->rx_errors;
	stats->tx_errors  = dev_stats->tx_errors;
	stats->tx_dropped = dev_stats->tx_dropped;
	stats->rx_dropped = dev_stats->rx_dropped;

	stats->rx_bytes	  = dev_stats->rx_bytes;
	stats->rx_packets = dev_stats->rx_packets;
	stats->tx_bytes	  = dev_stats->tx_bytes;
	stats->tx_packets = dev_stats->tx_packets;
}

/**
 *	ovs_vport_get_options - retrieve device options
 *
 * @vport: vport from which to retrieve the options.
 * @skb: sk_buff where options should be appended.
 *
 * Retrieves the configuration of the given device, appending an
 * %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested
 * vport-specific attributes to @skb.
 *
 * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another
 * negative error code if a real error occurred.  If an error occurs, @skb is
 * left unmodified.
 *
 * Must be called with ovs_mutex or rcu_read_lock.
 */
int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb)
{
	struct nlattr *nla;
	int err;

	if (!vport->ops->get_options)
		return 0;

	nla = nla_nest_start(skb, OVS_VPORT_ATTR_OPTIONS);
	if (!nla)
		return -EMSGSIZE;

	err = vport->ops->get_options(vport, skb);
	if (err) {
		nla_nest_cancel(skb, nla);
		return err;
	}

	nla_nest_end(skb, nla);
	return 0;
}

/**
 *	ovs_vport_set_upcall_portids - set upcall portids of @vport.
 *
 * @vport: vport to modify.
 * @ids: new configuration, an array of port ids.
 *
 * Sets the vport's upcall_portids to @ids.
 *
 * Returns 0 if successful, -EINVAL if @ids is zero length or cannot be parsed
 * as an array of U32.
 *
 * Must be called with ovs_mutex.
 */
int ovs_vport_set_upcall_portids(struct vport *vport, const struct nlattr *ids)
{
	struct vport_portids *old, *vport_portids;

	if (!nla_len(ids) || nla_len(ids) % sizeof(u32))
		return -EINVAL;

	old = ovsl_dereference(vport->upcall_portids);

	vport_portids = kmalloc(sizeof(*vport_portids) + nla_len(ids),
				GFP_KERNEL);
	if (!vport_portids)
		return -ENOMEM;

	vport_portids->n_ids = nla_len(ids) / sizeof(u32);
	vport_portids->rn_ids = reciprocal_value(vport_portids->n_ids);
	nla_memcpy(vport_portids->ids, ids, nla_len(ids));

	rcu_assign_pointer(vport->upcall_portids, vport_portids);

	if (old)
		kfree_rcu(old, rcu);
	return 0;
}

/**
 *	ovs_vport_get_upcall_portids - get the upcall_portids of @vport.
 *
 * @vport: vport from which to retrieve the portids.
 * @skb: sk_buff where portids should be appended.
 *
 * Retrieves the configuration of the given vport, appending the
 * %OVS_VPORT_ATTR_UPCALL_PID attribute which is the array of upcall
 * portids to @skb.
 *
 * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room.
 * If an error occurs, @skb is left unmodified.  Must be called with
 * ovs_mutex or rcu_read_lock.
 */
int ovs_vport_get_upcall_portids(const struct vport *vport,
				 struct sk_buff *skb)
{
	struct vport_portids *ids;

	ids = rcu_dereference_ovsl(vport->upcall_portids);

	if (vport->dp->user_features & OVS_DP_F_VPORT_PIDS)
		return nla_put(skb, OVS_VPORT_ATTR_UPCALL_PID,
			       ids->n_ids * sizeof(u32), (void *)ids->ids);
	else
		return nla_put_u32(skb, OVS_VPORT_ATTR_UPCALL_PID, ids->ids[0]);
}

/**
 *	ovs_vport_find_upcall_portid - find the upcall portid to send upcall.
 *
 * @vport: vport from which the missed packet is received.
 * @skb: skb that the missed packet was received.
 *
 * Uses the skb_get_hash() to select the upcall portid to send the
 * upcall.
 *
 * Returns the portid of the target socket.  Must be called with rcu_read_lock.
 */
u32 ovs_vport_find_upcall_portid(const struct vport *vport, struct sk_buff *skb)
{
	struct vport_portids *ids;
	u32 ids_index;
	u32 hash;

	ids = rcu_dereference(vport->upcall_portids);

	if (ids->n_ids == 1 && ids->ids[0] == 0)
		return 0;

	hash = skb_get_hash(skb);
	ids_index = hash - ids->n_ids * reciprocal_divide(hash, ids->rn_ids);
	return ids->ids[ids_index];
}

/**
 *	ovs_vport_receive - pass up received packet to the datapath for processing
 *
 * @vport: vport that received the packet
 * @skb: skb that was received
 * @tun_key: tunnel (if any) that carried packet
 *
 * Must be called with rcu_read_lock.  The packet cannot be shared and
 * skb->data should point to the Ethernet header.
 */
int ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
		      const struct ip_tunnel_info *tun_info)
{
	struct sw_flow_key key;
	int error;

	OVS_CB(skb)->input_vport = vport;
	OVS_CB(skb)->mru = 0;
	OVS_CB(skb)->cutlen = 0;
	if (unlikely(dev_net(skb->dev) != ovs_dp_get_net(vport->dp))) {
		u32 mark;

		mark = skb->mark;
		skb_scrub_packet(skb, true);
		skb->mark = mark;
		tun_info = NULL;
	}

	/* Extract flow from 'skb' into 'key'. */
	error = ovs_flow_key_extract(tun_info, skb, &key);
	if (unlikely(error)) {
		kfree_skb(skb);
		return error;
	}
	ovs_dp_process_packet(skb, &key);
	return 0;
}

static unsigned int packet_length(const struct sk_buff *skb,
				  struct net_device *dev)
{
	unsigned int length = skb->len - dev->hard_header_len;

	if (!skb_vlan_tag_present(skb) &&
	    eth_type_vlan(skb->protocol))
		length -= VLAN_HLEN;

	/* Don't subtract for multiple VLAN tags. Most (all?) drivers allow
	 * (ETH_LEN + VLAN_HLEN) in addition to the mtu value, but almost none
	 * account for 802.1ad. e.g. is_skb_forwardable().
	 */

	return length;
}

void ovs_vport_send(struct vport *vport, struct sk_buff *skb, u8 mac_proto)
{
	int mtu = vport->dev->mtu;

	switch (vport->dev->type) {
	case ARPHRD_NONE:
		if (mac_proto == MAC_PROTO_ETHERNET) {
			skb_reset_network_header(skb);
			skb_reset_mac_len(skb);
			skb->protocol = htons(ETH_P_TEB);
		} else if (mac_proto != MAC_PROTO_NONE) {
			WARN_ON_ONCE(1);
			goto drop;
		}
		break;
	case ARPHRD_ETHER:
		if (mac_proto != MAC_PROTO_ETHERNET)
			goto drop;
		break;
	default:
		goto drop;
	}

	if (unlikely(packet_length(skb, vport->dev) > mtu &&
		     !skb_is_gso(skb))) {
		net_warn_ratelimited("%s: dropped over-mtu packet: %d > %d\n",
				     vport->dev->name,
				     packet_length(skb, vport->dev), mtu);
		vport->dev->stats.tx_errors++;
		goto drop;
	}

	skb->dev = vport->dev;
	vport->ops->send(skb);
	return;

drop:
	kfree_skb(skb);
}
Commit	Line	Data
ccb1352e	1	/*
83c8df26	2	* Copyright (c) 2007-2014 Nicira, Inc.
ccb1352e JG	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
ccb1352e JG	19	#include <linux/etherdevice.h>
	20	#include <linux/if.h>
	21	#include <linux/if_vlan.h>
46df7b81	22	#include <linux/jhash.h>
ccb1352e JG	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>
46df7b81	30	#include <net/net_namespace.h>
62b9c8d0	31	#include <linux/module.h>
ccb1352e	32
46df7b81	33	#include "datapath.h"
ccb1352e JG	34	#include "vport.h"
	35	#include "vport-internal_dev.h"
	36
62b9c8d0	37	static LIST_HEAD(vport_ops_list);
ccb1352e	38
8e4e1713	39	/* Protected by RCU read lock for reading, ovs_mutex for writing. */
ccb1352e JG	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 = kzalloc(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
12eb18f7	68	static struct hlist_head hash_bucket(const struct net net, const char *name)
ccb1352e	69	{
46df7b81	70	unsigned int hash = jhash(name, strlen(name), (unsigned long) net);
ccb1352e JG	71	return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
	72	}
	73
83e4bf7a	74	int __ovs_vport_ops_register(struct vport_ops *ops)
62b9c8d0 TG	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	}
83e4bf7a	90	EXPORT_SYMBOL_GPL(__ovs_vport_ops_register);
62b9c8d0 TG	91
	92	void ovs_vport_ops_unregister(struct vport_ops *ops)
	93	{
	94	ovs_lock();
	95	list_del(&ops->list);
	96	ovs_unlock();
	97	}
9ba559d9	98	EXPORT_SYMBOL_GPL(ovs_vport_ops_unregister);
62b9c8d0	99
ccb1352e JG	100	/**
	101	* ovs_vport_locate - find a port that has already been created
	102	*
	103	* @name: name of port to find
	104	*
8e4e1713	105	* Must be called with ovs or RCU read lock.
ccb1352e	106	*/
12eb18f7	107	struct vport ovs_vport_locate(const struct net net, const char *name)
ccb1352e	108	{
46df7b81	109	struct hlist_head *bucket = hash_bucket(net, name);
ccb1352e	110	struct vport *vport;
ccb1352e	111
b67bfe0d	112	hlist_for_each_entry_rcu(vport, bucket, hash_node)
c9db965c	113	if (!strcmp(name, ovs_vport_name(vport)) &&
46df7b81	114	net_eq(ovs_dp_get_net(vport->dp), net))
ccb1352e JG	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;
ccb1352e	149	vport->ops = ops;
15eac2a7	150	INIT_HLIST_NODE(&vport->dp_hash_node);
ccb1352e	151
3791b3f6 CJ	152	if (ovs_vport_set_upcall_portids(vport, parms->upcall_portids)) {
3791b3f6 CJ	153	kfree(vport);
5cd667b0	154	return ERR_PTR(-EINVAL);
3791b3f6	155	}
5cd667b0	156
ccb1352e JG	157	return vport;
ccb1352e JG	158	}
9ba559d9	159	EXPORT_SYMBOL_GPL(ovs_vport_alloc);
ccb1352e JG	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	{
5cd667b0 AW	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));
ccb1352e JG	177	kfree(vport);
ccb1352e JG	178	}
9ba559d9	179	EXPORT_SYMBOL_GPL(ovs_vport_free);
62b9c8d0 TG	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	}
ccb1352e JG	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
8e4e1713	198	* device type). ovs_mutex must be held.
ccb1352e JG	199	*/
	200	struct vport ovs_vport_add(const struct vport_parms parms)
	201	{
62b9c8d0	202	struct vport_ops *ops;
ccb1352e	203	struct vport *vport;
ccb1352e	204
62b9c8d0 TG	205	ops = ovs_vport_lookup(parms);
	206	if (ops) {
	207	struct hlist_head *bucket;
46df7b81	208
62b9c8d0 TG	209	if (!try_module_get(ops->owner))
62b9c8d0 TG	210	return ERR_PTR(-EAFNOSUPPORT);
ccb1352e	211
62b9c8d0 TG	212	vport = ops->create(parms);
	213	if (IS_ERR(vport)) {
	214	module_put(ops->owner);
ccb1352e JG	215	return vport;
ccb1352e JG	216	}
62b9c8d0 TG	217
62b9c8d0 TG	218	bucket = hash_bucket(ovs_dp_get_net(vport->dp),
c9db965c	219	ovs_vport_name(vport));
62b9c8d0 TG	220	hlist_add_head_rcu(&vport->hash_node, bucket);
62b9c8d0 TG	221	return vport;
ccb1352e JG	222	}
ccb1352e JG	223
62b9c8d0 TG	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();
ccb1352e	231
62b9c8d0 TG	232	if (!ovs_vport_lookup(parms))
	233	return ERR_PTR(-EAFNOSUPPORT);
	234	else
	235	return ERR_PTR(-EAGAIN);
ccb1352e JG	236	}
	237
	238	/**
	239	* ovs_vport_set_options - modify existing vport device (for kernel callers)
	240	*
	241	* @vport: vport to modify.
2694838d	242	* @options: New configuration.
ccb1352e JG	243	*
ccb1352e JG	244	* Modifies an existing device with the specified configuration (which is
8e4e1713	245	* dependent on device type). ovs_mutex must be held.
ccb1352e JG	246	*/
	247	int ovs_vport_set_options(struct vport vport, struct nlattr options)
	248	{
ccb1352e JG	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	*
20f79566 AC	259	* Detaches @vport from its datapath and destroys it. ovs_mutex must
20f79566 AC	260	* be held.
ccb1352e JG	261	*/
	262	void ovs_vport_del(struct vport *vport)
	263	{
8e4e1713	264	ASSERT_OVSL();
ccb1352e JG	265
ccb1352e JG	266	hlist_del_rcu(&vport->hash_node);
62b9c8d0	267	module_put(vport->ops->owner);
fa2d8ff4	268	vport->ops->destroy(vport);
ccb1352e JG	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	*
8e4e1713	279	* Must be called with ovs_mutex or rcu_read_lock.
ccb1352e JG	280	*/
	281	void ovs_vport_get_stats(struct vport vport, struct ovs_vport_stats stats)
	282	{
83ffe99f PS	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;
ccb1352e JG	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	*
8e4e1713	312	* Must be called with ovs_mutex or rcu_read_lock.
ccb1352e JG	313	*/
	314	int ovs_vport_get_options(const struct vport vport, struct sk_buff skb)
	315	{
	316	struct nlattr *nla;
5d963352 TG	317	int err;
	318
	319	if (!vport->ops->get_options)
	320	return 0;
ccb1352e JG	321
	322	nla = nla_nest_start(skb, OVS_VPORT_ATTR_OPTIONS);
	323	if (!nla)
	324	return -EMSGSIZE;
	325
5d963352 TG	326	err = vport->ops->get_options(vport, skb);
	327	if (err) {
	328	nla_nest_cancel(skb, nla);
	329	return err;
ccb1352e JG	330	}
	331
	332	nla_nest_end(skb, nla);
	333	return 0;
	334	}
	335
5cd667b0 AW	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	*/
12eb18f7	349	int ovs_vport_set_upcall_portids(struct vport vport, const struct nlattr ids)
5cd667b0 AW	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	*/
4e8febd0	413	u32 ovs_vport_find_upcall_portid(const struct vport vport, struct sk_buff skb)
5cd667b0 AW	414	{
	415	struct vport_portids *ids;
	416	u32 ids_index;
	417	u32 hash;
	418
4e8febd0	419	ids = rcu_dereference(vport->upcall_portids);
5cd667b0 AW	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
ccb1352e JG	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
2694838d	434	* @tun_key: tunnel (if any) that carried packet
ccb1352e JG	435	*
ccb1352e JG	436	* Must be called with rcu_read_lock. The packet cannot be shared and
d176ca2a	437	* skb->data should point to the Ethernet header.
ccb1352e	438	*/
8c876639 PS	439	int ovs_vport_receive(struct vport vport, struct sk_buff skb,
8c876639 PS	440	const struct ip_tunnel_info *tun_info)
ccb1352e	441	{
8c8b1b83 PS	442	struct sw_flow_key key;
8c8b1b83 PS	443	int error;
ccb1352e	444
83c8df26	445	OVS_CB(skb)->input_vport = vport;
7f8a436e	446	OVS_CB(skb)->mru = 0;
f2a4d086	447	OVS_CB(skb)->cutlen = 0;
740dbc28 JS	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
8c8b1b83	457	/* Extract flow from 'skb' into 'key'. */
f0b128c1	458	error = ovs_flow_key_extract(tun_info, skb, &key);
8c8b1b83 PS	459	if (unlikely(error)) {
8c8b1b83 PS	460	kfree_skb(skb);
8c876639	461	return error;
8c8b1b83 PS	462	}
8c8b1b83 PS	463	ovs_dp_process_packet(skb, &key);
8c876639	464	return 0;
ccb1352e JG	465	}
ccb1352e JG	466
738314a0 JB	467	static unsigned int packet_length(const struct sk_buff *skb,
738314a0 JB	468	struct net_device *dev)
aec15924	469	{
738314a0	470	unsigned int length = skb->len - dev->hard_header_len;
aec15924	471
72ec108d JB	472	if (!skb_vlan_tag_present(skb) &&
72ec108d JB	473	eth_type_vlan(skb->protocol))
aec15924 PS	474	length -= VLAN_HLEN;
aec15924 PS	475
018c1dda EG	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
aec15924 PS	481	return length;
	482	}
	483
e2d9d835	484	void ovs_vport_send(struct vport vport, struct sk_buff skb, u8 mac_proto)
aec15924 PS	485	{
	486	int mtu = vport->dev->mtu;
	487
5108bbad JB	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
738314a0 JB	507	if (unlikely(packet_length(skb, vport->dev) > mtu &&
738314a0 JB	508	!skb_is_gso(skb))) {
aec15924 PS	509	net_warn_ratelimited("%s: dropped over-mtu packet: %d > %d\n",
aec15924 PS	510	vport->dev->name,
738314a0	511	packet_length(skb, vport->dev), mtu);
aec15924 PS	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	}