Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4083c805 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'net_next_ovs' of git://git.kernel.org/pub/scm/linux/kernel/git/pshelar/openvswitch 



Pravin B Shelar says:

====================
Open vSwitch

Following batch of patches brings feature parity between upstream
ovs and out of tree ovs module.

Two features are added, first adds support to export egress
tunnel information for a packet. This is used to improve
visibility in network traffic. Second feature allows userspace
vswitchd process to probe ovs module features. Other patches
are optimization and code cleanup.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents a2ae6007 05da5898

include/uapi/linux/openvswitch.h

+15 −0
Original line number Diff line number Diff line
@@ -157,6 +157,11 @@ enum ovs_packet_cmd { 
 * notification if the %OVS_ACTION_ATTR_USERSPACE action specified an

 * %OVS_USERSPACE_ATTR_USERDATA attribute, with the same length and content

 * specified there.

 * @OVS_PACKET_ATTR_EGRESS_TUN_KEY: Present for an %OVS_PACKET_CMD_ACTION

 * notification if the %OVS_ACTION_ATTR_USERSPACE action specified an

 * %OVS_USERSPACE_ATTR_EGRESS_TUN_PORT attribute, which is sent only if the

 * output port is actually a tunnel port. Contains the output tunnel key

 * extracted from the packet as nested %OVS_TUNNEL_KEY_ATTR_* attributes.

 *

 * These attributes follow the &struct ovs_header within the Generic Netlink

 * payload for %OVS_PACKET_* commands.
@@ -167,6 +172,8 @@ enum ovs_packet_attr { 
	OVS_PACKET_ATTR_KEY,         /* Nested OVS_KEY_ATTR_* attributes. */

	OVS_PACKET_ATTR_ACTIONS,     /* Nested OVS_ACTION_ATTR_* attributes. */

	OVS_PACKET_ATTR_USERDATA,    /* OVS_ACTION_ATTR_USERSPACE arg. */

	OVS_PACKET_ATTR_EGRESS_TUN_KEY,  /* Nested OVS_TUNNEL_KEY_ATTR_*

					    attributes. */

	__OVS_PACKET_ATTR_MAX

};
@@ -315,6 +322,8 @@ enum ovs_tunnel_key_attr { 
	OVS_TUNNEL_KEY_ATTR_CSUM,               /* No argument. CSUM packet. */

	OVS_TUNNEL_KEY_ATTR_OAM,                /* No argument. OAM frame.  */

	OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS,        /* Array of Geneve options. */

	OVS_TUNNEL_KEY_ATTR_TP_SRC,		/* be16 src Transport Port. */

	OVS_TUNNEL_KEY_ATTR_TP_DST,		/* be16 dst Transport Port. */

	__OVS_TUNNEL_KEY_ATTR_MAX

};
@@ -448,6 +457,8 @@ enum ovs_flow_attr { 
	OVS_FLOW_ATTR_USED,      /* u64 msecs last used in monotonic time. */

	OVS_FLOW_ATTR_CLEAR,     /* Flag to clear stats, tcp_flags, used. */

	OVS_FLOW_ATTR_MASK,      /* Sequence of OVS_KEY_ATTR_* attributes. */

	OVS_FLOW_ATTR_PROBE,     /* Flow operation is a feature probe, error

				  * logging should be suppressed. */

	__OVS_FLOW_ATTR_MAX

};
@@ -480,11 +491,15 @@ enum ovs_sample_attr { 
 * message should be sent.  Required.

 * @OVS_USERSPACE_ATTR_USERDATA: If present, its variable-length argument is

 * copied to the %OVS_PACKET_CMD_ACTION message as %OVS_PACKET_ATTR_USERDATA.

 * @OVS_USERSPACE_ATTR_EGRESS_TUN_PORT: If present, u32 output port to get

 * tunnel info.

 */

enum ovs_userspace_attr {

	OVS_USERSPACE_ATTR_UNSPEC,

	OVS_USERSPACE_ATTR_PID,	      /* u32 Netlink PID to receive upcalls. */

	OVS_USERSPACE_ATTR_USERDATA,  /* Optional user-specified cookie. */

	OVS_USERSPACE_ATTR_EGRESS_TUN_PORT,  /* Optional, u32 output port

					      * to get tunnel info. */

	__OVS_USERSPACE_ATTR_MAX

};

net/openvswitch/actions.c

+130 −50
Original line number Diff line number Diff line
@@ -69,7 +69,7 @@ static void action_fifo_init(struct action_fifo *fifo) 
	fifo->tail = 0;

}



static bool action_fifo_is_empty(struct action_fifo *fifo)

static bool action_fifo_is_empty(const struct action_fifo *fifo)

{

	return (fifo->head == fifo->tail);

}
@@ -92,7 +92,7 @@ static struct deferred_action *action_fifo_put(struct action_fifo *fifo) 


/* 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 sw_flow_key *key,

						    const struct nlattr *attr)

{

	struct action_fifo *fifo;
@@ -109,6 +109,16 @@ static struct deferred_action *add_deferred_actions(struct sk_buff *skb, 
	return da;

}



static void invalidate_flow_key(struct sw_flow_key *key)

{

	key->eth.type = htons(0);

}



static bool is_flow_key_valid(const struct sw_flow_key *key)

{

	return !!key->eth.type;

}



static int make_writable(struct sk_buff *skb, int write_len)

{

	if (!pskb_may_pull(skb, write_len))
@@ -120,7 +130,7 @@ static int make_writable(struct sk_buff *skb, int write_len) 
	return pskb_expand_head(skb, 0, 0, GFP_ATOMIC);

}



static int push_mpls(struct sk_buff *skb,

static int push_mpls(struct sk_buff *skb, struct sw_flow_key *key,

		     const struct ovs_action_push_mpls *mpls)

{

	__be32 *new_mpls_lse;
@@ -151,10 +161,12 @@ static int push_mpls(struct sk_buff *skb, 
	skb_set_inner_protocol(skb, skb->protocol);

	skb->protocol = mpls->mpls_ethertype;



	invalidate_flow_key(key);

	return 0;

}



static int pop_mpls(struct sk_buff *skb, const __be16 ethertype)

static int pop_mpls(struct sk_buff *skb, struct sw_flow_key *key,

		    const __be16 ethertype)

{

	struct ethhdr *hdr;

	int err;
@@ -181,10 +193,13 @@ static int pop_mpls(struct sk_buff *skb, const __be16 ethertype) 
	hdr->h_proto = ethertype;

	if (eth_p_mpls(skb->protocol))

		skb->protocol = ethertype;



	invalidate_flow_key(key);

	return 0;

}



static int set_mpls(struct sk_buff *skb, const __be32 *mpls_lse)

static int set_mpls(struct sk_buff *skb, struct sw_flow_key *key,

		    const __be32 *mpls_lse)

{

	__be32 *stack;

	int err;
@@ -196,13 +211,12 @@ static int set_mpls(struct sk_buff *skb, const __be32 *mpls_lse) 
	stack = (__be32 *)skb_mpls_header(skb);

	if (skb->ip_summed == CHECKSUM_COMPLETE) {

		__be32 diff[] = { ~(*stack), *mpls_lse };



		skb->csum = ~csum_partial((char *)diff, sizeof(diff),

					  ~skb->csum);

	}



	*stack = *mpls_lse;



	key->mpls.top_lse = *mpls_lse;

	return 0;

}
@@ -237,7 +251,7 @@ static int __pop_vlan_tci(struct sk_buff *skb, __be16 *current_tci) 
	return 0;

}



static int pop_vlan(struct sk_buff *skb)

static int pop_vlan(struct sk_buff *skb, struct sw_flow_key *key)

{

	__be16 tci;

	int err;
@@ -255,9 +269,12 @@ static int pop_vlan(struct sk_buff *skb) 
	}

	/* move next vlan tag to hw accel tag */

	if (likely(skb->protocol != htons(ETH_P_8021Q) ||

		   skb->len < VLAN_ETH_HLEN))

		   skb->len < VLAN_ETH_HLEN)) {

		key->eth.tci = 0;

		return 0;

	}



	invalidate_flow_key(key);

	err = __pop_vlan_tci(skb, &tci);

	if (unlikely(err))

		return err;
@@ -266,7 +283,8 @@ static int pop_vlan(struct sk_buff *skb) 
	return 0;

}



static int push_vlan(struct sk_buff *skb, const struct ovs_action_push_vlan *vlan)

static int push_vlan(struct sk_buff *skb, struct sw_flow_key *key,

		     const struct ovs_action_push_vlan *vlan)

{

	if (unlikely(vlan_tx_tag_present(skb))) {

		u16 current_tag;
@@ -283,12 +301,15 @@ static int push_vlan(struct sk_buff *skb, const struct ovs_action_push_vlan *vla 
			skb->csum = csum_add(skb->csum, csum_partial(skb->data

					+ (2 * ETH_ALEN), VLAN_HLEN, 0));



		invalidate_flow_key(key);

	} else {

		key->eth.tci = vlan->vlan_tci;

	}

	__vlan_hwaccel_put_tag(skb, vlan->vlan_tpid, ntohs(vlan->vlan_tci) & ~VLAN_TAG_PRESENT);

	return 0;

}



static int set_eth_addr(struct sk_buff *skb,

static int set_eth_addr(struct sk_buff *skb, struct sw_flow_key *key,

			const struct ovs_key_ethernet *eth_key)

{

	int err;
@@ -303,6 +324,8 @@ static int set_eth_addr(struct sk_buff *skb, 


	ovs_skb_postpush_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2);



	ether_addr_copy(key->eth.src, eth_key->eth_src);

	ether_addr_copy(key->eth.dst, eth_key->eth_dst);

	return 0;

}
@@ -386,7 +409,8 @@ static void set_ip_ttl(struct sk_buff *skb, struct iphdr *nh, u8 new_ttl) 
	nh->ttl = new_ttl;

}



static int set_ipv4(struct sk_buff *skb, const struct ovs_key_ipv4 *ipv4_key)

static int set_ipv4(struct sk_buff *skb, struct sw_flow_key *key,

		    const struct ovs_key_ipv4 *ipv4_key)

{

	struct iphdr *nh;

	int err;
@@ -398,22 +422,31 @@ static int set_ipv4(struct sk_buff *skb, const struct ovs_key_ipv4 *ipv4_key) 


	nh = ip_hdr(skb);



	if (ipv4_key->ipv4_src != nh->saddr)

	if (ipv4_key->ipv4_src != nh->saddr) {

		set_ip_addr(skb, nh, &nh->saddr, ipv4_key->ipv4_src);

		key->ipv4.addr.src = ipv4_key->ipv4_src;

	}



	if (ipv4_key->ipv4_dst != nh->daddr)

	if (ipv4_key->ipv4_dst != nh->daddr) {

		set_ip_addr(skb, nh, &nh->daddr, ipv4_key->ipv4_dst);

		key->ipv4.addr.dst = ipv4_key->ipv4_dst;

	}



	if (ipv4_key->ipv4_tos != nh->tos)

	if (ipv4_key->ipv4_tos != nh->tos) {

		ipv4_change_dsfield(nh, 0, ipv4_key->ipv4_tos);

		key->ip.tos = nh->tos;

	}



	if (ipv4_key->ipv4_ttl != nh->ttl)

	if (ipv4_key->ipv4_ttl != nh->ttl) {

		set_ip_ttl(skb, nh, ipv4_key->ipv4_ttl);

		key->ip.ttl = ipv4_key->ipv4_ttl;

	}



	return 0;

}



static int set_ipv6(struct sk_buff *skb, const struct ovs_key_ipv6 *ipv6_key)

static int set_ipv6(struct sk_buff *skb, struct sw_flow_key *key,

		    const struct ovs_key_ipv6 *ipv6_key)

{

	struct ipv6hdr *nh;

	int err;
@@ -429,9 +462,12 @@ static int set_ipv6(struct sk_buff *skb, const struct ovs_key_ipv6 *ipv6_key) 
	saddr = (__be32 *)&nh->saddr;

	daddr = (__be32 *)&nh->daddr;



	if (memcmp(ipv6_key->ipv6_src, saddr, sizeof(ipv6_key->ipv6_src)))

	if (memcmp(ipv6_key->ipv6_src, saddr, sizeof(ipv6_key->ipv6_src))) {

		set_ipv6_addr(skb, ipv6_key->ipv6_proto, saddr,

			      ipv6_key->ipv6_src, true);

		memcpy(&key->ipv6.addr.src, ipv6_key->ipv6_src,

		       sizeof(ipv6_key->ipv6_src));

	}



	if (memcmp(ipv6_key->ipv6_dst, daddr, sizeof(ipv6_key->ipv6_dst))) {

		unsigned int offset = 0;
@@ -445,12 +481,18 @@ static int set_ipv6(struct sk_buff *skb, const struct ovs_key_ipv6 *ipv6_key) 


		set_ipv6_addr(skb, ipv6_key->ipv6_proto, daddr,

			      ipv6_key->ipv6_dst, recalc_csum);

		memcpy(&key->ipv6.addr.dst, ipv6_key->ipv6_dst,

		       sizeof(ipv6_key->ipv6_dst));

	}



	set_ipv6_tc(nh, ipv6_key->ipv6_tclass);

	key->ip.tos = ipv6_get_dsfield(nh);



	set_ipv6_fl(nh, ntohl(ipv6_key->ipv6_label));

	nh->hop_limit = ipv6_key->ipv6_hlimit;

	key->ipv6.label = *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL);



	nh->hop_limit = ipv6_key->ipv6_hlimit;

	key->ip.ttl = ipv6_key->ipv6_hlimit;

	return 0;

}
@@ -478,7 +520,8 @@ static void set_udp_port(struct sk_buff *skb, __be16 *port, __be16 new_port) 
	}

}



static int set_udp(struct sk_buff *skb, const struct ovs_key_udp *udp_port_key)

static int set_udp(struct sk_buff *skb, struct sw_flow_key *key,

		   const struct ovs_key_udp *udp_port_key)

{

	struct udphdr *uh;

	int err;
@@ -489,16 +532,21 @@ static int set_udp(struct sk_buff *skb, const struct ovs_key_udp *udp_port_key) 
		return err;



	uh = udp_hdr(skb);

	if (udp_port_key->udp_src != uh->source)

	if (udp_port_key->udp_src != uh->source) {

		set_udp_port(skb, &uh->source, udp_port_key->udp_src);

		key->tp.src = udp_port_key->udp_src;

	}



	if (udp_port_key->udp_dst != uh->dest)

	if (udp_port_key->udp_dst != uh->dest) {

		set_udp_port(skb, &uh->dest, udp_port_key->udp_dst);

		key->tp.dst = udp_port_key->udp_dst;

	}



	return 0;

}



static int set_tcp(struct sk_buff *skb, const struct ovs_key_tcp *tcp_port_key)

static int set_tcp(struct sk_buff *skb, struct sw_flow_key *key,

		   const struct ovs_key_tcp *tcp_port_key)

{

	struct tcphdr *th;

	int err;
@@ -509,16 +557,20 @@ static int set_tcp(struct sk_buff *skb, const struct ovs_key_tcp *tcp_port_key) 
		return err;



	th = tcp_hdr(skb);

	if (tcp_port_key->tcp_src != th->source)

	if (tcp_port_key->tcp_src != th->source) {

		set_tp_port(skb, &th->source, tcp_port_key->tcp_src, &th->check);

		key->tp.src = tcp_port_key->tcp_src;

	}



	if (tcp_port_key->tcp_dst != th->dest)

	if (tcp_port_key->tcp_dst != th->dest) {

		set_tp_port(skb, &th->dest, tcp_port_key->tcp_dst, &th->check);

		key->tp.dst = tcp_port_key->tcp_dst;

	}



	return 0;

}



static int set_sctp(struct sk_buff *skb,

static int set_sctp(struct sk_buff *skb, struct sw_flow_key *key,

		    const struct ovs_key_sctp *sctp_port_key)

{

	struct sctphdr *sh;
@@ -546,6 +598,8 @@ static int set_sctp(struct sk_buff *skb, 
		sh->checksum = old_csum ^ old_correct_csum ^ new_csum;



		skb_clear_hash(skb);

		key->tp.src = sctp_port_key->sctp_src;

		key->tp.dst = sctp_port_key->sctp_dst;

	}



	return 0;
@@ -564,14 +618,15 @@ static void do_output(struct datapath *dp, struct sk_buff *skb, int out_port) 
static int output_userspace(struct datapath *dp, struct sk_buff *skb,

			    struct sw_flow_key *key, const struct nlattr *attr)

{

	struct ovs_tunnel_info info;

	struct dp_upcall_info upcall;

	const struct nlattr *a;

	int rem;



	upcall.cmd = OVS_PACKET_CMD_ACTION;

	upcall.key = key;

	upcall.userdata = NULL;

	upcall.portid = 0;

	upcall.egress_tun_info = NULL;



	for (a = nla_data(attr), rem = nla_len(attr); rem > 0;

		 a = nla_next(a, &rem)) {
@@ -583,10 +638,27 @@ static int output_userspace(struct datapath *dp, struct sk_buff *skb, 
		case OVS_USERSPACE_ATTR_PID:

			upcall.portid = nla_get_u32(a);

			break;



		case OVS_USERSPACE_ATTR_EGRESS_TUN_PORT: {

			/* Get out tunnel info. */

			struct vport *vport;



			vport = ovs_vport_rcu(dp, nla_get_u32(a));

			if (vport) {

				int err;



				err = ovs_vport_get_egress_tun_info(vport, skb,

								    &info);

				if (!err)

					upcall.egress_tun_info = &info;

			}

			break;

		}



		} /* End of switch. */

	}



	return ovs_dp_upcall(dp, skb, &upcall);

	return ovs_dp_upcall(dp, skb, key, &upcall);

}



static int sample(struct datapath *dp, struct sk_buff *skb,
@@ -656,7 +728,7 @@ static void execute_hash(struct sk_buff *skb, struct sw_flow_key *key, 
	key->ovs_flow_hash = hash;

}



static int execute_set_action(struct sk_buff *skb,

static int execute_set_action(struct sk_buff *skb, struct sw_flow_key *key,

			      const struct nlattr *nested_attr)

{

	int err = 0;
@@ -664,10 +736,12 @@ static int execute_set_action(struct sk_buff *skb, 
	switch (nla_type(nested_attr)) {

	case OVS_KEY_ATTR_PRIORITY:

		skb->priority = nla_get_u32(nested_attr);

		key->phy.priority = skb->priority;

		break;



	case OVS_KEY_ATTR_SKB_MARK:

		skb->mark = nla_get_u32(nested_attr);

		key->phy.skb_mark = skb->mark;

		break;



	case OVS_KEY_ATTR_TUNNEL_INFO:
@@ -675,31 +749,31 @@ static int execute_set_action(struct sk_buff *skb, 
		break;



	case OVS_KEY_ATTR_ETHERNET:

		err = set_eth_addr(skb, nla_data(nested_attr));

		err = set_eth_addr(skb, key, nla_data(nested_attr));

		break;



	case OVS_KEY_ATTR_IPV4:

		err = set_ipv4(skb, nla_data(nested_attr));

		err = set_ipv4(skb, key, nla_data(nested_attr));

		break;



	case OVS_KEY_ATTR_IPV6:

		err = set_ipv6(skb, nla_data(nested_attr));

		err = set_ipv6(skb, key, nla_data(nested_attr));

		break;



	case OVS_KEY_ATTR_TCP:

		err = set_tcp(skb, nla_data(nested_attr));

		err = set_tcp(skb, key, nla_data(nested_attr));

		break;



	case OVS_KEY_ATTR_UDP:

		err = set_udp(skb, nla_data(nested_attr));

		err = set_udp(skb, key, nla_data(nested_attr));

		break;



	case OVS_KEY_ATTR_SCTP:

		err = set_sctp(skb, nla_data(nested_attr));

		err = set_sctp(skb, key, nla_data(nested_attr));

		break;



	case OVS_KEY_ATTR_MPLS:

		err = set_mpls(skb, nla_data(nested_attr));

		err = set_mpls(skb, key, nla_data(nested_attr));

		break;

	}
@@ -711,11 +785,15 @@ static int execute_recirc(struct datapath *dp, struct sk_buff *skb, 
			  const struct nlattr *a, int rem)

{

	struct deferred_action *da;



	if (!is_flow_key_valid(key)) {

		int err;



		err = ovs_flow_key_update(skb, key);

		if (err)

			return err;

	}

	BUG_ON(!is_flow_key_valid(key));



	if (!nla_is_last(a, rem)) {

		/* Recirc action is the not the last action
@@ -752,7 +830,8 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb, 
	/* Every output action needs a separate clone of 'skb', but the common

	 * case is just a single output action, so that doing a clone and

	 * then freeing the original skbuff is wasteful.  So the following code

	 * is slightly obscure just to avoid that. */

	 * is slightly obscure just to avoid that.

	 */

	int prev_port = -1;

	const struct nlattr *a;

	int rem;
@@ -784,21 +863,21 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb, 
			break;



		case OVS_ACTION_ATTR_PUSH_MPLS:

			err = push_mpls(skb, nla_data(a));

			err = push_mpls(skb, key, nla_data(a));

			break;



		case OVS_ACTION_ATTR_POP_MPLS:

			err = pop_mpls(skb, nla_get_be16(a));

			err = pop_mpls(skb, key, nla_get_be16(a));

			break;



		case OVS_ACTION_ATTR_PUSH_VLAN:

			err = push_vlan(skb, nla_data(a));

			err = push_vlan(skb, key, nla_data(a));

			if (unlikely(err)) /* skb already freed. */

				return err;

			break;



		case OVS_ACTION_ATTR_POP_VLAN:

			err = pop_vlan(skb);

			err = pop_vlan(skb, key);

			break;



		case OVS_ACTION_ATTR_RECIRC:
@@ -813,7 +892,7 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb, 
			break;



		case OVS_ACTION_ATTR_SET:

			err = execute_set_action(skb, nla_data(a));

			err = execute_set_action(skb, key, nla_data(a));

			break;



		case OVS_ACTION_ATTR_SAMPLE:
@@ -865,7 +944,8 @@ static void process_deferred_actions(struct datapath *dp) 


/* Execute a list of actions against 'skb'. */

int ovs_execute_actions(struct datapath *dp, struct sk_buff *skb,

			struct sw_flow_actions *acts, struct sw_flow_key *key)

			const struct sw_flow_actions *acts,

			struct sw_flow_key *key)

{

	int level = this_cpu_read(exec_actions_level);

	int err;

net/openvswitch/datapath.c

+81 −48
Original line number Diff line number Diff line
@@ -59,7 +59,7 @@ 
#include "vport-netdev.h"



int ovs_net_id __read_mostly;

EXPORT_SYMBOL(ovs_net_id);

EXPORT_SYMBOL_GPL(ovs_net_id);



static struct genl_family dp_packet_genl_family;

static struct genl_family dp_flow_genl_family;
@@ -131,13 +131,15 @@ int lockdep_ovsl_is_held(void) 
	else

		return 1;

}

EXPORT_SYMBOL(lockdep_ovsl_is_held);

EXPORT_SYMBOL_GPL(lockdep_ovsl_is_held);

#endif



static struct vport *new_vport(const struct vport_parms *);

static int queue_gso_packets(struct datapath *dp, struct sk_buff *,

			     const struct sw_flow_key *,

			     const struct dp_upcall_info *);

static int queue_userspace_packet(struct datapath *dp, struct sk_buff *,

				  const struct sw_flow_key *,

				  const struct dp_upcall_info *);



/* Must be called with rcu_read_lock. */
@@ -176,7 +178,7 @@ const char *ovs_dp_name(const struct datapath *dp) 
	return vport->ops->get_name(vport);

}



static int get_dpifindex(struct datapath *dp)

static int get_dpifindex(const struct datapath *dp)

{

	struct vport *local;

	int ifindex;
@@ -271,10 +273,10 @@ void ovs_dp_process_packet(struct sk_buff *skb, struct sw_flow_key *key) 
		int error;



		upcall.cmd = OVS_PACKET_CMD_MISS;

		upcall.key = key;

		upcall.userdata = NULL;

		upcall.portid = ovs_vport_find_upcall_portid(p, skb);

		error = ovs_dp_upcall(dp, skb, &upcall);

		upcall.egress_tun_info = NULL;

		error = ovs_dp_upcall(dp, skb, key, &upcall);

		if (unlikely(error))

			kfree_skb(skb);

		else
@@ -298,6 +300,7 @@ void ovs_dp_process_packet(struct sk_buff *skb, struct sw_flow_key *key) 
}



int ovs_dp_upcall(struct datapath *dp, struct sk_buff *skb,

		  const struct sw_flow_key *key,

		  const struct dp_upcall_info *upcall_info)

{

	struct dp_stats_percpu *stats;
@@ -309,9 +312,9 @@ int ovs_dp_upcall(struct datapath *dp, struct sk_buff *skb, 
	}



	if (!skb_is_gso(skb))

		err = queue_userspace_packet(dp, skb, upcall_info);

		err = queue_userspace_packet(dp, skb, key, upcall_info);

	else

		err = queue_gso_packets(dp, skb, upcall_info);

		err = queue_gso_packets(dp, skb, key, upcall_info);

	if (err)

		goto err;
@@ -328,39 +331,43 @@ int ovs_dp_upcall(struct datapath *dp, struct sk_buff *skb, 
}



static int queue_gso_packets(struct datapath *dp, struct sk_buff *skb,

			     const struct sw_flow_key *key,

			     const struct dp_upcall_info *upcall_info)

{

	unsigned short gso_type = skb_shinfo(skb)->gso_type;

	struct dp_upcall_info later_info;

	struct sw_flow_key later_key;

	struct sk_buff *segs, *nskb;

	struct ovs_skb_cb ovs_cb;

	int err;



	ovs_cb = *OVS_CB(skb);

	segs = __skb_gso_segment(skb, NETIF_F_SG, false);

	*OVS_CB(skb) = ovs_cb;

	if (IS_ERR(segs))

		return PTR_ERR(segs);

	if (segs == NULL)

		return -EINVAL;



	if (gso_type & SKB_GSO_UDP) {

		/* The initial flow key extracted by ovs_flow_key_extract()

		 * in this case is for a first fragment, so we need to

		 * properly mark later fragments.

		 */

		later_key = *key;

		later_key.ip.frag = OVS_FRAG_TYPE_LATER;

	}



	/* Queue all of the segments. */

	skb = segs;

	do {

		err = queue_userspace_packet(dp, skb, upcall_info);

		*OVS_CB(skb) = ovs_cb;

		if (gso_type & SKB_GSO_UDP && skb != segs)

			key = &later_key;



		err = queue_userspace_packet(dp, skb, key, upcall_info);

		if (err)

			break;



		if (skb == segs && gso_type & SKB_GSO_UDP) {

			/* The initial flow key extracted by ovs_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.frag = OVS_FRAG_TYPE_LATER;



			later_info = *upcall_info;

			later_info.key = &later_key;

			upcall_info = &later_info;

		}

	} while ((skb = skb->next));



	/* Free all of the segments. */
@@ -375,7 +382,7 @@ static int queue_gso_packets(struct datapath *dp, struct sk_buff *skb, 
	return err;

}



static size_t upcall_msg_size(const struct nlattr *userdata,

static size_t upcall_msg_size(const struct dp_upcall_info *upcall_info,

			      unsigned int hdrlen)

{

	size_t size = NLMSG_ALIGN(sizeof(struct ovs_header))
@@ -383,13 +390,18 @@ static size_t upcall_msg_size(const struct nlattr *userdata, 
		+ nla_total_size(ovs_key_attr_size()); /* OVS_PACKET_ATTR_KEY */



	/* OVS_PACKET_ATTR_USERDATA */

	if (userdata)

		size += NLA_ALIGN(userdata->nla_len);

	if (upcall_info->userdata)

		size += NLA_ALIGN(upcall_info->userdata->nla_len);



	/* OVS_PACKET_ATTR_EGRESS_TUN_KEY */

	if (upcall_info->egress_tun_info)

		size += nla_total_size(ovs_tun_key_attr_size());



	return size;

}



static int queue_userspace_packet(struct datapath *dp, struct sk_buff *skb,

				  const struct sw_flow_key *key,

				  const struct dp_upcall_info *upcall_info)

{

	struct ovs_header *upcall;
@@ -440,7 +452,7 @@ static int queue_userspace_packet(struct datapath *dp, struct sk_buff *skb, 
	else

		hlen = skb->len;



	len = upcall_msg_size(upcall_info->userdata, hlen);

	len = upcall_msg_size(upcall_info, hlen);

	user_skb = genlmsg_new_unicast(len, &info, GFP_ATOMIC);

	if (!user_skb) {

		err = -ENOMEM;
@@ -452,7 +464,7 @@ static int queue_userspace_packet(struct datapath *dp, struct sk_buff *skb, 
	upcall->dp_ifindex = dp_ifindex;



	nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_KEY);

	err = ovs_nla_put_flow(upcall_info->key, upcall_info->key, user_skb);

	err = ovs_nla_put_flow(key, key, user_skb);

	BUG_ON(err);

	nla_nest_end(user_skb, nla);
@@ -461,6 +473,14 @@ static int queue_userspace_packet(struct datapath *dp, struct sk_buff *skb, 
			  nla_len(upcall_info->userdata),

			  nla_data(upcall_info->userdata));



	if (upcall_info->egress_tun_info) {

		nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_EGRESS_TUN_KEY);

		err = ovs_nla_put_egress_tunnel_key(user_skb,

						    upcall_info->egress_tun_info);

		BUG_ON(err);

		nla_nest_end(user_skb, nla);

	}



	/* Only reserve room for attribute header, packet data is added

	 * in skb_zerocopy() */

	if (!(nla = nla_reserve(user_skb, OVS_PACKET_ATTR_PACKET, 0))) {
@@ -506,6 +526,7 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info) 
	struct vport *input_vport;

	int len;

	int err;

	bool log = !a[OVS_FLOW_ATTR_PROBE];



	err = -EINVAL;

	if (!a[OVS_PACKET_ATTR_PACKET] || !a[OVS_PACKET_ATTR_KEY] ||
@@ -539,12 +560,12 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info) 
		goto err_kfree_skb;



	err = ovs_flow_key_extract_userspace(a[OVS_PACKET_ATTR_KEY], packet,

					     &flow->key);

					     &flow->key, log);

	if (err)

		goto err_flow_free;



	err = ovs_nla_copy_actions(a[OVS_PACKET_ATTR_ACTIONS],

				   &flow->key, &acts);

				   &flow->key, &acts, log);

	if (err)

		goto err_flow_free;
@@ -613,7 +634,7 @@ static struct genl_family dp_packet_genl_family = { 
	.n_ops = ARRAY_SIZE(dp_packet_genl_ops),

};



static void get_dp_stats(struct datapath *dp, struct ovs_dp_stats *stats,

static void get_dp_stats(const struct datapath *dp, struct ovs_dp_stats *stats,

			 struct ovs_dp_megaflow_stats *mega_stats)

{

	int i;
@@ -835,15 +856,16 @@ static int ovs_flow_cmd_new(struct sk_buff *skb, struct genl_info *info) 
	struct sw_flow_actions *acts;

	struct sw_flow_match match;

	int error;

	bool log = !a[OVS_FLOW_ATTR_PROBE];



	/* Must have key and actions. */

	error = -EINVAL;

	if (!a[OVS_FLOW_ATTR_KEY]) {

		OVS_NLERR("Flow key attribute not present in new flow.\n");

		OVS_NLERR(log, "Flow key attr not present in new flow.");

		goto error;

	}

	if (!a[OVS_FLOW_ATTR_ACTIONS]) {

		OVS_NLERR("Flow actions attribute not present in new flow.\n");

		OVS_NLERR(log, "Flow actions attr not present in new flow.");

		goto error;

	}
@@ -858,8 +880,8 @@ static int ovs_flow_cmd_new(struct sk_buff *skb, struct genl_info *info) 


	/* Extract key. */

	ovs_match_init(&match, &new_flow->unmasked_key, &mask);

	error = ovs_nla_get_match(&match,

				  a[OVS_FLOW_ATTR_KEY], a[OVS_FLOW_ATTR_MASK]);

	error = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY],

				  a[OVS_FLOW_ATTR_MASK], log);

	if (error)

		goto err_kfree_flow;
@@ -867,9 +889,9 @@ static int ovs_flow_cmd_new(struct sk_buff *skb, struct genl_info *info) 


	/* Validate actions. */

	error = ovs_nla_copy_actions(a[OVS_FLOW_ATTR_ACTIONS], &new_flow->key,

				     &acts);

				     &acts, log);

	if (error) {

		OVS_NLERR("Flow actions may not be safe on all matching packets.\n");

		OVS_NLERR(log, "Flow actions may not be safe on all matching packets.");

		goto err_kfree_flow;

	}
@@ -922,6 +944,7 @@ static int ovs_flow_cmd_new(struct sk_buff *skb, struct genl_info *info) 
		}

		/* The unmasked key has to be the same for flow updates. */

		if (unlikely(!ovs_flow_cmp_unmasked_key(flow, &match))) {

			/* Look for any overlapping flow. */

			flow = ovs_flow_tbl_lookup_exact(&dp->table, &match);

			if (!flow) {

				error = -ENOENT;
@@ -964,16 +987,18 @@ static int ovs_flow_cmd_new(struct sk_buff *skb, struct genl_info *info) 
/* Factor out action copy to avoid "Wframe-larger-than=1024" warning. */

static struct sw_flow_actions *get_flow_actions(const struct nlattr *a,

						const struct sw_flow_key *key,

						const struct sw_flow_mask *mask)

						const struct sw_flow_mask *mask,

						bool log)

{

	struct sw_flow_actions *acts;

	struct sw_flow_key masked_key;

	int error;



	ovs_flow_mask_key(&masked_key, key, mask);

	error = ovs_nla_copy_actions(a, &masked_key, &acts);

	error = ovs_nla_copy_actions(a, &masked_key, &acts, log);

	if (error) {

		OVS_NLERR("Actions may not be safe on all matching packets.\n");

		OVS_NLERR(log,

			  "Actions may not be safe on all matching packets");

		return ERR_PTR(error);

	}
@@ -992,23 +1017,25 @@ static int ovs_flow_cmd_set(struct sk_buff *skb, struct genl_info *info) 
	struct sw_flow_actions *old_acts = NULL, *acts = NULL;

	struct sw_flow_match match;

	int error;

	bool log = !a[OVS_FLOW_ATTR_PROBE];



	/* Extract key. */

	error = -EINVAL;

	if (!a[OVS_FLOW_ATTR_KEY]) {

		OVS_NLERR("Flow key attribute not present in set flow.\n");

		OVS_NLERR(log, "Flow key attribute not present in set flow.");

		goto error;

	}



	ovs_match_init(&match, &key, &mask);

	error = ovs_nla_get_match(&match,

				  a[OVS_FLOW_ATTR_KEY], a[OVS_FLOW_ATTR_MASK]);

	error = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY],

				  a[OVS_FLOW_ATTR_MASK], log);

	if (error)

		goto error;



	/* Validate actions. */

	if (a[OVS_FLOW_ATTR_ACTIONS]) {

		acts = get_flow_actions(a[OVS_FLOW_ATTR_ACTIONS], &key, &mask);

		acts = get_flow_actions(a[OVS_FLOW_ATTR_ACTIONS], &key, &mask,

					log);

		if (IS_ERR(acts)) {

			error = PTR_ERR(acts);

			goto error;
@@ -1089,14 +1116,16 @@ static int ovs_flow_cmd_get(struct sk_buff *skb, struct genl_info *info) 
	struct datapath *dp;

	struct sw_flow_match match;

	int err;

	bool log = !a[OVS_FLOW_ATTR_PROBE];



	if (!a[OVS_FLOW_ATTR_KEY]) {

		OVS_NLERR("Flow get message rejected, Key attribute missing.\n");

		OVS_NLERR(log,

			  "Flow get message rejected, Key attribute missing.");

		return -EINVAL;

	}



	ovs_match_init(&match, &key, NULL);

	err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL);

	err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL, log);

	if (err)

		return err;
@@ -1137,10 +1166,12 @@ static int ovs_flow_cmd_del(struct sk_buff *skb, struct genl_info *info) 
	struct datapath *dp;

	struct sw_flow_match match;

	int err;

	bool log = !a[OVS_FLOW_ATTR_PROBE];



	if (likely(a[OVS_FLOW_ATTR_KEY])) {

		ovs_match_init(&match, &key, NULL);

		err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL);

		err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL,

					log);

		if (unlikely(err))

			return err;

	}
@@ -1230,8 +1261,10 @@ static int ovs_flow_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb) 


static const struct nla_policy flow_policy[OVS_FLOW_ATTR_MAX + 1] = {

	[OVS_FLOW_ATTR_KEY] = { .type = NLA_NESTED },

	[OVS_FLOW_ATTR_MASK] = { .type = NLA_NESTED },

	[OVS_FLOW_ATTR_ACTIONS] = { .type = NLA_NESTED },

	[OVS_FLOW_ATTR_CLEAR] = { .type = NLA_FLAG },

	[OVS_FLOW_ATTR_PROBE] = { .type = NLA_FLAG },

};



static const struct genl_ops dp_flow_genl_ops[] = {
@@ -1332,7 +1365,7 @@ static struct sk_buff *ovs_dp_cmd_alloc_info(struct genl_info *info) 


/* Called with rcu_read_lock or ovs_mutex. */

static struct datapath *lookup_datapath(struct net *net,

					struct ovs_header *ovs_header,

					const struct ovs_header *ovs_header,

					struct nlattr *a[OVS_DP_ATTR_MAX + 1])

{

	struct datapath *dp;
@@ -1360,7 +1393,7 @@ static void ovs_dp_reset_user_features(struct sk_buff *skb, struct genl_info *in 
	dp->user_features = 0;

}



static void ovs_dp_change(struct datapath *dp, struct nlattr **a)

static void ovs_dp_change(struct datapath *dp, struct nlattr *a[])

{

	if (a[OVS_DP_ATTR_USER_FEATURES])

		dp->user_features = nla_get_u32(a[OVS_DP_ATTR_USER_FEATURES]);
@@ -1724,7 +1757,7 @@ struct sk_buff *ovs_vport_cmd_build_info(struct vport *vport, u32 portid, 


/* Called with ovs_mutex or RCU read lock. */

static struct vport *lookup_vport(struct net *net,

				  struct ovs_header *ovs_header,

				  const struct ovs_header *ovs_header,

				  struct nlattr *a[OVS_VPORT_ATTR_MAX + 1])

{

	struct datapath *dp;

net/openvswitch/datapath.h

+11 −11

File changed.

Preview size limit exceeded, changes collapsed.

net/openvswitch/flow.c

+4 −4

File changed.

Preview size limit exceeded, changes collapsed.