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