X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=datapath%2Fvport.c;h=37d6d8ab058477dea0c74b36801256a0a96b21cc;hb=cd10ed7fb4fb5b1e3ed8e3fae1fd115c7ae96e77;hp=83b42d550f294eb10dab56b9833fe5a1999105bb;hpb=61e89cd6d688b8ea2368a815dbe3516d731e77f0;p=openvswitch

diff --git a/datapath/vport.c b/datapath/vport.c
index 83b42d55..37d6d8ab 100644
--- a/datapath/vport.c
+++ b/datapath/vport.c
@@ -6,29 +6,33 @@
  * kernel, by Linus Torvalds and others.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #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 <linux/version.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 patch_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,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+	&capwap_vport_ops,
+#endif
 };
 
 static const struct vport_ops **vport_ops_list;
@@ -59,8 +63,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);
 }
@@ -70,19 +73,19 @@ vport_lock(void)
  *
  * Release lock acquired with vport_lock.
  */
-void
-vport_unlock(void)
+void vport_unlock(void)
 {
 	mutex_unlock(&vport_mutex);
 }
 
-#define ASSERT_VPORT() do { \
-	if (unlikely(!mutex_is_locked(&vport_mutex))) { \
-		printk(KERN_ERR "openvswitch: vport lock not held at %s (%d)\n", \
-			__FILE__, __LINE__); \
-		dump_stack(); \
-	} \
-} while(0)
+#define ASSERT_VPORT()						\
+do {								\
+	if (unlikely(!mutex_is_locked(&vport_mutex))) {		\
+		pr_err("vport lock not held at %s (%d)\n",	\
+		       __FILE__, __LINE__);			\
+		dump_stack();					\
+	}							\
+} while (0)
 
 /**
  *	vport_init - initialize vport subsystem
@@ -90,8 +93,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;
@@ -113,11 +115,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
@@ -139,8 +136,7 @@ error:
 	return err;
 }
 
-static void
-vport_del_all(void)
+static void vport_del_all(void)
 {
 	int i;
 
@@ -166,8 +162,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;
 
@@ -182,8 +177,7 @@ vport_exit(void)
 	kfree(dev_table);
 }
 
-static int
-do_vport_add(struct odp_vport_add *vport_config)
+static int do_vport_add(struct odp_vport_add *vport_config)
 {
 	struct vport *vport;
 	int err = 0;
@@ -195,7 +189,7 @@ do_vport_add(struct odp_vport_add *vport_config)
 
 	vport = vport_locate(vport_config->devname);
 	if (vport) {
-		err = -EEXIST;
+		err = -EBUSY;
 		goto out;
 	}
 
@@ -221,8 +215,7 @@ out:
  * on device type).  This function is for userspace callers and assumes no
  * locks are held.
  */
-int
-vport_user_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;
 
@@ -233,8 +226,7 @@ vport_user_add(const struct odp_vport_add __user *uvport_config)
 }
 
 #ifdef CONFIG_COMPAT
-int
-compat_vport_user_add(struct compat_odp_vport_add *ucompat)
+int compat_vport_user_add(struct compat_odp_vport_add *ucompat)
 {
 	struct compat_odp_vport_add compat;
 	struct odp_vport_add vport_config;
@@ -250,8 +242,7 @@ compat_vport_user_add(struct compat_odp_vport_add *ucompat)
 }
 #endif
 
-static int
-do_vport_mod(struct odp_vport_mod *vport_config)
+static int do_vport_mod(struct odp_vport_mod *vport_config)
 {
 	struct vport *vport;
 	int err;
@@ -284,8 +275,7 @@ out:
  * dependent on device type).  This function is for userspace callers and
  * assumes no locks are held.
  */
-int
-vport_user_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;
 
@@ -296,8 +286,7 @@ vport_user_mod(const struct odp_vport_mod __user *uvport_config)
 }
 
 #ifdef CONFIG_COMPAT
-int
-compat_vport_user_mod(struct compat_odp_vport_mod *ucompat)
+int compat_vport_user_mod(struct compat_odp_vport_mod *ucompat)
 {
 	struct compat_odp_vport_mod compat;
 	struct odp_vport_mod vport_config;
@@ -323,8 +312,7 @@ compat_vport_user_mod(struct compat_odp_vport_mod *ucompat)
  * reasons, such as lack of memory.  This function is for userspace callers and
  * assumes no locks are held.
  */
-int
-vport_user_del(const char __user *udevname)
+int vport_user_del(const char __user *udevname)
 {
 	char devname[IFNAMSIZ];
 	struct vport *vport;
@@ -383,8 +371,7 @@ out:
  * Retrieves transmit, receive, and error stats for the given device.  This
  * function is for userspace callers and assumes no locks are held.
  */
-int
-vport_user_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;
@@ -403,56 +390,58 @@ vport_user_stats_get(struct odp_vport_stats_req __user *ustats_req)
 		goto out;
 	}
 
-	if (vport->ops->get_stats) {
-		rcu_read_lock();
-		err = vport->ops->get_stats(vport, &stats_req.stats);
-		rcu_read_unlock();
+	err = vport_get_stats(vport, &stats_req.stats);
 
-	} else if (vport->ops->flags & VPORT_F_GEN_STATS) {
-		int i;
+out:
+	vport_unlock();
 
-		memset(&stats_req.stats, 0, sizeof(struct odp_vport_stats));
+	if (!err)
+		if (copy_to_user(ustats_req, &stats_req, sizeof(struct odp_vport_stats_req)))
+			err = -EFAULT;
 
-		for_each_possible_cpu(i) {
-			const struct vport_percpu_stats *percpu_stats;
+	return err;
+}
 
-			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;
-		}
+/**
+ *	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;
 
-		spin_lock_bh(&vport->err_stats.lock);
+	if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
+		return -EFAULT;
 
-		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;
+	stats_req.devname[IFNAMSIZ - 1] = '\0';
 
-		spin_unlock_bh(&vport->err_stats.lock);
+	rtnl_lock();
+	vport_lock();
 
-		err = 0;
-	} else
-		err = -EOPNOTSUPP;
+	vport = vport_locate(stats_req.devname);
+	if (!vport) {
+		err = -ENODEV;
+		goto out;
+	}
+
+	err = vport_set_stats(vport, &stats_req.stats);
 
 out:
 	vport_unlock();
-
-	if (!err)
-		if (copy_to_user(ustats_req, &stats_req, sizeof(struct odp_vport_stats_req)))
-			err = -EFAULT;
-
+	rtnl_unlock();
 	return err;
 }
 
+
 /**
  *	vport_user_ether_get - retrieve device Ethernet address (for userspace callers)
  *
@@ -461,8 +450,7 @@ out:
  * Retrieves the Ethernet address of the given device.  This function is for
  * userspace callers and assumes no locks are held.
  */
-int
-vport_user_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;
@@ -505,8 +493,7 @@ out:
  * -EOPNOTSUPP.  This function is for userspace callers and assumes no locks
  * are held.
  */
-int
-vport_user_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;
@@ -542,8 +529,7 @@ out:
  * Retrieves the MTU of the given device.  This function is for userspace
  * callers and assumes no locks are held.
  */
-int
-vport_user_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;
@@ -583,8 +569,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_user_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;
@@ -612,8 +597,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)];
@@ -628,15 +612,14 @@ 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;
 	struct hlist_node *node;
 
 	if (unlikely(!mutex_is_locked(&vport_mutex) && !rtnl_is_locked())) {
-		printk(KERN_ERR "openvswitch: neither RTNL nor vport lock held in vport_locate\n");
+		pr_err("neither RTNL nor vport lock held in vport_locate\n");
 		dump_stack();
 	}
 
@@ -653,14 +636,12 @@ out:
 	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);
 }
@@ -676,8 +657,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;
@@ -699,7 +679,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;
@@ -712,8 +692,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);
@@ -732,8 +711,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;
@@ -770,8 +748,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();
@@ -791,8 +768,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();
@@ -814,14 +790,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;
 
@@ -833,7 +805,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;
@@ -847,8 +818,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;
 
@@ -858,7 +828,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)
@@ -877,8 +846,7 @@ 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();
 
@@ -912,8 +880,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();
 
@@ -926,6 +893,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 rtnl_link_stats64 *stats)
+{
+	ASSERT_RTNL();
+
+	if (vport->ops->flags & VPORT_F_GEN_STATS) {
+		spin_lock_bh(&vport->stats_lock);
+		vport->offset_stats = *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
  *
@@ -934,8 +928,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);
 }
@@ -948,8 +941,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;
 }
@@ -963,8 +955,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);
 }
@@ -978,8 +969,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);
 }
@@ -992,8 +982,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);
@@ -1001,6 +990,114 @@ 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 rtnl_link_stats64 *stats)
+{
+	struct rtnl_link_stats64 dev_stats;
+	struct rtnl_link_stats64 *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);
+
+		*stats = vport->offset_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_errors	+= vport->err_stats.rx_over_err;
+		stats->rx_crc_errors	+= vport->err_stats.rx_crc_err;
+		stats->rx_frame_errors	+= vport->err_stats.rx_frame_err;
+		stats->collisions	+= vport->err_stats.collisions;
+
+		spin_unlock_bh(&vport->stats_lock);
+
+		if (dev_statsp) {
+			stats->rx_packets          += dev_statsp->rx_packets;
+			stats->tx_packets          += dev_statsp->tx_packets;
+			stats->rx_bytes            += dev_statsp->rx_bytes;
+			stats->tx_bytes            += dev_statsp->tx_bytes;
+			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->multicast           += dev_statsp->multicast;
+			stats->collisions          += dev_statsp->collisions;
+			stats->rx_length_errors    += dev_statsp->rx_length_errors;
+			stats->rx_over_errors      += dev_statsp->rx_over_errors;
+			stats->rx_crc_errors       += dev_statsp->rx_crc_errors;
+			stats->rx_frame_errors     += dev_statsp->rx_frame_errors;
+			stats->rx_fifo_errors      += dev_statsp->rx_fifo_errors;
+			stats->rx_missed_errors    += dev_statsp->rx_missed_errors;
+			stats->tx_aborted_errors   += dev_statsp->tx_aborted_errors;
+			stats->tx_carrier_errors   += dev_statsp->tx_carrier_errors;
+			stats->tx_fifo_errors      += dev_statsp->tx_fifo_errors;
+			stats->tx_heartbeat_errors += dev_statsp->tx_heartbeat_errors;
+			stats->tx_window_errors    += dev_statsp->tx_window_errors;
+			stats->rx_compressed       += dev_statsp->rx_compressed;
+			stats->tx_compressed       += dev_statsp->tx_compressed;
+		}
+
+		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
  *
@@ -1009,8 +1106,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);
 }
@@ -1023,8 +1119,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);
 }
@@ -1037,8 +1132,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);
 }
@@ -1053,8 +1147,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;
 
@@ -1081,8 +1174,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);
@@ -1100,8 +1192,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);
 }
@@ -1116,8 +1207,7 @@ vport_get_mtu(const struct vport *vport)
  * 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);
 
@@ -1132,20 +1222,35 @@ vport_receive(struct vport *vport, struct sk_buff *skb)
 		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();
 	}
 
+	if (!(vport->ops->flags & VPORT_F_FLOW))
+		OVS_CB(skb)->flow = NULL;
+
 	if (!(vport->ops->flags & VPORT_F_TUN_ID))
 		OVS_CB(skb)->tun_id = 0;
 
 	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
  *
@@ -1155,26 +1260,42 @@ 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())
+			pr_warn("%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;
 }
 
 /**
@@ -1186,12 +1307,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:
@@ -1227,6 +1347,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);
 	}
 }