X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=datapath%2Fdatapath.c;h=87056cf8cafde32b7df541fcffa91c81123e250b;hb=b3e0370a37daeecc44ddaf03bbd98c2e8ff4513d;hp=15c1e33b2dc4be8a47385c35e8178418ad2071b7;hpb=36ce148c6d2105dc2e485ec169bcc9998ffebf9d;p=openvswitch

diff --git a/datapath/datapath.c b/datapath/datapath.c
index 15c1e33b..87056cf8 100644
--- a/datapath/datapath.c
+++ b/datapath/datapath.c
@@ -39,12 +39,12 @@
 #include <linux/netfilter_ipv4.h>
 #include <linux/inetdevice.h>
 #include <linux/list.h>
+#include <linux/openvswitch.h>
 #include <linux/rculist.h>
 #include <linux/dmi.h>
 #include <net/inet_ecn.h>
 #include <net/genetlink.h>
 
-#include "openvswitch/datapath-protocol.h"
 #include "checksum.h"
 #include "datapath.h"
 #include "actions.h"
@@ -54,8 +54,8 @@
 #include "vport-internal_dev.h"
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) || \
-    LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)
-#error Kernels before 2.6.18 or after 3.0 are not supported by this version of Open vSwitch.
+    LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
+#error Kernels before 2.6.18 or after 3.1 are not supported by this version of Open vSwitch.
 #endif
 
 int (*dp_ioctl_hook)(struct net_device *dev, struct ifreq *rq, int cmd);
@@ -68,8 +68,8 @@ EXPORT_SYMBOL(dp_ioctl_hook);
  * etc.) are protected by RTNL.
  *
  * Writes to other state (flow table modifications, set miscellaneous datapath
- * parameters such as drop frags, etc.) are protected by genl_mutex.  The RTNL
- * lock nests inside genl_mutex.
+ * parameters, etc.) are protected by genl_mutex.  The RTNL lock nests inside
+ * genl_mutex.
  *
  * Reads are protected by RCU.
  *
@@ -84,8 +84,10 @@ EXPORT_SYMBOL(dp_ioctl_hook);
 static LIST_HEAD(dps);
 
 static struct vport *new_vport(const struct vport_parms *);
-static int queue_userspace_packets(struct datapath *, u32 pid, struct sk_buff *,
-				 const struct dp_upcall_info *);
+static int queue_gso_packets(int dp_ifindex, struct sk_buff *,
+			     const struct dp_upcall_info *);
+static int queue_userspace_packet(int dp_ifindex, struct sk_buff *,
+				  const struct dp_upcall_info *);
 
 /* Must be called with rcu_read_lock, genl_mutex, or RTNL lock. */
 struct datapath *get_dp(int dp_ifindex)
@@ -280,29 +282,23 @@ void dp_process_received_packet(struct vport *p, struct sk_buff *skb)
 	struct datapath *dp = p->dp;
 	struct sw_flow *flow;
 	struct dp_stats_percpu *stats;
-	int stats_counter_off;
+	u64 *stats_counter;
 	int error;
 
+	stats = per_cpu_ptr(dp->stats_percpu, smp_processor_id());
 	OVS_CB(skb)->vport = p;
 
 	if (!OVS_CB(skb)->flow) {
 		struct sw_flow_key key;
 		int key_len;
-		bool is_frag;
 
 		/* Extract flow from 'skb' into 'key'. */
-		error = flow_extract(skb, p->port_no, &key, &key_len, &is_frag);
+		error = flow_extract(skb, p->port_no, &key, &key_len);
 		if (unlikely(error)) {
 			kfree_skb(skb);
 			return;
 		}
 
-		if (is_frag && dp->drop_frags) {
-			consume_skb(skb);
-			stats_counter_off = offsetof(struct dp_stats_percpu, n_frags);
-			goto out;
-		}
-
 		/* Look up flow. */
 		flow = flow_tbl_lookup(rcu_dereference(dp->table), &key, key_len);
 		if (unlikely(!flow)) {
@@ -310,29 +306,27 @@ void dp_process_received_packet(struct vport *p, struct sk_buff *skb)
 
 			upcall.cmd = OVS_PACKET_CMD_MISS;
 			upcall.key = &key;
+			upcall.userdata = NULL;
+			upcall.pid = p->upcall_pid;
 			dp_upcall(dp, skb, &upcall);
-			kfree_skb(skb);
-			stats_counter_off = offsetof(struct dp_stats_percpu, n_missed);
+			consume_skb(skb);
+			stats_counter = &stats->n_missed;
 			goto out;
 		}
 
 		OVS_CB(skb)->flow = flow;
 	}
 
-	stats_counter_off = offsetof(struct dp_stats_percpu, n_hit);
+	stats_counter = &stats->n_hit;
 	flow_used(OVS_CB(skb)->flow, skb);
 	execute_actions(dp, skb);
 
 out:
 	/* Update datapath statistics. */
-	local_bh_disable();
-	stats = per_cpu_ptr(dp->stats_percpu, smp_processor_id());
 
 	write_seqcount_begin(&stats->seqlock);
-	(*(u64 *)((u8 *)stats + stats_counter_off))++;
+	(*stats_counter)++;
 	write_seqcount_end(&stats->seqlock);
-
-	local_bh_enable();
 }
 
 static void copy_and_csum_skb(struct sk_buff *skb, void *to)
@@ -354,133 +348,140 @@ static struct genl_family dp_packet_genl_family = {
 	.id = GENL_ID_GENERATE,
 	.hdrsize = sizeof(struct ovs_header),
 	.name = OVS_PACKET_FAMILY,
-	.version = 1,
+	.version = OVS_PACKET_VERSION,
 	.maxattr = OVS_PACKET_ATTR_MAX
 };
 
 int dp_upcall(struct datapath *dp, struct sk_buff *skb,
 	      const struct dp_upcall_info *upcall_info)
 {
-	struct sk_buff *segs = NULL;
 	struct dp_stats_percpu *stats;
-	u32 pid;
+	int dp_ifindex;
 	int err;
 
-	if (OVS_CB(skb)->flow)
-		pid = OVS_CB(skb)->flow->upcall_pid;
-	else
-		pid = OVS_CB(skb)->vport->upcall_pid;
-
-	if (pid == 0) {
+	if (upcall_info->pid == 0) {
 		err = -ENOTCONN;
 		goto err;
 	}
 
-	forward_ip_summed(skb, true);
-
-	/* Break apart GSO packets into their component pieces.  Otherwise
-	 * userspace may try to stuff a 64kB packet into a 1500-byte MTU. */
-	if (skb_is_gso(skb)) {
-		segs = skb_gso_segment(skb, NETIF_F_SG | NETIF_F_HW_CSUM);
-		
-		if (IS_ERR(segs)) {
-			err = PTR_ERR(segs);
-			goto err;
-		}
-		skb = segs;
+	dp_ifindex = get_dpifindex(dp);
+	if (!dp_ifindex) {
+		err = -ENODEV;
+		goto err;
 	}
 
-	err = queue_userspace_packets(dp, pid, skb, upcall_info);
-	if (segs) {
-		struct sk_buff *next;
-		/* Free GSO-segments */
-		do {
-			next = segs->next;
-			kfree_skb(segs);
-		} while ((segs = next) != NULL);
-	}
+	forward_ip_summed(skb, true);
 
+	if (!skb_is_gso(skb))
+		err = queue_userspace_packet(dp_ifindex, skb, upcall_info);
+	else
+		err = queue_gso_packets(dp_ifindex, skb, upcall_info);
 	if (err)
 		goto err;
 
 	return 0;
 
 err:
-	local_bh_disable();
 	stats = per_cpu_ptr(dp->stats_percpu, smp_processor_id());
 
 	write_seqcount_begin(&stats->seqlock);
 	stats->n_lost++;
 	write_seqcount_end(&stats->seqlock);
 
-	local_bh_enable();
-
 	return err;
 }
 
-/* Send each packet in the 'skb' list to userspace for 'dp' as directed by
- * 'upcall_info'.  There will be only one packet unless we broke up a GSO
- * packet.
- */
-static int queue_userspace_packets(struct datapath *dp, u32 pid,
-				   struct sk_buff *skb,
-				   const struct dp_upcall_info *upcall_info)
+static int queue_gso_packets(int dp_ifindex, struct sk_buff *skb,
+			     const struct dp_upcall_info *upcall_info)
 {
-	int dp_ifindex;
+	struct dp_upcall_info later_info;
+	struct sw_flow_key later_key;
+	struct sk_buff *segs, *nskb;
+	int err;
 
-	dp_ifindex = get_dpifindex(dp);
-	if (!dp_ifindex)
-		return -ENODEV;
+	segs = skb_gso_segment(skb, NETIF_F_SG | NETIF_F_HW_CSUM);
+	if (IS_ERR(skb))
+		return PTR_ERR(skb);
 
+	/* Queue all of the segments. */
+	skb = segs;
 	do {
-		struct ovs_header *upcall;
-		struct sk_buff *user_skb; /* to be queued to userspace */
-		struct nlattr *nla;
-		unsigned int len;
-		int err;
-
-		err = vlan_deaccel_tag(skb);
-		if (unlikely(err))
-			return err;
-
-		if (nla_attr_size(skb->len) > USHRT_MAX)
-			return -EFBIG;
-
-		len = sizeof(struct ovs_header);
-		len += nla_total_size(skb->len);
-		len += nla_total_size(FLOW_BUFSIZE);
-		if (upcall_info->cmd == OVS_PACKET_CMD_ACTION)
-			len += nla_total_size(8);
-
-		user_skb = genlmsg_new(len, GFP_ATOMIC);
-		if (!user_skb)
-			return -ENOMEM;
-
-		upcall = genlmsg_put(user_skb, 0, 0, &dp_packet_genl_family,
-					 0, upcall_info->cmd);
-		upcall->dp_ifindex = dp_ifindex;
-
-		nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_KEY);
-		flow_to_nlattrs(upcall_info->key, user_skb);
-		nla_nest_end(user_skb, nla);
-
-		if (upcall_info->cmd == OVS_PACKET_CMD_ACTION)
-			nla_put_u64(user_skb, OVS_PACKET_ATTR_USERDATA,
-						upcall_info->userdata);
-
-		nla = __nla_reserve(user_skb, OVS_PACKET_ATTR_PACKET, skb->len);
-		if (skb->ip_summed == CHECKSUM_PARTIAL)
-			copy_and_csum_skb(skb, nla_data(nla));
-		else
-			skb_copy_bits(skb, 0, nla_data(nla), skb->len);
-
-		err = genlmsg_unicast(&init_net, user_skb, pid);
+		err = queue_userspace_packet(dp_ifindex, skb, upcall_info);
 		if (err)
-			return err;
+			break;
 
+		if (skb == segs && skb_shinfo(skb)->gso_type & SKB_GSO_UDP) {
+			/* The initial flow key extracted by flow_extract() in
+			 * this case is for a first fragment, so we need to
+			 * properly mark later fragments.
+			 */
+			later_key = *upcall_info->key;
+			later_key.ip.tos_frag &= ~OVS_FRAG_TYPE_MASK;
+			later_key.ip.tos_frag |= OVS_FRAG_TYPE_LATER;
+
+			later_info = *upcall_info;
+			later_info.key = &later_key;
+			upcall_info = &later_info;
+		}
 	} while ((skb = skb->next));
 
-	return 0;
+	/* Free all of the segments. */
+	skb = segs;
+	do {
+		nskb = skb->next;
+		if (err)
+			kfree_skb(skb);
+		else
+			consume_skb(skb);
+	} while ((skb = nskb));
+	return err;
+}
+
+static int queue_userspace_packet(int dp_ifindex, struct sk_buff *skb,
+				  const struct dp_upcall_info *upcall_info)
+{
+	struct ovs_header *upcall;
+	struct sk_buff *user_skb; /* to be queued to userspace */
+	struct nlattr *nla;
+	unsigned int len;
+	int err;
+
+	err = vlan_deaccel_tag(skb);
+	if (unlikely(err))
+		return err;
+
+	if (nla_attr_size(skb->len) > USHRT_MAX)
+		return -EFBIG;
+
+	len = sizeof(struct ovs_header);
+	len += nla_total_size(skb->len);
+	len += nla_total_size(FLOW_BUFSIZE);
+	if (upcall_info->cmd == OVS_PACKET_CMD_ACTION)
+		len += nla_total_size(8);
+
+	user_skb = genlmsg_new(len, GFP_ATOMIC);
+	if (!user_skb)
+		return -ENOMEM;
+
+	upcall = genlmsg_put(user_skb, 0, 0, &dp_packet_genl_family,
+			     0, upcall_info->cmd);
+	upcall->dp_ifindex = dp_ifindex;
+
+	nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_KEY);
+	flow_to_nlattrs(upcall_info->key, user_skb);
+	nla_nest_end(user_skb, nla);
+
+	if (upcall_info->userdata)
+		nla_put_u64(user_skb, OVS_PACKET_ATTR_USERDATA,
+			    nla_get_u64(upcall_info->userdata));
+
+	nla = __nla_reserve(user_skb, OVS_PACKET_ATTR_PACKET, skb->len);
+	if (skb->ip_summed == CHECKSUM_PARTIAL)
+		copy_and_csum_skb(skb, nla_data(nla));
+	else
+		skb_copy_bits(skb, 0, nla_data(nla), skb->len);
+
+	return genlmsg_unicast(&init_net, user_skb, upcall_info->pid);
 }
 
 /* Called with genl_mutex. */
@@ -505,31 +506,138 @@ static int flush_flows(int dp_ifindex)
 	return 0;
 }
 
-static int validate_actions(const struct nlattr *attr, int depth);
+static int validate_actions(const struct nlattr *attr,
+				const struct sw_flow_key *key, int depth);
 
-static int validate_sample(const struct nlattr *attr, int depth)
+static int validate_sample(const struct nlattr *attr,
+				const struct sw_flow_key *key, int depth)
 {
-	static const struct nla_policy sample_policy[OVS_SAMPLE_ATTR_MAX + 1] =
+	const struct nlattr *attrs[OVS_SAMPLE_ATTR_MAX + 1];
+	const struct nlattr *probability, *actions;
+	const struct nlattr *a;
+	int rem;
+
+	memset(attrs, 0, sizeof(attrs));
+	nla_for_each_nested (a, attr, rem) {
+		int type = nla_type(a);
+		if (!type || type > OVS_SAMPLE_ATTR_MAX || attrs[type])
+			return -EINVAL;
+		attrs[type] = a;
+	}
+	if (rem)
+		return -EINVAL;
+
+	probability = attrs[OVS_SAMPLE_ATTR_PROBABILITY];
+	if (!probability || nla_len(probability) != sizeof(u32))
+		return -EINVAL;
+
+	actions = attrs[OVS_SAMPLE_ATTR_ACTIONS];
+	if (!actions || (nla_len(actions) && nla_len(actions) < NLA_HDRLEN))
+		return -EINVAL;
+	return validate_actions(actions, key, depth + 1);
+}
+
+static int validate_action_key(const struct nlattr *a,
+				const struct sw_flow_key *flow_key)
+{
+	int act_type = nla_type(a);
+	const struct nlattr *ovs_key = nla_data(a);
+	int key_type = nla_type(ovs_key);
+
+	/* There can be only one key in a action */
+	if (nla_total_size(nla_len(ovs_key)) != nla_len(a))
+		return -EINVAL;
+
+	if (key_type > OVS_KEY_ATTR_MAX ||
+	    nla_len(ovs_key) != ovs_key_lens[key_type])
+		return -EINVAL;
+
+#define ACTION(act, key)	(((act) << 8) | (key))
+
+	switch(ACTION(act_type, key_type)) {
+	const struct ovs_key_ipv4 *ipv4_key;
+	const struct ovs_key_8021q *q_key;
+
+	case ACTION(OVS_ACTION_ATTR_SET, OVS_KEY_ATTR_PRIORITY):
+	case ACTION(OVS_ACTION_ATTR_SET, OVS_KEY_ATTR_TUN_ID):
+	case ACTION(OVS_ACTION_ATTR_SET, OVS_KEY_ATTR_ETHERNET):
+		break;
+
+	case ACTION(OVS_ACTION_ATTR_PUSH, OVS_KEY_ATTR_8021Q):
+		q_key = nla_data(ovs_key);
+		if (q_key->q_tpid != htons(ETH_P_8021Q))
+			return -EINVAL;
+
+		if (q_key->q_tci & htons(VLAN_TAG_PRESENT))
+			return -EINVAL;
+		break;
+
+	case ACTION(OVS_ACTION_ATTR_SET, OVS_KEY_ATTR_IPV4):
+		if (flow_key->eth.type != htons(ETH_P_IP))
+			return -EINVAL;
+
+		if (!flow_key->ipv4.addr.src || !flow_key->ipv4.addr.dst)
+			return -EINVAL;
+
+		ipv4_key = nla_data(ovs_key);
+		if (ipv4_key->ipv4_proto != flow_key->ip.proto)
+			return -EINVAL;
+
+		if (ipv4_key->ipv4_tos & INET_ECN_MASK)
+			return -EINVAL;
+
+		if (ipv4_key->ipv4_frag !=
+		    (flow_key->ip.tos_frag & OVS_FRAG_TYPE_MASK))
+			return -EINVAL;
+
+		break;
+
+	case ACTION(OVS_ACTION_ATTR_SET, OVS_KEY_ATTR_TCP):
+		if (flow_key->ip.proto != IPPROTO_TCP)
+			return -EINVAL;
+
+		if (!flow_key->ipv4.tp.src || !flow_key->ipv4.tp.dst)
+			return -EINVAL;
+
+		break;
+
+	case ACTION(OVS_ACTION_ATTR_SET, OVS_KEY_ATTR_UDP):
+		if (flow_key->ip.proto != IPPROTO_UDP)
+			return -EINVAL;
+
+		if (!flow_key->ipv4.tp.src || !flow_key->ipv4.tp.dst)
+			return -EINVAL;
+		break;
+
+	default:
+		return -EINVAL;
+	}
+#undef ACTION
+	return 0;
+}
+
+static int validate_userspace(const struct nlattr *attr)
+{
+	static const struct nla_policy userspace_policy[OVS_USERSPACE_ATTR_MAX + 1] =
 	{
-		[OVS_SAMPLE_ATTR_PROBABILITY] = {.type = NLA_U32 },
-		[OVS_SAMPLE_ATTR_ACTIONS] = {.type = NLA_UNSPEC },
+		[OVS_USERSPACE_ATTR_PID] = {.type = NLA_U32 },
+		[OVS_USERSPACE_ATTR_USERDATA] = {.type = NLA_U64 },
 	};
-	struct nlattr *a[OVS_SAMPLE_ATTR_MAX + 1];
+	struct nlattr *a[OVS_USERSPACE_ATTR_MAX + 1];
 	int error;
 
-	error = nla_parse_nested(a, OVS_SAMPLE_ATTR_MAX, attr, sample_policy);
+	error = nla_parse_nested(a, OVS_USERSPACE_ATTR_MAX, attr, userspace_policy);
 	if (error)
 		return error;
 
-	if (!a[OVS_SAMPLE_ATTR_PROBABILITY])
-		return -EINVAL;
-	if (!a[OVS_SAMPLE_ATTR_ACTIONS])
+	if (!a[OVS_USERSPACE_ATTR_PID] || !nla_get_u32(a[OVS_USERSPACE_ATTR_PID]))
 		return -EINVAL;
 
-	return validate_actions(a[OVS_SAMPLE_ATTR_ACTIONS], (depth + 1));
+	return 0;
 }
 
-static int validate_actions(const struct nlattr *attr, int depth)
+static int validate_actions(const struct nlattr *attr,
+				const struct sw_flow_key *key,  int depth)
 {
 	const struct nlattr *a;
 	int rem, err;
@@ -538,30 +646,20 @@ static int validate_actions(const struct nlattr *attr, int depth)
 		return -EOVERFLOW;
 
 	nla_for_each_nested(a, attr, rem) {
+		/* Expected argument lengths, (u32)-1 for variable length. */
 		static const u32 action_lens[OVS_ACTION_ATTR_MAX + 1] = {
 			[OVS_ACTION_ATTR_OUTPUT] = 4,
-			[OVS_ACTION_ATTR_USERSPACE] = 8,
-			[OVS_ACTION_ATTR_PUSH_VLAN] = 2,
-			[OVS_ACTION_ATTR_POP_VLAN] = 0,
-			[OVS_ACTION_ATTR_SET_DL_SRC] = ETH_ALEN,
-			[OVS_ACTION_ATTR_SET_DL_DST] = ETH_ALEN,
-			[OVS_ACTION_ATTR_SET_NW_SRC] = 4,
-			[OVS_ACTION_ATTR_SET_NW_DST] = 4,
-			[OVS_ACTION_ATTR_SET_NW_TOS] = 1,
-			[OVS_ACTION_ATTR_SET_TP_SRC] = 2,
-			[OVS_ACTION_ATTR_SET_TP_DST] = 2,
-			[OVS_ACTION_ATTR_SET_TUNNEL] = 8,
-			[OVS_ACTION_ATTR_SET_PRIORITY] = 4,
-			[OVS_ACTION_ATTR_POP_PRIORITY] = 0,
+			[OVS_ACTION_ATTR_USERSPACE] = (u32)-1,
+			[OVS_ACTION_ATTR_PUSH] = (u32)-1,
+			[OVS_ACTION_ATTR_POP] = 2,
+			[OVS_ACTION_ATTR_SET] = (u32)-1,
+			[OVS_ACTION_ATTR_SAMPLE] = (u32)-1
 		};
 		int type = nla_type(a);
 
-		/* Match expected attr len for given attr len except for
-		 * OVS_ACTION_ATTR_SAMPLE, as it has nested actions list which
-		 * is variable size. */
 		if (type > OVS_ACTION_ATTR_MAX ||
-		   (nla_len(a) != action_lens[type] &&
-			  type != OVS_ACTION_ATTR_SAMPLE))
+		    (action_lens[type] != nla_len(a) &&
+		     action_lens[type] != (u32)-1))
 			return -EINVAL;
 
 		switch (type) {
@@ -569,17 +667,9 @@ static int validate_actions(const struct nlattr *attr, int depth)
 			return -EINVAL;
 
 		case OVS_ACTION_ATTR_USERSPACE:
-		case OVS_ACTION_ATTR_POP_VLAN:
-		case OVS_ACTION_ATTR_SET_DL_SRC:
-		case OVS_ACTION_ATTR_SET_DL_DST:
-		case OVS_ACTION_ATTR_SET_NW_SRC:
-		case OVS_ACTION_ATTR_SET_NW_DST:
-		case OVS_ACTION_ATTR_SET_TP_SRC:
-		case OVS_ACTION_ATTR_SET_TP_DST:
-		case OVS_ACTION_ATTR_SET_TUNNEL:
-		case OVS_ACTION_ATTR_SET_PRIORITY:
-		case OVS_ACTION_ATTR_POP_PRIORITY:
-			/* No validation needed. */
+			err = validate_userspace(a);
+			if (err)
+				return err;
 			break;
 
 		case OVS_ACTION_ATTR_OUTPUT:
@@ -587,24 +677,27 @@ static int validate_actions(const struct nlattr *attr, int depth)
 				return -EINVAL;
 			break;
 
-		case OVS_ACTION_ATTR_PUSH_VLAN:
-			if (nla_get_be16(a) & htons(VLAN_CFI_MASK))
+
+		case OVS_ACTION_ATTR_POP:
+			if (nla_get_u16(a) != OVS_KEY_ATTR_8021Q)
 				return -EINVAL;
 			break;
 
-		case OVS_ACTION_ATTR_SET_NW_TOS:
-			if (nla_get_u8(a) & INET_ECN_MASK)
-				return -EINVAL;
+		case OVS_ACTION_ATTR_SET:
+		case OVS_ACTION_ATTR_PUSH:
+			err = validate_action_key(a, key);
+			if (err)
+				return err;
 			break;
 
 		case OVS_ACTION_ATTR_SAMPLE:
-			err = validate_sample(a, depth);
+			err = validate_sample(a, key, depth);
 			if (err)
 				return err;
 			break;
 
 		default:
-			return -EOPNOTSUPP;
+			return -EINVAL;
 		}
 	}
 
@@ -613,6 +706,7 @@ static int validate_actions(const struct nlattr *attr, int depth)
 
 	return 0;
 }
+
 static void clear_stats(struct sw_flow *flow)
 {
 	flow->used = 0;
@@ -630,7 +724,6 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
 	struct sw_flow *flow;
 	struct datapath *dp;
 	struct ethhdr *eth;
-	bool is_frag;
 	int len;
 	int err;
 	int key_len;
@@ -641,10 +734,6 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
 	    nla_len(a[OVS_PACKET_ATTR_PACKET]) < ETH_HLEN)
 		goto err;
 
-	err = validate_actions(a[OVS_PACKET_ATTR_ACTIONS], 0);
-	if (err)
-		goto err;
-
 	len = nla_len(a[OVS_PACKET_ATTR_PACKET]);
 	packet = __dev_alloc_skb(NET_IP_ALIGN + len, GFP_KERNEL);
 	err = -ENOMEM;
@@ -671,22 +760,22 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
 	if (IS_ERR(flow))
 		goto err_kfree_skb;
 
-	err = flow_extract(packet, -1, &flow->key, &key_len, &is_frag);
+	err = flow_extract(packet, -1, &flow->key, &key_len);
 	if (err)
 		goto err_flow_put;
 
-	err = flow_metadata_from_nlattrs(&flow->key.eth.in_port,
-					 &flow->key.eth.tun_id,
+	err = flow_metadata_from_nlattrs(&flow->key.phy.priority,
+					 &flow->key.phy.in_port,
+					 &flow->key.phy.tun_id,
 					 a[OVS_PACKET_ATTR_KEY]);
 	if (err)
 		goto err_flow_put;
 
-	flow->hash = flow_hash(&flow->key, key_len);
+	err = validate_actions(a[OVS_PACKET_ATTR_ACTIONS], &flow->key, 0);
+	if (err)
+		goto err_flow_put;
 
-	if (a[OVS_PACKET_ATTR_UPCALL_PID])
-		flow->upcall_pid = nla_get_u32(a[OVS_PACKET_ATTR_UPCALL_PID]);
-	else
-		flow->upcall_pid = NETLINK_CB(skb).pid;
+	flow->hash = flow_hash(&flow->key, key_len);
 
 	acts = flow_actions_alloc(a[OVS_PACKET_ATTR_ACTIONS]);
 	err = PTR_ERR(acts);
@@ -695,6 +784,7 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
 	rcu_assign_pointer(flow->sf_acts, acts);
 
 	OVS_CB(packet)->flow = flow;
+	packet->priority = flow->key.phy.priority;
 
 	rcu_read_lock();
 	dp = get_dp(ovs_header->dp_ifindex);
@@ -702,11 +792,13 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
 	if (!dp)
 		goto err_unlock;
 
-	if (flow->key.eth.in_port < DP_MAX_PORTS)
+	if (flow->key.phy.in_port < DP_MAX_PORTS)
 		OVS_CB(packet)->vport = get_vport_protected(dp,
-							flow->key.eth.in_port);
+							flow->key.phy.in_port);
 
+	local_bh_disable();
 	err = execute_actions(dp, packet);
+	local_bh_enable();
 	rcu_read_unlock();
 
 	flow_put(flow);
@@ -726,7 +818,6 @@ static const struct nla_policy packet_policy[OVS_PACKET_ATTR_MAX + 1] = {
 	[OVS_PACKET_ATTR_PACKET] = { .type = NLA_UNSPEC },
 	[OVS_PACKET_ATTR_KEY] = { .type = NLA_NESTED },
 	[OVS_PACKET_ATTR_ACTIONS] = { .type = NLA_NESTED },
-	[OVS_PACKET_ATTR_UPCALL_PID] = { .type = NLA_U32 },
 };
 
 static struct genl_ops dp_packet_genl_ops[] = {
@@ -744,7 +835,7 @@ static void get_dp_stats(struct datapath *dp, struct ovs_dp_stats *stats)
 
 	stats->n_flows = flow_tbl_count(table);
 
-	stats->n_frags = stats->n_hit = stats->n_missed = stats->n_lost = 0;
+	stats->n_hit = stats->n_missed = stats->n_lost = 0;
 	for_each_possible_cpu(i) {
 		const struct dp_stats_percpu *percpu_stats;
 		struct dp_stats_percpu local_stats;
@@ -757,7 +848,6 @@ static void get_dp_stats(struct datapath *dp, struct ovs_dp_stats *stats)
 			local_stats = *percpu_stats;
 		} while (read_seqcount_retry(&percpu_stats->seqlock, seqcount));
 
-		stats->n_frags += local_stats.n_frags;
 		stats->n_hit += local_stats.n_hit;
 		stats->n_missed += local_stats.n_missed;
 		stats->n_lost += local_stats.n_lost;
@@ -766,7 +856,6 @@ static void get_dp_stats(struct datapath *dp, struct ovs_dp_stats *stats)
 
 static const struct nla_policy flow_policy[OVS_FLOW_ATTR_MAX + 1] = {
 	[OVS_FLOW_ATTR_KEY] = { .type = NLA_NESTED },
-	[OVS_FLOW_ATTR_UPCALL_PID] = { .type = NLA_U32 },
 	[OVS_FLOW_ATTR_ACTIONS] = { .type = NLA_NESTED },
 	[OVS_FLOW_ATTR_CLEAR] = { .type = NLA_FLAG },
 };
@@ -775,7 +864,7 @@ static struct genl_family dp_flow_genl_family = {
 	.id = GENL_ID_GENERATE,
 	.hdrsize = sizeof(struct ovs_header),
 	.name = OVS_FLOW_FAMILY,
-	.version = 1,
+	.version = OVS_FLOW_VERSION,
 	.maxattr = OVS_FLOW_ATTR_MAX
 };
 
@@ -813,8 +902,6 @@ static int ovs_flow_cmd_fill_info(struct sw_flow *flow, struct datapath *dp,
 		goto error;
 	nla_nest_end(skb, nla);
 
-	NLA_PUT_U32(skb, OVS_FLOW_ATTR_UPCALL_PID, flow->upcall_pid);
-
 	spin_lock_bh(&flow->lock);
 	used = flow->used;
 	stats.n_packets = flow->packet_count;
@@ -908,7 +995,7 @@ static int ovs_flow_cmd_new_or_set(struct sk_buff *skb, struct genl_info *info)
 
 	/* Validate actions. */
 	if (a[OVS_FLOW_ATTR_ACTIONS]) {
-		error = validate_actions(a[OVS_FLOW_ATTR_ACTIONS], 0);
+		error = validate_actions(a[OVS_FLOW_ATTR_ACTIONS], &key,  0);
 		if (error)
 			goto error;
 	} else if (info->genlhdr->cmd == OVS_FLOW_CMD_NEW) {
@@ -952,11 +1039,6 @@ static int ovs_flow_cmd_new_or_set(struct sk_buff *skb, struct genl_info *info)
 		flow->key = key;
 		clear_stats(flow);
 
-		if (a[OVS_FLOW_ATTR_UPCALL_PID])
-			flow->upcall_pid = nla_get_u32(a[OVS_FLOW_ATTR_UPCALL_PID]);
-		else
-			flow->upcall_pid = NETLINK_CB(skb).pid;
-
 		/* Obtain actions. */
 		acts = flow_actions_alloc(a[OVS_FLOW_ATTR_ACTIONS]);
 		error = PTR_ERR(acts);
@@ -1006,9 +1088,6 @@ static int ovs_flow_cmd_new_or_set(struct sk_buff *skb, struct genl_info *info)
 		reply = ovs_flow_cmd_build_info(flow, dp, info->snd_pid,
 						info->snd_seq, OVS_FLOW_CMD_NEW);
 
-		if (a[OVS_FLOW_ATTR_UPCALL_PID])
-			flow->upcall_pid = nla_get_u32(a[OVS_FLOW_ATTR_UPCALL_PID]);
-
 		/* Clear stats. */
 		if (a[OVS_FLOW_ATTR_CLEAR]) {
 			spin_lock_bh(&flow->lock);
@@ -1168,14 +1247,13 @@ static const struct nla_policy datapath_policy[OVS_DP_ATTR_MAX + 1] = {
 	[OVS_DP_ATTR_NAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ - 1 },
 #endif
 	[OVS_DP_ATTR_UPCALL_PID] = { .type = NLA_U32 },
-	[OVS_DP_ATTR_IPV4_FRAGS] = { .type = NLA_U32 },
 };
 
 static struct genl_family dp_datapath_genl_family = {
 	.id = GENL_ID_GENERATE,
 	.hdrsize = sizeof(struct ovs_header),
 	.name = OVS_DATAPATH_FAMILY,
-	.version = 1,
+	.version = OVS_DATAPATH_VERSION,
 	.maxattr = OVS_DP_ATTR_MAX
 };
 
@@ -1208,9 +1286,6 @@ static int ovs_dp_cmd_fill_info(struct datapath *dp, struct sk_buff *skb,
 		goto nla_put_failure;
 	get_dp_stats(dp, nla_data(nla));
 
-	NLA_PUT_U32(skb, OVS_DP_ATTR_IPV4_FRAGS,
-		    dp->drop_frags ? OVS_DP_FRAG_DROP : OVS_DP_FRAG_ZERO);
-
 	return genlmsg_end(skb, ovs_header);
 
 nla_put_failure:
@@ -1239,13 +1314,6 @@ static struct sk_buff *ovs_dp_cmd_build_info(struct datapath *dp, u32 pid,
 
 static int ovs_dp_cmd_validate(struct nlattr *a[OVS_DP_ATTR_MAX + 1])
 {
-	if (a[OVS_DP_ATTR_IPV4_FRAGS]) {
-		u32 frags = nla_get_u32(a[OVS_DP_ATTR_IPV4_FRAGS]);
-
-		if (frags != OVS_DP_FRAG_ZERO && frags != OVS_DP_FRAG_DROP)
-			return -EINVAL;
-	}
-
 	return CHECK_NUL_STRING(a[OVS_DP_ATTR_NAME], IFNAMSIZ - 1);
 }
 
@@ -1267,13 +1335,6 @@ static struct datapath *lookup_datapath(struct ovs_header *ovs_header, struct nl
 	return dp ? dp : ERR_PTR(-ENODEV);
 }
 
-/* Called with genl_mutex. */
-static void change_datapath(struct datapath *dp, struct nlattr *a[OVS_DP_ATTR_MAX + 1])
-{
-	if (a[OVS_DP_ATTR_IPV4_FRAGS])
-		dp->drop_frags = nla_get_u32(a[OVS_DP_ATTR_IPV4_FRAGS]) == OVS_DP_FRAG_DROP;
-}
-
 static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info)
 {
 	struct nlattr **a = info->attrs;
@@ -1284,7 +1345,7 @@ static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info)
 	int err;
 
 	err = -EINVAL;
-	if (!a[OVS_DP_ATTR_NAME])
+	if (!a[OVS_DP_ATTR_NAME] || !a[OVS_DP_ATTR_UPCALL_PID])
 		goto err;
 
 	err = ovs_dp_cmd_validate(a);
@@ -1313,25 +1374,19 @@ static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info)
 	if (!dp->table)
 		goto err_free_dp;
 
-	dp->drop_frags = 0;
 	dp->stats_percpu = alloc_percpu(struct dp_stats_percpu);
 	if (!dp->stats_percpu) {
 		err = -ENOMEM;
 		goto err_destroy_table;
 	}
 
-	change_datapath(dp, a);
-
 	/* Set up our datapath device. */
 	parms.name = nla_data(a[OVS_DP_ATTR_NAME]);
 	parms.type = OVS_VPORT_TYPE_INTERNAL;
 	parms.options = NULL;
 	parms.dp = dp;
 	parms.port_no = OVSP_LOCAL;
-	if (a[OVS_DP_ATTR_UPCALL_PID])
-		parms.upcall_pid = nla_get_u32(a[OVS_DP_ATTR_UPCALL_PID]);
-	else
-		parms.upcall_pid = NETLINK_CB(skb).pid;
+	parms.upcall_pid = nla_get_u32(a[OVS_DP_ATTR_UPCALL_PID]);
 
 	vport = new_vport(&parms);
 	if (IS_ERR(vport)) {
@@ -1437,8 +1492,6 @@ static int ovs_dp_cmd_set(struct sk_buff *skb, struct genl_info *info)
 	if (IS_ERR(dp))
 		return PTR_ERR(dp);
 
-	change_datapath(dp, info->attrs);
-
 	reply = ovs_dp_cmd_build_info(dp, info->snd_pid, info->snd_seq, OVS_DP_CMD_NEW);
 	if (IS_ERR(reply)) {
 		err = PTR_ERR(reply);
@@ -1537,7 +1590,7 @@ static struct genl_family dp_vport_genl_family = {
 	.id = GENL_ID_GENERATE,
 	.hdrsize = sizeof(struct ovs_header),
 	.name = OVS_VPORT_FAMILY,
-	.version = 1,
+	.version = OVS_VPORT_VERSION,
 	.maxattr = OVS_VPORT_ATTR_MAX
 };
 
@@ -1551,7 +1604,6 @@ static int ovs_vport_cmd_fill_info(struct vport *vport, struct sk_buff *skb,
 {
 	struct ovs_header *ovs_header;
 	struct nlattr *nla;
-	int ifindex;
 	int err;
 
 	ovs_header = genlmsg_put(skb, pid, seq, &dp_vport_genl_family,
@@ -1578,10 +1630,6 @@ static int ovs_vport_cmd_fill_info(struct vport *vport, struct sk_buff *skb,
 	if (err == -EMSGSIZE)
 		goto error;
 
-	ifindex = vport_get_ifindex(vport);
-	if (ifindex > 0)
-		NLA_PUT_U32(skb, OVS_VPORT_ATTR_IFINDEX, ifindex);
-
 	return genlmsg_end(skb, ovs_header);
 
 nla_put_failure:
@@ -1671,7 +1719,8 @@ static int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info)
 	int err;
 
 	err = -EINVAL;
-	if (!a[OVS_VPORT_ATTR_NAME] || !a[OVS_VPORT_ATTR_TYPE])
+	if (!a[OVS_VPORT_ATTR_NAME] || !a[OVS_VPORT_ATTR_TYPE] ||
+	    !a[OVS_VPORT_ATTR_UPCALL_PID])
 		goto exit;
 
 	err = ovs_vport_cmd_validate(a);
@@ -1712,10 +1761,7 @@ static int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info)
 	parms.options = a[OVS_VPORT_ATTR_OPTIONS];
 	parms.dp = dp;
 	parms.port_no = port_no;
-	if (a[OVS_VPORT_ATTR_UPCALL_PID])
-		parms.upcall_pid = nla_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]);
-	else
-		parms.upcall_pid = NETLINK_CB(skb).pid;
+	parms.upcall_pid = nla_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]);
 
 	vport = new_vport(&parms);
 	err = PTR_ERR(vport);
@@ -1763,7 +1809,9 @@ static int ovs_vport_cmd_set(struct sk_buff *skb, struct genl_info *info)
 		goto exit_unlock;
 
 	err = 0;
-	if (a[OVS_VPORT_ATTR_OPTIONS])
+	if (a[OVS_VPORT_ATTR_TYPE] && nla_get_u32(a[OVS_VPORT_ATTR_TYPE]) != vport_get_type(vport))
+		err = -EINVAL;
+	if (!err && a[OVS_VPORT_ATTR_OPTIONS])
 		err = vport_set_options(vport, a[OVS_VPORT_ATTR_OPTIONS]);
 	if (!err)
 		err = change_vport(vport, a);