Merge branch 'net_next_ovs' of git://git.kernel.org/pub/scm/linux/kernel/git/pshelar/openvswitch (2d9d65fa) · Commits · 戴 / test

include/uapi/linux/openvswitch.h

+26 −0

Original line number	Original line	Diff line number	Diff line
	@@ -289,6 +289,9 @@ enum ovs_key_attr {
	OVS_KEY_ATTR_TUNNEL, /* Nested set of ovs_tunnel attributes */		OVS_KEY_ATTR_TUNNEL, /* Nested set of ovs_tunnel attributes */
	OVS_KEY_ATTR_SCTP, /* struct ovs_key_sctp */		OVS_KEY_ATTR_SCTP, /* struct ovs_key_sctp */
	OVS_KEY_ATTR_TCP_FLAGS, /* be16 TCP flags. */		OVS_KEY_ATTR_TCP_FLAGS, /* be16 TCP flags. */
			OVS_KEY_ATTR_DP_HASH, /* u32 hash value. Value 0 indicates the hash
			is not computed by the datapath. */
			OVS_KEY_ATTR_RECIRC_ID, /* u32 recirc id */

	#ifdef __KERNEL__		#ifdef __KERNEL__
	OVS_KEY_ATTR_IPV4_TUNNEL, /* struct ovs_key_ipv4_tunnel */		OVS_KEY_ATTR_IPV4_TUNNEL, /* struct ovs_key_ipv4_tunnel */
	@@ -493,6 +496,27 @@ struct ovs_action_push_vlan {
	__be16 vlan_tci; /* 802.1Q TCI (VLAN ID and priority). */		__be16 vlan_tci; /* 802.1Q TCI (VLAN ID and priority). */
	};		};

			/* Data path hash algorithm for computing Datapath hash.
			*
			* The algorithm type only specifies the fields in a flow
			* will be used as part of the hash. Each datapath is free
			* to use its own hash algorithm. The hash value will be
			* opaque to the user space daemon.
			*/
			enum ovs_hash_alg {
			OVS_HASH_ALG_L4,
			};

			/*
			* struct ovs_action_hash - %OVS_ACTION_ATTR_HASH action argument.
			* @hash_alg: Algorithm used to compute hash prior to recirculation.
			* @hash_basis: basis used for computing hash.
			*/
			struct ovs_action_hash {
			uint32_t hash_alg; /* One of ovs_hash_alg. */
			uint32_t hash_basis;
			};

	/**		/**
	* enum ovs_action_attr - Action types.		* enum ovs_action_attr - Action types.
	*		*
	@@ -521,6 +545,8 @@ enum ovs_action_attr {
	OVS_ACTION_ATTR_PUSH_VLAN, /* struct ovs_action_push_vlan. */		OVS_ACTION_ATTR_PUSH_VLAN, /* struct ovs_action_push_vlan. */
	OVS_ACTION_ATTR_POP_VLAN, /* No argument. */		OVS_ACTION_ATTR_POP_VLAN, /* No argument. */
	OVS_ACTION_ATTR_SAMPLE, /* Nested OVS_SAMPLE_ATTR_. /		OVS_ACTION_ATTR_SAMPLE, /* Nested OVS_SAMPLE_ATTR_. /
			OVS_ACTION_ATTR_RECIRC, /* u32 recirc_id. */
			OVS_ACTION_ATTR_HASH, /* struct ovs_action_hash. */
	__OVS_ACTION_ATTR_MAX		__OVS_ACTION_ATTR_MAX
	};		};

net/openvswitch/actions.c

+222 −36

Original line number	Original line	Diff line number	Diff line
	/*		/*
	* Copyright (c) 2007-2013 Nicira, Inc.		* Copyright (c) 2007-2014 Nicira, Inc.
	*		*
	* This program is free software; you can redistribute it and/or		* This program is free software; you can redistribute it and/or
	* modify it under the terms of version 2 of the GNU General Public		* modify it under the terms of version 2 of the GNU General Public
	@@ -35,11 +35,78 @@
	#include <net/sctp/checksum.h>		#include <net/sctp/checksum.h>

	#include "datapath.h"		#include "datapath.h"
			#include "flow.h"
	#include "vport.h"		#include "vport.h"

	static int do_execute_actions(struct datapath dp, struct sk_buff skb,		static int do_execute_actions(struct datapath dp, struct sk_buff skb,
			struct sw_flow_key *key,
	const struct nlattr *attr, int len);		const struct nlattr *attr, int len);

			struct deferred_action {
			struct sk_buff *skb;
			const struct nlattr *actions;

			/* Store pkt_key clone when creating deferred action. */
			struct sw_flow_key pkt_key;
			};

			#define DEFERRED_ACTION_FIFO_SIZE 10
			struct action_fifo {
			int head;
			int tail;
			/* Deferred action fifo queue storage. */
			struct deferred_action fifo[DEFERRED_ACTION_FIFO_SIZE];
			};

			static struct action_fifo __percpu *action_fifos;
			static DEFINE_PER_CPU(int, exec_actions_level);

			static void action_fifo_init(struct action_fifo *fifo)
			{
			fifo->head = 0;
			fifo->tail = 0;
			}

			static bool action_fifo_is_empty(struct action_fifo *fifo)
			{
			return (fifo->head == fifo->tail);
			}

			static struct deferred_action action_fifo_get(struct action_fifo fifo)
			{
			if (action_fifo_is_empty(fifo))
			return NULL;

			return &fifo->fifo[fifo->tail++];
			}

			static struct deferred_action action_fifo_put(struct action_fifo fifo)
			{
			if (fifo->head >= DEFERRED_ACTION_FIFO_SIZE - 1)
			return NULL;

			return &fifo->fifo[fifo->head++];
			}

			/* Return true if fifo is not full */
			static struct deferred_action add_deferred_actions(struct sk_buff skb,
			struct sw_flow_key *key,
			const struct nlattr *attr)
			{
			struct action_fifo *fifo;
			struct deferred_action *da;

			fifo = this_cpu_ptr(action_fifos);
			da = action_fifo_put(fifo);
			if (da) {
			da->skb = skb;
			da->actions = attr;
			da->pkt_key = *key;
			}

			return da;
			}

	static int make_writable(struct sk_buff *skb, int write_len)		static int make_writable(struct sk_buff *skb, int write_len)
	{		{
	if (!pskb_may_pull(skb, write_len))		if (!pskb_may_pull(skb, write_len))
	@@ -410,16 +477,14 @@ static int do_output(struct datapath dp, struct sk_buff skb, int out_port)
	}		}

	static int output_userspace(struct datapath dp, struct sk_buff skb,		static int output_userspace(struct datapath dp, struct sk_buff skb,
	const struct nlattr *attr)		struct sw_flow_key key, const struct nlattr attr)
	{		{
	struct dp_upcall_info upcall;		struct dp_upcall_info upcall;
	const struct nlattr *a;		const struct nlattr *a;
	int rem;		int rem;

	BUG_ON(!OVS_CB(skb)->pkt_key);

	upcall.cmd = OVS_PACKET_CMD_ACTION;		upcall.cmd = OVS_PACKET_CMD_ACTION;
	upcall.key = OVS_CB(skb)->pkt_key;		upcall.key = key;
	upcall.userdata = NULL;		upcall.userdata = NULL;
	upcall.portid = 0;		upcall.portid = 0;

	@@ -445,11 +510,10 @@ static bool last_action(const struct nlattr *a, int rem)
	}		}

	static int sample(struct datapath dp, struct sk_buff skb,		static int sample(struct datapath dp, struct sk_buff skb,
	const struct nlattr *attr)		struct sw_flow_key key, const struct nlattr attr)
	{		{
	const struct nlattr *acts_list = NULL;		const struct nlattr *acts_list = NULL;
	const struct nlattr *a;		const struct nlattr *a;
	struct sk_buff *sample_skb;
	int rem;		int rem;

	for (a = nla_data(attr), rem = nla_len(attr); rem > 0;		for (a = nla_data(attr), rem = nla_len(attr); rem > 0;
	@@ -469,31 +533,47 @@ static int sample(struct datapath dp, struct sk_buff skb,
	rem = nla_len(acts_list);		rem = nla_len(acts_list);
	a = nla_data(acts_list);		a = nla_data(acts_list);

	/* Actions list is either empty or only contains a single user-space		/* Actions list is empty, do nothing */
	* action, the latter being a special case as it is the only known		if (unlikely(!rem))
	* usage of the sample action.		return 0;
	* In these special cases don't clone the skb as there are no
	* side-effects in the nested actions.		/* The only known usage of sample action is having a single user-space
	* Otherwise, clone in case the nested actions have side effects.		* action. Treat this usage as a special case.
			* The output_userspace() should clone the skb to be sent to the
			* user space. This skb will be consumed by its caller.
	*/		*/
	if (likely(rem == 0 \|\| (nla_type(a) == OVS_ACTION_ATTR_USERSPACE &&		if (likely(nla_type(a) == OVS_ACTION_ATTR_USERSPACE &&
	last_action(a, rem)))) {		last_action(a, rem)))
	sample_skb = skb;		return output_userspace(dp, skb, key, a);
	skb_get(skb);
	} else {		skb = skb_clone(skb, GFP_ATOMIC);
	sample_skb = skb_clone(skb, GFP_ATOMIC);		if (!skb)
	if (!sample_skb) /* Skip sample action when out of memory. */		/* Skip the sample action when out of memory. */
			return 0;

			if (!add_deferred_actions(skb, key, a)) {
			if (net_ratelimit())
			pr_warn("%s: deferred actions limit reached, dropping sample action\n",
			ovs_dp_name(dp));

			kfree_skb(skb);
			}
	return 0;		return 0;
	}		}

	/* Note that do_execute_actions() never consumes skb.		static void execute_hash(struct sk_buff skb, struct sw_flow_key key,
	* In the case where skb has been cloned above it is the clone that		const struct nlattr *attr)
	* is consumed. Otherwise the skb_get(skb) call prevents		{
	* consumption by do_execute_actions(). Thus, it is safe to simply		struct ovs_action_hash *hash_act = nla_data(attr);
	* return the error code and let the caller (also		u32 hash = 0;
	* do_execute_actions()) free skb on error.
	*/		/* OVS_HASH_ALG_L4 is the only possible hash algorithm. */
	return do_execute_actions(dp, sample_skb, a, rem);		hash = skb_get_hash(skb);
			hash = jhash_1word(hash, hash_act->hash_basis);
			if (!hash)
			hash = 0x1;

			key->ovs_flow_hash = hash;
	}		}

	static int execute_set_action(struct sk_buff *skb,		static int execute_set_action(struct sk_buff *skb,
	@@ -511,7 +591,7 @@ static int execute_set_action(struct sk_buff *skb,
	break;		break;

	case OVS_KEY_ATTR_IPV4_TUNNEL:		case OVS_KEY_ATTR_IPV4_TUNNEL:
	OVS_CB(skb)->tun_key = nla_data(nested_attr);		OVS_CB(skb)->egress_tun_key = nla_data(nested_attr);
	break;		break;

	case OVS_KEY_ATTR_ETHERNET:		case OVS_KEY_ATTR_ETHERNET:
	@@ -542,8 +622,47 @@ static int execute_set_action(struct sk_buff *skb,
	return err;		return err;
	}		}

			static int execute_recirc(struct datapath dp, struct sk_buff skb,
			struct sw_flow_key *key,
			const struct nlattr *a, int rem)
			{
			struct deferred_action *da;
			int err;

			err = ovs_flow_key_update(skb, key);
			if (err)
			return err;

			if (!last_action(a, rem)) {
			/* Recirc action is the not the last action
			* of the action list, need to clone the skb.
			*/
			skb = skb_clone(skb, GFP_ATOMIC);

			/* Skip the recirc action when out of memory, but
			* continue on with the rest of the action list.
			*/
			if (!skb)
			return 0;
			}

			da = add_deferred_actions(skb, key, NULL);
			if (da) {
			da->pkt_key.recirc_id = nla_get_u32(a);
			} else {
			kfree_skb(skb);

			if (net_ratelimit())
			pr_warn("%s: deferred action limit reached, drop recirc action\n",
			ovs_dp_name(dp));
			}

			return 0;
			}

	/* Execute a list of actions against 'skb'. */		/* Execute a list of actions against 'skb'. */
	static int do_execute_actions(struct datapath dp, struct sk_buff skb,		static int do_execute_actions(struct datapath dp, struct sk_buff skb,
			struct sw_flow_key *key,
	const struct nlattr *attr, int len)		const struct nlattr *attr, int len)
	{		{
	/* Every output action needs a separate clone of 'skb', but the common		/* Every output action needs a separate clone of 'skb', but the common
	@@ -569,7 +688,11 @@ static int do_execute_actions(struct datapath dp, struct sk_buff skb,
	break;		break;

	case OVS_ACTION_ATTR_USERSPACE:		case OVS_ACTION_ATTR_USERSPACE:
	output_userspace(dp, skb, a);		output_userspace(dp, skb, key, a);
			break;

			case OVS_ACTION_ATTR_HASH:
			execute_hash(skb, key, a);
	break;		break;

	case OVS_ACTION_ATTR_PUSH_VLAN:		case OVS_ACTION_ATTR_PUSH_VLAN:
	@@ -582,12 +705,23 @@ static int do_execute_actions(struct datapath dp, struct sk_buff skb,
	err = pop_vlan(skb);		err = pop_vlan(skb);
	break;		break;

			case OVS_ACTION_ATTR_RECIRC:
			err = execute_recirc(dp, skb, key, a, rem);
			if (last_action(a, rem)) {
			/* If this is the last action, the skb has
			* been consumed or freed.
			* Return immediately.
			*/
			return err;
			}
			break;

	case OVS_ACTION_ATTR_SET:		case OVS_ACTION_ATTR_SET:
	err = execute_set_action(skb, nla_data(a));		err = execute_set_action(skb, nla_data(a));
	break;		break;

	case OVS_ACTION_ATTR_SAMPLE:		case OVS_ACTION_ATTR_SAMPLE:
	err = sample(dp, skb, a);		err = sample(dp, skb, key, a);
	if (unlikely(err)) /* skb already freed. */		if (unlikely(err)) /* skb already freed. */
	return err;		return err;
	break;		break;
	@@ -607,11 +741,63 @@ static int do_execute_actions(struct datapath dp, struct sk_buff skb,
	return 0;		return 0;
	}		}

			static void process_deferred_actions(struct datapath *dp)
			{
			struct action_fifo *fifo = this_cpu_ptr(action_fifos);

			/* Do not touch the FIFO in case there is no deferred actions. */
			if (action_fifo_is_empty(fifo))
			return;

			/* Finishing executing all deferred actions. */
			do {
			struct deferred_action *da = action_fifo_get(fifo);
			struct sk_buff *skb = da->skb;
			struct sw_flow_key *key = &da->pkt_key;
			const struct nlattr *actions = da->actions;

			if (actions)
			do_execute_actions(dp, skb, key, actions,
			nla_len(actions));
			else
			ovs_dp_process_packet(skb, key);
			} while (!action_fifo_is_empty(fifo));

			/* Reset FIFO for the next packet. */
			action_fifo_init(fifo);
			}

	/* Execute a list of actions against 'skb'. */		/* Execute a list of actions against 'skb'. */
	int ovs_execute_actions(struct datapath dp, struct sk_buff skb)		int ovs_execute_actions(struct datapath dp, struct sk_buff skb,
			struct sw_flow_key *key)
			{
			int level = this_cpu_read(exec_actions_level);
			struct sw_flow_actions *acts;
			int err;

			acts = rcu_dereference(OVS_CB(skb)->flow->sf_acts);

			this_cpu_inc(exec_actions_level);
			err = do_execute_actions(dp, skb, key,
			acts->actions, acts->actions_len);

			if (!level)
			process_deferred_actions(dp);

			this_cpu_dec(exec_actions_level);
			return err;
			}

			int action_fifos_init(void)
	{		{
	struct sw_flow_actions *acts = rcu_dereference(OVS_CB(skb)->flow->sf_acts);		action_fifos = alloc_percpu(struct action_fifo);
			if (!action_fifos)
			return -ENOMEM;

	OVS_CB(skb)->tun_key = NULL;		return 0;
	return do_execute_actions(dp, skb, acts->actions, acts->actions_len);		}

			void action_fifos_exit(void)
			{
			free_percpu(action_fifos);
	}		}

net/openvswitch/datapath.c

+29 −23

Original line number	Original line	Diff line number	Diff line
	@@ -156,7 +156,7 @@ static struct datapath get_dp(struct net net, int dp_ifindex)
	}		}

	/* Must be called with rcu_read_lock or ovs_mutex. */		/* Must be called with rcu_read_lock or ovs_mutex. */
	static const char ovs_dp_name(const struct datapath dp)		const char ovs_dp_name(const struct datapath dp)
	{		{
	struct vport *vport = ovs_vport_ovsl_rcu(dp, OVSP_LOCAL);		struct vport *vport = ovs_vport_ovsl_rcu(dp, OVSP_LOCAL);
	return vport->ops->get_name(vport);		return vport->ops->get_name(vport);
	@@ -237,32 +237,25 @@ void ovs_dp_detach_port(struct vport *p)
	}		}

	/* Must be called with rcu_read_lock. */		/* Must be called with rcu_read_lock. */
	void ovs_dp_process_received_packet(struct vport p, struct sk_buff skb)		void ovs_dp_process_packet(struct sk_buff skb, struct sw_flow_key key)
	{		{
			const struct vport *p = OVS_CB(skb)->input_vport;
	struct datapath *dp = p->dp;		struct datapath *dp = p->dp;
	struct sw_flow *flow;		struct sw_flow *flow;
	struct dp_stats_percpu *stats;		struct dp_stats_percpu *stats;
	struct sw_flow_key key;
	u64 *stats_counter;		u64 *stats_counter;
	u32 n_mask_hit;		u32 n_mask_hit;
	int error;

	stats = this_cpu_ptr(dp->stats_percpu);		stats = this_cpu_ptr(dp->stats_percpu);

	/* Extract flow from 'skb' into 'key'. */
	error = ovs_flow_extract(skb, p->port_no, &key);
	if (unlikely(error)) {
	kfree_skb(skb);
	return;
	}

	/* Look up flow. */		/* Look up flow. */
	flow = ovs_flow_tbl_lookup_stats(&dp->table, &key, &n_mask_hit);		flow = ovs_flow_tbl_lookup_stats(&dp->table, key, &n_mask_hit);
	if (unlikely(!flow)) {		if (unlikely(!flow)) {
	struct dp_upcall_info upcall;		struct dp_upcall_info upcall;
			int error;

	upcall.cmd = OVS_PACKET_CMD_MISS;		upcall.cmd = OVS_PACKET_CMD_MISS;
	upcall.key = &key;		upcall.key = key;
	upcall.userdata = NULL;		upcall.userdata = NULL;
	upcall.portid = ovs_vport_find_upcall_portid(p, skb);		upcall.portid = ovs_vport_find_upcall_portid(p, skb);
	error = ovs_dp_upcall(dp, skb, &upcall);		error = ovs_dp_upcall(dp, skb, &upcall);
	@@ -275,10 +268,9 @@ void ovs_dp_process_received_packet(struct vport p, struct sk_buff skb)
	}		}

	OVS_CB(skb)->flow = flow;		OVS_CB(skb)->flow = flow;
	OVS_CB(skb)->pkt_key = &key;

	ovs_flow_stats_update(OVS_CB(skb)->flow, key.tp.flags, skb);		ovs_flow_stats_update(OVS_CB(skb)->flow, key->tp.flags, skb);
	ovs_execute_actions(dp, skb);		ovs_execute_actions(dp, skb, key);
	stats_counter = &stats->n_hit;		stats_counter = &stats->n_hit;

	out:		out:
	@@ -515,6 +507,7 @@ static int ovs_packet_cmd_execute(struct sk_buff skb, struct genl_info info)
	struct sw_flow *flow;		struct sw_flow *flow;
	struct datapath *dp;		struct datapath *dp;
	struct ethhdr *eth;		struct ethhdr *eth;
			struct vport *input_vport;
	int len;		int len;
	int err;		int err;

	@@ -549,13 +542,11 @@ static int ovs_packet_cmd_execute(struct sk_buff skb, struct genl_info info)
	if (IS_ERR(flow))		if (IS_ERR(flow))
	goto err_kfree_skb;		goto err_kfree_skb;

	err = ovs_flow_extract(packet, -1, &flow->key);		err = ovs_flow_key_extract_userspace(a[OVS_PACKET_ATTR_KEY], packet,
			&flow->key);
	if (err)		if (err)
	goto err_flow_free;		goto err_flow_free;

	err = ovs_nla_get_flow_metadata(flow, a[OVS_PACKET_ATTR_KEY]);
	if (err)
	goto err_flow_free;
	acts = ovs_nla_alloc_flow_actions(nla_len(a[OVS_PACKET_ATTR_ACTIONS]));		acts = ovs_nla_alloc_flow_actions(nla_len(a[OVS_PACKET_ATTR_ACTIONS]));
	err = PTR_ERR(acts);		err = PTR_ERR(acts);
	if (IS_ERR(acts))		if (IS_ERR(acts))
	@@ -568,7 +559,6 @@ static int ovs_packet_cmd_execute(struct sk_buff skb, struct genl_info info)
	goto err_flow_free;		goto err_flow_free;

	OVS_CB(packet)->flow = flow;		OVS_CB(packet)->flow = flow;
	OVS_CB(packet)->pkt_key = &flow->key;
	packet->priority = flow->key.phy.priority;		packet->priority = flow->key.phy.priority;
	packet->mark = flow->key.phy.skb_mark;		packet->mark = flow->key.phy.skb_mark;

	@@ -578,8 +568,17 @@ static int ovs_packet_cmd_execute(struct sk_buff skb, struct genl_info info)
	if (!dp)		if (!dp)
	goto err_unlock;		goto err_unlock;

			input_vport = ovs_vport_rcu(dp, flow->key.phy.in_port);
			if (!input_vport)
			input_vport = ovs_vport_rcu(dp, OVSP_LOCAL);

			if (!input_vport)
			goto err_unlock;

			OVS_CB(packet)->input_vport = input_vport;

	local_bh_disable();		local_bh_disable();
	err = ovs_execute_actions(dp, packet);		err = ovs_execute_actions(dp, packet, &flow->key);
	local_bh_enable();		local_bh_enable();
	rcu_read_unlock();		rcu_read_unlock();

	@@ -2066,10 +2065,14 @@ static int __init dp_init(void)

	pr_info("Open vSwitch switching datapath\n");		pr_info("Open vSwitch switching datapath\n");

	err = ovs_internal_dev_rtnl_link_register();		err = action_fifos_init();
	if (err)		if (err)
	goto error;		goto error;

			err = ovs_internal_dev_rtnl_link_register();
			if (err)
			goto error_action_fifos_exit;

	err = ovs_flow_init();		err = ovs_flow_init();
	if (err)		if (err)
	goto error_unreg_rtnl_link;		goto error_unreg_rtnl_link;
	@@ -2102,6 +2105,8 @@ error_flow_exit:
	ovs_flow_exit();		ovs_flow_exit();
	error_unreg_rtnl_link:		error_unreg_rtnl_link:
	ovs_internal_dev_rtnl_link_unregister();		ovs_internal_dev_rtnl_link_unregister();
			error_action_fifos_exit:
			action_fifos_exit();
	error:		error:
	return err;		return err;
	}		}
	@@ -2115,6 +2120,7 @@ static void dp_cleanup(void)
	ovs_vport_exit();		ovs_vport_exit();
	ovs_flow_exit();		ovs_flow_exit();
	ovs_internal_dev_rtnl_link_unregister();		ovs_internal_dev_rtnl_link_unregister();
			action_fifos_exit();
	}		}

	module_init(dp_init);		module_init(dp_init);

net/openvswitch/datapath.h

+15 −8

Original line number	Original line	Diff line number	Diff line
	/*		/*
	* Copyright (c) 2007-2012 Nicira, Inc.		* Copyright (c) 2007-2014 Nicira, Inc.
	*		*
	* This program is free software; you can redistribute it and/or		* This program is free software; you can redistribute it and/or
	* modify it under the terms of version 2 of the GNU General Public		* modify it under the terms of version 2 of the GNU General Public
	@@ -95,14 +95,15 @@ struct datapath {
	/**		/**
	* struct ovs_skb_cb - OVS data in skb CB		* struct ovs_skb_cb - OVS data in skb CB
	* @flow: The flow associated with this packet. May be %NULL if no flow.		* @flow: The flow associated with this packet. May be %NULL if no flow.
	* @pkt_key: The flow information extracted from the packet. Must be nonnull.		* @egress_tun_key: Tunnel information about this packet on egress path.
	* @tun_key: Key for the tunnel that encapsulated this packet. NULL if the		* NULL if the packet is not being tunneled.
	* packet is not being tunneled.		* @input_vport: The original vport packet came in on. This value is cached
			* when a packet is received by OVS.
	*/		*/
	struct ovs_skb_cb {		struct ovs_skb_cb {
	struct sw_flow *flow;		struct sw_flow *flow;
	struct sw_flow_key *pkt_key;		struct vport *input_vport;
	struct ovs_key_ipv4_tunnel *tun_key;		struct ovs_key_ipv4_tunnel *egress_tun_key;
	};		};
	#define OVS_CB(skb) ((struct ovs_skb_cb *)(skb)->cb)		#define OVS_CB(skb) ((struct ovs_skb_cb *)(skb)->cb)

	@@ -183,17 +184,23 @@ static inline struct vport ovs_vport_ovsl(const struct datapath dp, int port_n
	extern struct notifier_block ovs_dp_device_notifier;		extern struct notifier_block ovs_dp_device_notifier;
	extern struct genl_family dp_vport_genl_family;		extern struct genl_family dp_vport_genl_family;

	void ovs_dp_process_received_packet(struct vport , struct sk_buff );		void ovs_dp_process_packet(struct sk_buff skb, struct sw_flow_key key);
	void ovs_dp_detach_port(struct vport *);		void ovs_dp_detach_port(struct vport *);
	int ovs_dp_upcall(struct datapath , struct sk_buff ,		int ovs_dp_upcall(struct datapath , struct sk_buff ,
	const struct dp_upcall_info *);		const struct dp_upcall_info *);

			const char ovs_dp_name(const struct datapath dp);
	struct sk_buff ovs_vport_cmd_build_info(struct vport , u32 pid, u32 seq,		struct sk_buff ovs_vport_cmd_build_info(struct vport , u32 pid, u32 seq,
	u8 cmd);		u8 cmd);

	int ovs_execute_actions(struct datapath dp, struct sk_buff skb);		int ovs_execute_actions(struct datapath dp, struct sk_buff skb,
			struct sw_flow_key *);

	void ovs_dp_notify_wq(struct work_struct *work);		void ovs_dp_notify_wq(struct work_struct *work);

			int action_fifos_init(void);
			void action_fifos_exit(void);

	#define OVS_NLERR(fmt, ...) \		#define OVS_NLERR(fmt, ...) \
	do { \		do { \
	if (net_ratelimit()) \		if (net_ratelimit()) \

net/openvswitch/flow.c

+42 −15

Original line number	Original line	Diff line number	Diff line
	/*		/*
	* Copyright (c) 2007-2013 Nicira, Inc.		* Copyright (c) 2007-2014 Nicira, Inc.
	*		*
	* This program is free software; you can redistribute it and/or		* This program is free software; you can redistribute it and/or
	* modify it under the terms of version 2 of the GNU General Public		* modify it under the terms of version 2 of the GNU General Public
	@@ -16,8 +16,6 @@
	* 02110-1301, USA		* 02110-1301, USA
	*/		*/

	#include "flow.h"
	#include "datapath.h"
	#include <linux/uaccess.h>		#include <linux/uaccess.h>
	#include <linux/netdevice.h>		#include <linux/netdevice.h>
	#include <linux/etherdevice.h>		#include <linux/etherdevice.h>
	@@ -46,6 +44,10 @@
	#include <net/ipv6.h>		#include <net/ipv6.h>
	#include <net/ndisc.h>		#include <net/ndisc.h>

			#include "datapath.h"
			#include "flow.h"
			#include "flow_netlink.h"

	u64 ovs_flow_used_time(unsigned long flow_jiffies)		u64 ovs_flow_used_time(unsigned long flow_jiffies)
	{		{
	struct timespec cur_ts;		struct timespec cur_ts;
	@@ -420,10 +422,9 @@ invalid:
	}		}

	/**		/**
	* ovs_flow_extract - extracts a flow key from an Ethernet frame.		* key_extract - extracts a flow key from an Ethernet frame.
	* @skb: sk_buff that contains the frame, with skb->data pointing to the		* @skb: sk_buff that contains the frame, with skb->data pointing to the
	* Ethernet header		* Ethernet header
	* @in_port: port number on which @skb was received.
	* @key: output flow key		* @key: output flow key
	*		*
	* The caller must ensure that skb->len >= ETH_HLEN.		* The caller must ensure that skb->len >= ETH_HLEN.
	@@ -442,19 +443,11 @@ invalid:
	* of a correct length, otherwise the same as skb->network_header.		* of a correct length, otherwise the same as skb->network_header.
	* For other key->eth.type values it is left untouched.		* For other key->eth.type values it is left untouched.
	*/		*/
	int ovs_flow_extract(struct sk_buff skb, u16 in_port, struct sw_flow_key key)		static int key_extract(struct sk_buff skb, struct sw_flow_key key)
	{		{
	int error;		int error;
	struct ethhdr *eth;		struct ethhdr *eth;

	memset(key, 0, sizeof(*key));

	key->phy.priority = skb->priority;
	if (OVS_CB(skb)->tun_key)
	memcpy(&key->tun_key, OVS_CB(skb)->tun_key, sizeof(key->tun_key));
	key->phy.in_port = in_port;
	key->phy.skb_mark = skb->mark;

	skb_reset_mac_header(skb);		skb_reset_mac_header(skb);

	/* Link layer. We are guaranteed to have at least the 14 byte Ethernet		/* Link layer. We are guaranteed to have at least the 14 byte Ethernet
	@@ -610,6 +603,40 @@ int ovs_flow_extract(struct sk_buff skb, u16 in_port, struct sw_flow_key key)
	}		}
	}		}
	}		}

	return 0;		return 0;
	}		}

			int ovs_flow_key_update(struct sk_buff skb, struct sw_flow_key key)
			{
			return key_extract(skb, key);
			}

			int ovs_flow_key_extract(struct ovs_key_ipv4_tunnel *tun_key,
			struct sk_buff skb, struct sw_flow_key key)
			{
			/* Extract metadata from packet. */
			memset(key, 0, sizeof(*key));
			if (tun_key)
			memcpy(&key->tun_key, tun_key, sizeof(key->tun_key));

			key->phy.priority = skb->priority;
			key->phy.in_port = OVS_CB(skb)->input_vport->port_no;
			key->phy.skb_mark = skb->mark;

			return key_extract(skb, key);
			}

			int ovs_flow_key_extract_userspace(const struct nlattr *attr,
			struct sk_buff *skb,
			struct sw_flow_key *key)
			{
			int err;

			memset(key, 0, sizeof(*key));
			/* Extract metadata from netlink attributes. */
			err = ovs_nla_get_flow_metadata(attr, key);
			if (err)
			return err;

			return key_extract(skb, key);
			}

Admin message