X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=datapath%2Fvport.c;h=cdf615a47b8b135c631988ba6d52e9666391bab3;hb=33ef7695b71a71f2d0bb0e00aab46855afb8c2a6;hp=a166ef900e0482e0a9bfaa27167e447b928e4214;hpb=f2459fe7d91c4c325dfaa3ed18f56200b63ae27e;p=openvswitch

diff --git a/datapath/vport.c b/datapath/vport.c
index a166ef90..cdf615a4 100644
--- a/datapath/vport.c
+++ b/datapath/vport.c
@@ -9,21 +9,24 @@
 #include <linux/dcache.h>
 #include <linux/etherdevice.h>
 #include <linux/if.h>
+#include <linux/if_vlan.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/percpu.h>
 #include <linux/rtnetlink.h>
+#include <linux/compat.h>
 
 #include "vport.h"
+#include "vport-internal_dev.h"
 
-extern struct vport_ops netdev_vport_ops;
-extern struct vport_ops internal_vport_ops;
-extern struct vport_ops gre_vport_ops;
-
+/* List of statically compiled vport implementations.  Don't forget to also
+ * add yours to the list at the bottom of vport.h. */
 static struct vport_ops *base_vport_ops_list[] = {
 	&netdev_vport_ops,
 	&internal_vport_ops,
+	&patch_vport_ops,
+	&gre_vport_ops,
 };
 
 static const struct vport_ops **vport_ops_list;
@@ -54,8 +57,7 @@ static DEFINE_MUTEX(vport_mutex);
  * Acquire global vport lock.  See above comment about locking requirements
  * and specific function definitions.  May sleep.
  */
-void
-vport_lock(void)
+void vport_lock(void)
 {
 	mutex_lock(&vport_mutex);
 }
@@ -65,8 +67,7 @@ vport_lock(void)
  *
  * Release lock acquired with vport_lock.
  */
-void
-vport_unlock(void)
+void vport_unlock(void)
 {
 	mutex_unlock(&vport_mutex);
 }
@@ -85,8 +86,7 @@ vport_unlock(void)
  * Called at module load time to initialize the vport subsystem and any
  * compiled in vport types.
  */
-int
-vport_init(void)
+int vport_init(void)
 {
 	int err;
 	int i;
@@ -108,11 +108,6 @@ vport_init(void)
 	for (i = 0; i < ARRAY_SIZE(base_vport_ops_list); i++) {
 		struct vport_ops *new_ops = base_vport_ops_list[i];
 
-		if (new_ops->get_stats && new_ops->flags & VPORT_F_GEN_STATS) {
-			printk(KERN_INFO "openvswitch: both get_stats() and VPORT_F_GEN_STATS defined on vport %s, dropping VPORT_F_GEN_STATS\n", new_ops->type);
-			new_ops->flags &= ~VPORT_F_GEN_STATS;
-		}
-
 		if (new_ops->init)
 			err = new_ops->init();
 		else
@@ -134,8 +129,7 @@ error:
 	return err;
 }
 
-static void
-vport_del_all(void)
+static void vport_del_all(void)
 {
 	int i;
 
@@ -148,7 +142,7 @@ vport_del_all(void)
 		struct hlist_node *node, *next;
 
 		hlist_for_each_entry_safe(vport, node, next, bucket, hash_node)
-			__vport_del(vport);
+			vport_del(vport);
 	}
 
 	vport_unlock();
@@ -161,8 +155,7 @@ vport_del_all(void)
  * Called at module exit time to shutdown the vport subsystem and any
  * initialized vport types.
  */
-void
-vport_exit(void)
+void vport_exit(void)
 {
 	int i;
 
@@ -177,8 +170,37 @@ vport_exit(void)
 	kfree(dev_table);
 }
 
+static int do_vport_add(struct odp_vport_add *vport_config)
+{
+	struct vport *vport;
+	int err = 0;
+
+	vport_config->port_type[VPORT_TYPE_SIZE - 1] = '\0';
+	vport_config->devname[IFNAMSIZ - 1] = '\0';
+
+	rtnl_lock();
+
+	vport = vport_locate(vport_config->devname);
+	if (vport) {
+		err = -EBUSY;
+		goto out;
+	}
+
+	vport_lock();
+	vport = vport_add(vport_config->devname, vport_config->port_type,
+			  vport_config->config);
+	vport_unlock();
+
+	if (IS_ERR(vport))
+		err = PTR_ERR(vport);
+
+out:
+	rtnl_unlock();
+	return err;
+}
+
 /**
- *	vport_add - add vport device (for userspace callers)
+ *	vport_user_add - add vport device (for userspace callers)
  *
  * @uvport_config: New port configuration.
  *
@@ -186,42 +208,59 @@ vport_exit(void)
  * on device type).  This function is for userspace callers and assumes no
  * locks are held.
  */
-int
-vport_add(const struct odp_vport_add __user *uvport_config)
+int vport_user_add(const struct odp_vport_add __user *uvport_config)
 {
 	struct odp_vport_add vport_config;
-	struct vport *vport;
-	int err = 0;
 
 	if (copy_from_user(&vport_config, uvport_config, sizeof(struct odp_vport_add)))
 		return -EFAULT;
 
-	vport_config.port_type[VPORT_TYPE_SIZE - 1] = '\0';
-	vport_config.devname[IFNAMSIZ - 1] = '\0';
+	return do_vport_add(&vport_config);
+}
+
+#ifdef CONFIG_COMPAT
+int compat_vport_user_add(struct compat_odp_vport_add *ucompat)
+{
+	struct compat_odp_vport_add compat;
+	struct odp_vport_add vport_config;
+
+	if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_add)))
+		return -EFAULT;
+
+	memcpy(vport_config.port_type, compat.port_type, VPORT_TYPE_SIZE);
+	memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
+	vport_config.config = compat_ptr(compat.config);
+
+	return do_vport_add(&vport_config);
+}
+#endif
+
+static int do_vport_mod(struct odp_vport_mod *vport_config)
+{
+	struct vport *vport;
+	int err;
+
+	vport_config->devname[IFNAMSIZ - 1] = '\0';
 
 	rtnl_lock();
 
-	vport = vport_locate(vport_config.devname);
-	if (vport) {
-		err = -EEXIST;
+	vport = vport_locate(vport_config->devname);
+	if (!vport) {
+		err = -ENODEV;
 		goto out;
 	}
 
 	vport_lock();
-	vport = __vport_add(vport_config.devname, vport_config.port_type,
-			    vport_config.config);
+	err = vport_mod(vport, vport_config->config);
 	vport_unlock();
 
-	if (IS_ERR(vport))
-		err = PTR_ERR(vport);
-
 out:
 	rtnl_unlock();
 	return err;
 }
 
 /**
- *	vport_mod - modify existing vport device (for userspace callers)
+ *	vport_user_mod - modify existing vport device (for userspace callers)
  *
  * @uvport_config: New configuration for vport
  *
@@ -229,37 +268,34 @@ out:
  * dependent on device type).  This function is for userspace callers and
  * assumes no locks are held.
  */
-int
-vport_mod(const struct odp_vport_mod __user *uvport_config)
+int vport_user_mod(const struct odp_vport_mod __user *uvport_config)
 {
 	struct odp_vport_mod vport_config;
-	struct vport *vport;
-	int err;
 
 	if (copy_from_user(&vport_config, uvport_config, sizeof(struct odp_vport_mod)))
 		return -EFAULT;
 
-	vport_config.devname[IFNAMSIZ - 1] = '\0';
+	return do_vport_mod(&vport_config);
+}
 
-	rtnl_lock();
+#ifdef CONFIG_COMPAT
+int compat_vport_user_mod(struct compat_odp_vport_mod *ucompat)
+{
+	struct compat_odp_vport_mod compat;
+	struct odp_vport_mod vport_config;
 
-	vport = vport_locate(vport_config.devname);
-	if (!vport) {
-		err = -ENODEV;
-		goto out;
-	}
+	if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_mod)))
+		return -EFAULT;
 
-	vport_lock();
-	err = __vport_mod(vport, vport_config.config);
-	vport_unlock();
+	memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
+	vport_config.config = compat_ptr(compat.config);
 
-out:
-	rtnl_unlock();
-	return err;
+	return do_vport_mod(&vport_config);
 }
+#endif
 
 /**
- *	vport_del - delete existing vport device (for userspace callers)
+ *	vport_user_del - delete existing vport device (for userspace callers)
  *
  * @udevname: Name of device to delete
  *
@@ -269,17 +305,19 @@ out:
  * reasons, such as lack of memory.  This function is for userspace callers and
  * assumes no locks are held.
  */
-int
-vport_del(const char __user *udevname)
+int vport_user_del(const char __user *udevname)
 {
 	char devname[IFNAMSIZ];
 	struct vport *vport;
 	struct dp_port *dp_port;
 	int err = 0;
+	int retval;
 
-	if (strncpy_from_user(devname, udevname, IFNAMSIZ - 1) < 0)
+	retval = strncpy_from_user(devname, udevname, IFNAMSIZ);
+	if (retval < 0)
 		return -EFAULT;
-	devname[IFNAMSIZ - 1] = '\0';
+	else if (retval >= IFNAMSIZ)
+		return -ENAMETOOLONG;
 
 	rtnl_lock();
 
@@ -310,7 +348,7 @@ dp_port_out:
 	}
 
 	vport_lock();
-	err = __vport_del(vport);
+	err = vport_del(vport);
 	vport_unlock();
 
 out:
@@ -319,15 +357,14 @@ out:
 }
 
 /**
- *	vport_stats_get - retrieve device stats (for userspace callers)
+ *	vport_user_stats_get - retrieve device stats (for userspace callers)
  *
  * @ustats_req: Stats request parameters.
  *
  * Retrieves transmit, receive, and error stats for the given device.  This
  * function is for userspace callers and assumes no locks are held.
  */
-int
-vport_stats_get(struct odp_vport_stats_req __user *ustats_req)
+int vport_user_stats_get(struct odp_vport_stats_req __user *ustats_req)
 {
 	struct odp_vport_stats_req stats_req;
 	struct vport *vport;
@@ -346,63 +383,67 @@ vport_stats_get(struct odp_vport_stats_req __user *ustats_req)
 		goto out;
 	}
 
-	if (vport->ops->get_stats)
-		err = vport->ops->get_stats(vport, &stats_req.stats);
-	else if (vport->ops->flags & VPORT_F_GEN_STATS) {
-		int i;
+	err = vport_get_stats(vport, &stats_req.stats);
 
-		memset(&stats_req.stats, 0, sizeof(struct odp_vport_stats));
+out:
+	vport_unlock();
 
-		for_each_possible_cpu(i) {
-			const struct vport_percpu_stats *percpu_stats;
+	if (!err)
+		if (copy_to_user(ustats_req, &stats_req, sizeof(struct odp_vport_stats_req)))
+			err = -EFAULT;
 
-			percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
-			stats_req.stats.rx_bytes	+= percpu_stats->rx_bytes;
-			stats_req.stats.rx_packets	+= percpu_stats->rx_packets;
-			stats_req.stats.tx_bytes	+= percpu_stats->tx_bytes;
-			stats_req.stats.tx_packets	+= percpu_stats->tx_packets;
-		}
+	return err;
+}
 
-		spin_lock_bh(&vport->err_stats.lock);
+/**
+ *	vport_user_stats_set - sets offset device stats (for userspace callers)
+ *
+ * @ustats_req: Stats set parameters.
+ *
+ * Provides a set of transmit, receive, and error stats to be added as an
+ * offset to the collect data when stats are retreived.  Some devices may not
+ * support setting the stats, in which case the result will always be
+ * -EOPNOTSUPP.  This function is for userspace callers and assumes no locks
+ * are held.
+ */
+int vport_user_stats_set(struct odp_vport_stats_req __user *ustats_req)
+{
+	struct odp_vport_stats_req stats_req;
+	struct vport *vport;
+	int err;
 
-		stats_req.stats.rx_dropped	= vport->err_stats.rx_dropped;
-		stats_req.stats.rx_errors	= vport->err_stats.rx_errors
-						+ vport->err_stats.rx_frame_err
-						+ vport->err_stats.rx_over_err
-						+ vport->err_stats.rx_crc_err;
-		stats_req.stats.rx_frame_err	= vport->err_stats.rx_frame_err;
-		stats_req.stats.rx_over_err	= vport->err_stats.rx_over_err;
-		stats_req.stats.rx_crc_err	= vport->err_stats.rx_crc_err;
-		stats_req.stats.tx_dropped	= vport->err_stats.tx_dropped;
-		stats_req.stats.tx_errors	= vport->err_stats.tx_errors;
-		stats_req.stats.collisions	= vport->err_stats.collisions;
+	if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
+		return -EFAULT;
 
-		spin_unlock_bh(&vport->err_stats.lock);
+	stats_req.devname[IFNAMSIZ - 1] = '\0';
 
-		err = 0;
-	} else
-		err = -EOPNOTSUPP;
+	rtnl_lock();
+	vport_lock();
 
-out:
-	vport_unlock();
+	vport = vport_locate(stats_req.devname);
+	if (!vport) {
+		err = -ENODEV;
+		goto out;
+	}
 
-	if (!err)
-		if (copy_to_user(ustats_req, &stats_req, sizeof(struct odp_vport_stats_req)))
-			err = -EFAULT;
+	err = vport_set_stats(vport, &stats_req.stats);
 
+out:
+	vport_unlock();
+	rtnl_unlock();
 	return err;
 }
 
+
 /**
- *	vport_ether_get - retrieve device Ethernet address (for userspace callers)
+ *	vport_user_ether_get - retrieve device Ethernet address (for userspace callers)
  *
  * @uvport_ether: Ethernet address request parameters.
  *
  * Retrieves the Ethernet address of the given device.  This function is for
  * userspace callers and assumes no locks are held.
  */
-int
-vport_ether_get(struct odp_vport_ether __user *uvport_ether)
+int vport_user_ether_get(struct odp_vport_ether __user *uvport_ether)
 {
 	struct odp_vport_ether vport_ether;
 	struct vport *vport;
@@ -421,7 +462,9 @@ vport_ether_get(struct odp_vport_ether __user *uvport_ether)
 		goto out;
 	}
 
+	rcu_read_lock();
 	memcpy(vport_ether.ether_addr, vport_get_addr(vport), ETH_ALEN);
+	rcu_read_unlock();
 
 out:
 	vport_unlock();
@@ -434,7 +477,7 @@ out:
 }
 
 /**
- *	vport_ether_set - set device Ethernet address (for userspace callers)
+ *	vport_user_ether_set - set device Ethernet address (for userspace callers)
  *
  * @uvport_ether: Ethernet address request parameters.
  *
@@ -443,8 +486,7 @@ out:
  * -EOPNOTSUPP.  This function is for userspace callers and assumes no locks
  * are held.
  */
-int
-vport_ether_set(struct odp_vport_ether __user *uvport_ether)
+int vport_user_ether_set(struct odp_vport_ether __user *uvport_ether)
 {
 	struct odp_vport_ether vport_ether;
 	struct vport *vport;
@@ -473,15 +515,14 @@ out:
 }
 
 /**
- *	vport_mut_get - retrieve device MTU (for userspace callers)
+ *	vport_user_mtu_get - retrieve device MTU (for userspace callers)
  *
  * @uvport_mtu: MTU request parameters.
  *
  * Retrieves the MTU of the given device.  This function is for userspace
  * callers and assumes no locks are held.
  */
-int
-vport_mtu_get(struct odp_vport_mtu __user *uvport_mtu)
+int vport_user_mtu_get(struct odp_vport_mtu __user *uvport_mtu)
 {
 	struct odp_vport_mtu vport_mtu;
 	struct vport *vport;
@@ -513,7 +554,7 @@ out:
 }
 
 /**
- *	vport_mtu_set - set device MTU (for userspace callers)
+ *	vport_user_mtu_set - set device MTU (for userspace callers)
  *
  * @uvport_mtu: MTU request parameters.
  *
@@ -521,8 +562,7 @@ out:
  * MTU, in which case the result will always be -EOPNOTSUPP.  This function is
  * for userspace callers and assumes no locks are held.
  */
-int
-vport_mtu_set(struct odp_vport_mtu __user *uvport_mtu)
+int vport_user_mtu_set(struct odp_vport_mtu __user *uvport_mtu)
 {
 	struct odp_vport_mtu vport_mtu;
 	struct vport *vport;
@@ -550,8 +590,7 @@ out:
 	return err;
 }
 
-static struct hlist_head *
-hash_bucket(const char *name)
+static struct hlist_head *hash_bucket(const char *name)
 {
 	unsigned int hash = full_name_hash(name, strlen(name));
 	return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
@@ -566,8 +605,7 @@ hash_bucket(const char *name)
  * and held while using the found port.  See the locking comments at the
  * top of the file.
  */
-struct vport *
-vport_locate(const char *name)
+struct vport *vport_locate(const char *name)
 {
 	struct hlist_head *bucket = hash_bucket(name);
 	struct vport *vport;
@@ -578,21 +616,25 @@ vport_locate(const char *name)
 		dump_stack();
 	}
 
+	rcu_read_lock();
+
 	hlist_for_each_entry(vport, node, bucket, hash_node)
 		if (!strcmp(name, vport_get_name(vport)))
-			return vport;
+			goto out;
+
+	vport = NULL;
 
-	return NULL;
+out:
+	rcu_read_unlock();
+	return vport;
 }
 
-static void
-register_vport(struct vport *vport)
+static void register_vport(struct vport *vport)
 {
 	hlist_add_head(&vport->hash_node, hash_bucket(vport_get_name(vport)));
 }
 
-static void
-unregister_vport(struct vport *vport)
+static void unregister_vport(struct vport *vport)
 {
 	hlist_del(&vport->hash_node);
 }
@@ -608,8 +650,7 @@ unregister_vport(struct vport *vport)
  * vport_priv().  vports that are no longer needed should be released with
  * vport_free().
  */
-struct vport *
-vport_alloc(int priv_size, const struct vport_ops *ops)
+struct vport *vport_alloc(int priv_size, const struct vport_ops *ops)
 {
 	struct vport *vport;
 	size_t alloc_size;
@@ -631,7 +672,7 @@ vport_alloc(int priv_size, const struct vport_ops *ops)
 		if (!vport->percpu_stats)
 			return ERR_PTR(-ENOMEM);
 
-		spin_lock_init(&vport->err_stats.lock);
+		spin_lock_init(&vport->stats_lock);
 	}
 
 	return vport;
@@ -644,8 +685,7 @@ vport_alloc(int priv_size, const struct vport_ops *ops)
  *
  * Frees a vport allocated with vport_alloc() when it is no longer needed.
  */
-void
-vport_free(struct vport *vport)
+void vport_free(struct vport *vport)
 {
 	if (vport->ops->flags & VPORT_F_GEN_STATS)
 		free_percpu(vport->percpu_stats);
@@ -654,7 +694,7 @@ vport_free(struct vport *vport)
 }
 
 /**
- *	__vport_add - add vport device (for kernel callers)
+ *	vport_add - add vport device (for kernel callers)
  *
  * @name: Name of new device.
  * @type: Type of new device (to be matched against types in registered vport
@@ -664,8 +704,7 @@ vport_free(struct vport *vport)
  * Creates a new vport with the specified configuration (which is dependent
  * on device type).  Both RTNL and vport locks must be held.
  */
-struct vport *
-__vport_add(const char *name, const char *type, const void __user *config)
+struct vport *vport_add(const char *name, const char *type, const void __user *config)
 {
 	struct vport *vport;
 	int err = 0;
@@ -694,7 +733,7 @@ out:
 }
 
 /**
- *	__vport_mod - modify existing vport device (for kernel callers)
+ *	vport_mod - modify existing vport device (for kernel callers)
  *
  * @vport: vport to modify.
  * @config: Device type specific configuration.  Userspace pointer.
@@ -702,8 +741,7 @@ out:
  * Modifies an existing device with the specified configuration (which is
  * dependent on device type).  Both RTNL and vport locks must be held.
  */
-int
-__vport_mod(struct vport *vport, const void __user *config)
+int vport_mod(struct vport *vport, const void __user *config)
 {
 	ASSERT_RTNL();
 	ASSERT_VPORT();
@@ -715,7 +753,7 @@ __vport_mod(struct vport *vport, const void __user *config)
 }
 
 /**
- *	__vport_del - delete existing vport device (for kernel callers)
+ *	vport_del - delete existing vport device (for kernel callers)
  *
  * @vport: vport to delete.
  *
@@ -723,8 +761,7 @@ __vport_mod(struct vport *vport, const void __user *config)
  * a datapath.  It is possible to fail for reasons such as lack of memory.
  * Both RTNL and vport locks must be held.
  */
-int
-__vport_del(struct vport *vport)
+int vport_del(struct vport *vport)
 {
 	ASSERT_RTNL();
 	ASSERT_VPORT();
@@ -746,14 +783,10 @@ __vport_del(struct vport *vport)
  * attached to a vport before it is connected to a datapath and must not be
  * modified while connected.  RTNL lock and the appropriate DP mutex must be held.
  */
-int
-vport_attach(struct vport *vport, struct dp_port *dp_port)
+int vport_attach(struct vport *vport, struct dp_port *dp_port)
 {
 	ASSERT_RTNL();
 
-	if (dp_port->vport)
-		return -EBUSY;
-
 	if (vport_get_dp_port(vport))
 		return -EBUSY;
 
@@ -765,7 +798,6 @@ vport_attach(struct vport *vport, struct dp_port *dp_port)
 			return err;
 	}
 
-	dp_port->vport = vport;
 	rcu_assign_pointer(vport->dp_port, dp_port);
 
 	return 0;
@@ -779,8 +811,7 @@ vport_attach(struct vport *vport, struct dp_port *dp_port)
  * Detaches a vport from a datapath.  May fail for a variety of reasons,
  * including lack of memory.  RTNL lock and the appropriate DP mutex must be held.
  */
-int
-vport_detach(struct vport *vport)
+int vport_detach(struct vport *vport)
 {
 	struct dp_port *dp_port;
 
@@ -790,7 +821,6 @@ vport_detach(struct vport *vport)
 	if (!dp_port)
 		return -EINVAL;
 
-	dp_port->vport = NULL;
 	rcu_assign_pointer(vport->dp_port, NULL);
 
 	if (vport->ops->detach)
@@ -809,17 +839,27 @@ vport_detach(struct vport *vport)
  * MTU, in which case the result will always be -EOPNOTSUPP.  RTNL lock must
  * be held.
  */
-int
-vport_set_mtu(struct vport *vport, int mtu)
+int vport_set_mtu(struct vport *vport, int mtu)
 {
 	ASSERT_RTNL();
 
 	if (mtu < 68)
 		return -EINVAL;
 
-	if (vport->ops->set_mtu)
-		return vport->ops->set_mtu(vport, mtu);
-	else
+	if (vport->ops->set_mtu) {
+		int ret;
+
+		ret = vport->ops->set_mtu(vport, mtu);
+
+		if (!ret && !is_internal_vport(vport)) {
+			struct dp_port *dp_port = vport_get_dp_port(vport);
+
+			if (dp_port)
+				set_internal_devs_mtu(dp_port->dp);
+		}
+
+		return ret;
+	} else
 		return -EOPNOTSUPP;
 }
 
@@ -833,8 +873,7 @@ vport_set_mtu(struct vport *vport, int mtu)
  * setting the Ethernet address, in which case the result will always be
  * -EOPNOTSUPP.  RTNL lock must be held.
  */
-int
-vport_set_addr(struct vport *vport, const unsigned char *addr)
+int vport_set_addr(struct vport *vport, const unsigned char *addr)
 {
 	ASSERT_RTNL();
 
@@ -847,6 +886,33 @@ vport_set_addr(struct vport *vport, const unsigned char *addr)
 		return -EOPNOTSUPP;
 }
 
+/**
+ *	vport_set_stats - sets offset device stats (for kernel callers)
+ *
+ * @vport: vport on which to set stats
+ * @stats: stats to set
+ *
+ * Provides a set of transmit, receive, and error stats to be added as an
+ * offset to the collect data when stats are retreived.  Some devices may not
+ * support setting the stats, in which case the result will always be
+ * -EOPNOTSUPP.  RTNL lock must be held.
+ */
+int vport_set_stats(struct vport *vport, struct odp_vport_stats *stats)
+{
+	ASSERT_RTNL();
+
+	if (vport->ops->flags & VPORT_F_GEN_STATS) {
+		spin_lock_bh(&vport->stats_lock);
+		memcpy(&vport->offset_stats, stats, sizeof(struct odp_vport_stats));
+		spin_unlock_bh(&vport->stats_lock);
+
+		return 0;
+	} else if (vport->ops->set_stats)
+		return vport->ops->set_stats(vport, stats);
+	else
+		return -EOPNOTSUPP;
+}
+
 /**
  *	vport_get_name - retrieve device name
  *
@@ -855,8 +921,7 @@ vport_set_addr(struct vport *vport, const unsigned char *addr)
  * Retrieves the name of the given device.  Either RTNL lock or rcu_read_lock
  * must be held for the entire duration that the name is in use.
  */
-const char *
-vport_get_name(const struct vport *vport)
+const char *vport_get_name(const struct vport *vport)
 {
 	return vport->ops->get_name(vport);
 }
@@ -869,8 +934,7 @@ vport_get_name(const struct vport *vport)
  * Retrieves the type of the given device.  Either RTNL lock or rcu_read_lock
  * must be held for the entire duration that the type is in use.
  */
-const char *
-vport_get_type(const struct vport *vport)
+const char *vport_get_type(const struct vport *vport)
 {
 	return vport->ops->type;
 }
@@ -884,8 +948,7 @@ vport_get_type(const struct vport *vport)
  * rcu_read_lock must be held for the entire duration that the Ethernet address
  * is in use.
  */
-const unsigned char *
-vport_get_addr(const struct vport *vport)
+const unsigned char *vport_get_addr(const struct vport *vport)
 {
 	return vport->ops->get_addr(vport);
 }
@@ -899,8 +962,7 @@ vport_get_addr(const struct vport *vport)
  * lock or rcu_read_lock must be held for the entire duration that the datapath
  * port is being accessed.
  */
-struct dp_port *
-vport_get_dp_port(const struct vport *vport)
+struct dp_port *vport_get_dp_port(const struct vport *vport)
 {
 	return rcu_dereference(vport->dp_port);
 }
@@ -913,8 +975,7 @@ vport_get_dp_port(const struct vport *vport)
  * Retrieves the associated kobj or null if no kobj.  The returned kobj is
  * valid for as long as the vport exists.
  */
-struct kobject *
-vport_get_kobj(const struct vport *vport)
+struct kobject *vport_get_kobj(const struct vport *vport)
 {
 	if (vport->ops->get_kobj)
 		return vport->ops->get_kobj(vport);
@@ -922,6 +983,99 @@ vport_get_kobj(const struct vport *vport)
 		return NULL;
 }
 
+/**
+ *	vport_get_stats - retrieve device stats (for kernel callers)
+ *
+ * @vport: vport from which to retrieve the stats
+ * @stats: location to store stats
+ *
+ * Retrieves transmit, receive, and error stats for the given device.
+ */
+int vport_get_stats(struct vport *vport, struct odp_vport_stats *stats)
+{
+	struct odp_vport_stats dev_stats;
+	struct odp_vport_stats *dev_statsp = NULL;
+	int err;
+
+	if (vport->ops->get_stats) {
+		if (vport->ops->flags & VPORT_F_GEN_STATS)
+			dev_statsp = &dev_stats;
+		else
+			dev_statsp = stats;
+
+		rcu_read_lock();
+		err = vport->ops->get_stats(vport, dev_statsp);
+		rcu_read_unlock();
+
+		if (err)
+			goto out;
+	}
+
+	if (vport->ops->flags & VPORT_F_GEN_STATS) {
+		int i;
+
+		/* We potentially have 3 sources of stats that need to be
+		 * combined: those we have collected (split into err_stats and
+		 * percpu_stats), offset_stats from set_stats(), and device
+		 * error stats from get_stats() (for errors that happen
+		 * downstream and therefore aren't reported through our
+		 * vport_record_error() function). */
+
+		spin_lock_bh(&vport->stats_lock);
+
+		memcpy(stats, &vport->offset_stats, sizeof(struct odp_vport_stats));
+
+		stats->rx_errors	+= vport->err_stats.rx_errors
+						+ vport->err_stats.rx_frame_err
+						+ vport->err_stats.rx_over_err
+						+ vport->err_stats.rx_crc_err;
+		stats->tx_errors	+= vport->err_stats.tx_errors;
+		stats->tx_dropped	+= vport->err_stats.tx_dropped;
+		stats->rx_dropped	+= vport->err_stats.rx_dropped;
+		stats->rx_over_err	+= vport->err_stats.rx_over_err;
+		stats->rx_crc_err	+= vport->err_stats.rx_crc_err;
+		stats->rx_frame_err	+= vport->err_stats.rx_frame_err;
+		stats->collisions	+= vport->err_stats.collisions;
+
+		spin_unlock_bh(&vport->stats_lock);
+
+		if (dev_statsp) {
+			stats->rx_errors	+= dev_statsp->rx_errors;
+			stats->tx_errors	+= dev_statsp->tx_errors;
+			stats->rx_dropped	+= dev_statsp->rx_dropped;
+			stats->tx_dropped	+= dev_statsp->tx_dropped;
+			stats->rx_over_err	+= dev_statsp->rx_over_err;
+			stats->rx_crc_err	+= dev_statsp->rx_crc_err;
+			stats->rx_frame_err	+= dev_statsp->rx_frame_err;
+			stats->collisions	+= dev_statsp->collisions;
+		}
+
+		for_each_possible_cpu(i) {
+			const struct vport_percpu_stats *percpu_stats;
+			struct vport_percpu_stats local_stats;
+			unsigned seqcount;
+
+			percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
+
+			do {
+				seqcount = read_seqcount_begin(&percpu_stats->seqlock);
+				local_stats = *percpu_stats;
+			} while (read_seqcount_retry(&percpu_stats->seqlock, seqcount));
+
+			stats->rx_bytes		+= local_stats.rx_bytes;
+			stats->rx_packets	+= local_stats.rx_packets;
+			stats->tx_bytes		+= local_stats.tx_bytes;
+			stats->tx_packets	+= local_stats.tx_packets;
+		}
+
+		err = 0;
+	} else
+		err = -EOPNOTSUPP;
+
+out:
+	return err;
+}
+
 /**
  *	vport_get_flags - retrieve device flags
  *
@@ -930,8 +1084,7 @@ vport_get_kobj(const struct vport *vport)
  * Retrieves the flags of the given device.  Either RTNL lock or rcu_read_lock
  * must be held.
  */
-unsigned
-vport_get_flags(const struct vport *vport)
+unsigned vport_get_flags(const struct vport *vport)
 {
 	return vport->ops->get_dev_flags(vport);
 }
@@ -944,8 +1097,7 @@ vport_get_flags(const struct vport *vport)
  * Checks whether the given device is running.  Either RTNL lock or
  * rcu_read_lock must be held.
  */
-int
-vport_is_running(const struct vport *vport)
+int vport_is_running(const struct vport *vport)
 {
 	return vport->ops->is_running(vport);
 }
@@ -958,8 +1110,7 @@ vport_is_running(const struct vport *vport)
  * Retrieves the RFC2863 operstate of the given device.  Either RTNL lock or
  * rcu_read_lock must be held.
  */
-unsigned char
-vport_get_operstate(const struct vport *vport)
+unsigned char vport_get_operstate(const struct vport *vport)
 {
 	return vport->ops->get_operstate(vport);
 }
@@ -974,8 +1125,7 @@ vport_get_operstate(const struct vport *vport)
  * port is returned.  Returns a negative index on error.  Either RTNL lock or
  * rcu_read_lock must be held.
  */
-int
-vport_get_ifindex(const struct vport *vport)
+int vport_get_ifindex(const struct vport *vport)
 {
 	const struct dp_port *dp_port;
 
@@ -1002,8 +1152,7 @@ vport_get_ifindex(const struct vport *vport)
  * Returns a negative index on error.  Either RTNL lock or rcu_read_lock must
  * be held.
  */
-int
-vport_get_iflink(const struct vport *vport)
+int vport_get_iflink(const struct vport *vport)
 {
 	if (vport->ops->get_iflink)
 		return vport->ops->get_iflink(vport);
@@ -1021,8 +1170,7 @@ vport_get_iflink(const struct vport *vport)
  * Retrieves the MTU of the given device.  Either RTNL lock or rcu_read_lock
  * must be held.
  */
-int
-vport_get_mtu(const struct vport *vport)
+int vport_get_mtu(const struct vport *vport)
 {
 	return vport->ops->get_mtu(vport);
 }
@@ -1033,25 +1181,31 @@ vport_get_mtu(const struct vport *vport)
  * @vport: vport that received the packet
  * @skb: skb that was received
  *
- * Must be called with rcu_read_lock and bottom halves disabled.  The packet
- * cannot be shared and skb->data should point to the Ethernet header.
+ * Must be called with rcu_read_lock.  The packet cannot be shared and
+ * skb->data should point to the Ethernet header.  The caller must have already
+ * called compute_ip_summed() to initialize the checksumming fields.
  */
-void
-vport_receive(struct vport *vport, struct sk_buff *skb)
+void vport_receive(struct vport *vport, struct sk_buff *skb)
 {
 	struct dp_port *dp_port = vport_get_dp_port(vport);
 
-	if (!dp_port)
+	if (!dp_port) {
+		vport_record_error(vport, VPORT_E_RX_DROPPED);
+		kfree_skb(skb);
+
 		return;
+	}
 
 	if (vport->ops->flags & VPORT_F_GEN_STATS) {
 		struct vport_percpu_stats *stats;
 
 		local_bh_disable();
-
 		stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
+
+		write_seqcount_begin(&stats->seqlock);
 		stats->rx_packets++;
 		stats->rx_bytes += skb->len;
+		write_seqcount_end(&stats->seqlock);
 
 		local_bh_enable();
 	}
@@ -1062,6 +1216,16 @@ vport_receive(struct vport *vport, struct sk_buff *skb)
 	dp_process_received_packet(dp_port, skb);
 }
 
+static inline unsigned packet_length(const struct sk_buff *skb)
+{
+	unsigned length = skb->len - ETH_HLEN;
+
+	if (skb->protocol == htons(ETH_P_8021Q))
+		length -= VLAN_HLEN;
+
+	return length;
+}
+
 /**
  *	vport_send - send a packet on a device
  *
@@ -1071,26 +1235,41 @@ vport_receive(struct vport *vport, struct sk_buff *skb)
  * Sends the given packet and returns the length of data sent.  Either RTNL
  * lock or rcu_read_lock must be held.
  */
-int
-vport_send(struct vport *vport, struct sk_buff *skb)
+int vport_send(struct vport *vport, struct sk_buff *skb)
 {
+	int mtu;
 	int sent;
 
+	mtu = vport_get_mtu(vport);
+	if (unlikely(packet_length(skb) > mtu && !skb_is_gso(skb))) {
+		if (net_ratelimit())
+			printk(KERN_WARNING "%s: dropped over-mtu packet: %d > %d\n",
+			       dp_name(vport_get_dp_port(vport)->dp), packet_length(skb), mtu);
+		goto error;
+	}
+
 	sent = vport->ops->send(vport, skb);
 
 	if (vport->ops->flags & VPORT_F_GEN_STATS && sent > 0) {
 		struct vport_percpu_stats *stats;
 
 		local_bh_disable();
-
 		stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
+
+		write_seqcount_begin(&stats->seqlock);
 		stats->tx_packets++;
 		stats->tx_bytes += sent;
+		write_seqcount_end(&stats->seqlock);
 
 		local_bh_enable();
 	}
 
 	return sent;
+
+error:
+	kfree_skb(skb);
+	vport_record_error(vport, VPORT_E_TX_DROPPED);
+	return 0;
 }
 
 /**
@@ -1102,12 +1281,11 @@ vport_send(struct vport *vport, struct sk_buff *skb)
  * If using the vport generic stats layer indicate that an error of the given
  * type has occured.
  */
-void
-vport_record_error(struct vport *vport, enum vport_err_type err_type)
+void vport_record_error(struct vport *vport, enum vport_err_type err_type)
 {
 	if (vport->ops->flags & VPORT_F_GEN_STATS) {
 
-		spin_lock_bh(&vport->err_stats.lock);
+		spin_lock_bh(&vport->stats_lock);
 
 		switch (err_type) {
 		case VPORT_E_RX_DROPPED:
@@ -1143,28 +1321,6 @@ vport_record_error(struct vport *vport, enum vport_err_type err_type)
 			break;
 		};
 
-		spin_unlock_bh(&vport->err_stats.lock);
+		spin_unlock_bh(&vport->stats_lock);
 	}
 }
-
-/**
- *	vport_gen_ether_addr - generate an Ethernet address
- *
- * @addr: location to store generated address
- *
- * Generates a random Ethernet address for use when creating a device that
- * has no natural address.
- */
-void
-vport_gen_ether_addr(u8 *addr)
-{
-	random_ether_addr(addr);
-
-	/* Set the OUI to the Nicira one. */
-	addr[0] = 0x00;
-	addr[1] = 0x23;
-	addr[2] = 0x20;
-
-	/* Set the top bit to indicate random address. */
-	addr[3] |= 0x80;
-}