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