[linux-2.6-block.git] / net / openvswitch / vport.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2007-2014 Nicira, Inc.
 */

#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 = kcalloc(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)
{
	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_noflag(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 int packet_length(const struct sk_buff *skb,
			 struct net_device *dev)
{
	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 > 0 ? length : 0;
}

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