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

Pravin B Shelar says:

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

Following patches adds recirculation and hash action to OVS.
First patch removes pointer to stack object. Next three patches
does code restructuring which is required for last patch.
Recirculation implementation is changed, according to comments from
David Miller, to avoid using recursive calls in OVS. It is using
queue to record recirc action and deferred recirc is executed at
the end of current actions execution.

v1-v2:
Changed subsystem name in subject to openvswitch
v2-v3:
Added patch to remove pkt_key pointer from skb->cb.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

11 files changed, 428 insertions, 126 deletions

diff --git a/include/uapi/linux/openvswitch.h b/include/uapi/linux/openvswitch.h
index a794d1dd7b40..f7fc507d82ab 100644
--- a/include/uapi/linux/openvswitch.h
+++ b/include/uapi/linux/openvswitch.h
@@ -289,6 +289,9 @@ enum ovs_key_attr {
         OVS_KEY_ATTR_TUNNEL,    /* Nested set of ovs_tunnel attributes */
         OVS_KEY_ATTR_SCTP,      /* struct ovs_key_sctp */
         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__
         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). */
 };
 
+/* 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.
  *
@@ -521,6 +545,8 @@ enum ovs_action_attr {
         OVS_ACTION_ATTR_PUSH_VLAN,    /* struct ovs_action_push_vlan. */
         OVS_ACTION_ATTR_POP_VLAN,     /* No argument. */
         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
 };
 
diff --git a/net/openvswitch/actions.c b/net/openvswitch/actions.c
index 5231652a95d9..6932a42e41a2 100644
--- a/net/openvswitch/actions.c
+++ b/net/openvswitch/actions.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2013 Nicira, Inc.
+ * Copyright (c) 2007-2014 Nicira, Inc.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
@@ -35,11 +35,78 @@
 #include <net/sctp/checksum.h>
 
 #include "datapath.h"
+#include "flow.h"
 #include "vport.h"
 
 static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
+                              struct sw_flow_key *key,
                               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)
 {
         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,
-                            const struct nlattr *attr)
+                            struct sw_flow_key *key, const struct nlattr *attr)
 {
         struct dp_upcall_info upcall;
         const struct nlattr *a;
         int rem;
 
-        BUG_ON(!OVS_CB(skb)->pkt_key);
-
         upcall.cmd = OVS_PACKET_CMD_ACTION;
-        upcall.key = OVS_CB(skb)->pkt_key;
+        upcall.key = key;
         upcall.userdata = NULL;
         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,
-                  const struct nlattr *attr)
+                  struct sw_flow_key *key, const struct nlattr *attr)
 {
         const struct nlattr *acts_list = NULL;
         const struct nlattr *a;
-        struct sk_buff *sample_skb;
         int rem;
 
         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);
         a = nla_data(acts_list);
 
-        /* Actions list is either empty or only contains a single user-space
-         * action, the latter being a special case as it is the only known
-         * usage of the sample action.
-         * In these special cases don't clone the skb as there are no
-         * side-effects in the nested actions.
-         * Otherwise, clone in case the nested actions have side effects.
+        /* Actions list is empty, do nothing */
+        if (unlikely(!rem))
+                return 0;
+
+        /* The only known usage of sample action is having a single user-space
+         * 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 &&
-                                last_action(a, rem)))) {
-                sample_skb = skb;
-                skb_get(skb);
-        } else {
-                sample_skb = skb_clone(skb, GFP_ATOMIC);
-                if (!sample_skb) /* Skip sample action when out of memory. */
-                        return 0;
+        if (likely(nla_type(a) == OVS_ACTION_ATTR_USERSPACE &&
+                   last_action(a, rem)))
+                return output_userspace(dp, skb, key, a);
+
+        skb = skb_clone(skb, GFP_ATOMIC);
+        if (!skb)
+                /* 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;
+}
 
-        /* Note that do_execute_actions() never consumes skb.
-         * In the case where skb has been cloned above it is the clone that
-         * is consumed.  Otherwise the skb_get(skb) call prevents
-         * consumption by do_execute_actions(). Thus, it is safe to simply
-         * return the error code and let the caller (also
-         * do_execute_actions()) free skb on error.
-         */
-        return do_execute_actions(dp, sample_skb, a, rem);
+static void execute_hash(struct sk_buff *skb, struct sw_flow_key *key,
+                         const struct nlattr *attr)
+{
+        struct ovs_action_hash *hash_act = nla_data(attr);
+        u32 hash = 0;
+
+        /* OVS_HASH_ALG_L4 is the only possible hash algorithm.  */
+        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,
@@ -511,7 +591,7 @@ static int execute_set_action(struct sk_buff *skb,
                 break;
 
         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;
 
         case OVS_KEY_ATTR_ETHERNET:
@@ -542,8 +622,47 @@ static int execute_set_action(struct sk_buff *skb,
         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'. */
 static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
+                              struct sw_flow_key *key,
                               const struct nlattr *attr, int len)
 {
         /* 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;
 
                 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;
 
                 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);
                         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:
                         err = execute_set_action(skb, nla_data(a));
                         break;
 
                 case OVS_ACTION_ATTR_SAMPLE:
-                        err = sample(dp, skb, a);
+                        err = sample(dp, skb, key, a);
                         if (unlikely(err)) /* skb already freed. */
                                 return err;
                         break;
@@ -607,11 +741,63 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
         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'. */
-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)
 {
-        struct sw_flow_actions *acts = rcu_dereference(OVS_CB(skb)->flow->sf_acts);
+        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);
 
-        OVS_CB(skb)->tun_key = NULL;
-        return do_execute_actions(dp, skb, acts->actions, acts->actions_len);
+        if (!level)
+                process_deferred_actions(dp);
+
+        this_cpu_dec(exec_actions_level);
+        return err;
+}
+
+int action_fifos_init(void)
+{
+        action_fifos = alloc_percpu(struct action_fifo);
+        if (!action_fifos)
+                return -ENOMEM;
+
+        return 0;
+}
+
+void action_fifos_exit(void)
+{
+        free_percpu(action_fifos);
 }
diff --git a/net/openvswitch/datapath.c b/net/openvswitch/datapath.c
index 91d66b7e64ac..16cad14fa81e 100644
--- a/net/openvswitch/datapath.c
+++ b/net/openvswitch/datapath.c
@@ -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. */
-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);
         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. */
-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 sw_flow *flow;
         struct dp_stats_percpu *stats;
-        struct sw_flow_key key;
         u64 *stats_counter;
         u32 n_mask_hit;
-        int error;
 
         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. */
-        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)) {
                 struct dp_upcall_info upcall;
+                int error;
 
                 upcall.cmd = OVS_PACKET_CMD_MISS;
-                upcall.key = &key;
+                upcall.key = key;
                 upcall.userdata = NULL;
                 upcall.portid = ovs_vport_find_upcall_portid(p, skb);
                 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)->pkt_key = &key;
 
-        ovs_flow_stats_update(OVS_CB(skb)->flow, key.tp.flags, skb);
-        ovs_execute_actions(dp, skb);
+        ovs_flow_stats_update(OVS_CB(skb)->flow, key->tp.flags, skb);
+        ovs_execute_actions(dp, skb, key);
         stats_counter = &stats->n_hit;
 
 out:
@@ -515,6 +507,7 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
         struct sw_flow *flow;
         struct datapath *dp;
         struct ethhdr *eth;
+        struct vport *input_vport;
         int len;
         int err;
 
@@ -549,13 +542,11 @@ static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info)
         if (IS_ERR(flow))
                 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)
                 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]));
         err = PTR_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;
 
         OVS_CB(packet)->flow = flow;
-        OVS_CB(packet)->pkt_key = &flow->key;
         packet->priority = flow->key.phy.priority;
         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)
                 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();
-        err = ovs_execute_actions(dp, packet);
+        err = ovs_execute_actions(dp, packet, &flow->key);
         local_bh_enable();
         rcu_read_unlock();
 
@@ -2066,10 +2065,14 @@ static int __init dp_init(void)
 
         pr_info("Open vSwitch switching datapath\n");
 
-        err = ovs_internal_dev_rtnl_link_register();
+        err = action_fifos_init();
         if (err)
                 goto error;
 
+        err = ovs_internal_dev_rtnl_link_register();
+        if (err)
+                goto error_action_fifos_exit;
+
         err = ovs_flow_init();
         if (err)
                 goto error_unreg_rtnl_link;
@@ -2102,6 +2105,8 @@ error_flow_exit:
         ovs_flow_exit();
 error_unreg_rtnl_link:
         ovs_internal_dev_rtnl_link_unregister();
+error_action_fifos_exit:
+        action_fifos_exit();
 error:
         return err;
 }
@@ -2115,6 +2120,7 @@ static void dp_cleanup(void)
         ovs_vport_exit();
         ovs_flow_exit();
         ovs_internal_dev_rtnl_link_unregister();
+        action_fifos_exit();
 }
 
 module_init(dp_init);
diff --git a/net/openvswitch/datapath.h b/net/openvswitch/datapath.h
index 701b5738c38a..ac3f3df96961 100644
--- a/net/openvswitch/datapath.h
+++ b/net/openvswitch/datapath.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2012 Nicira, Inc.
+ * Copyright (c) 2007-2014 Nicira, Inc.
  *
  * This program is free software; you can redistribute it and/or
  * 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
  * @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.
- * @tun_key: Key for the tunnel that encapsulated this packet. NULL if the
- * packet is not being tunneled.
+ * @egress_tun_key: Tunnel information about this packet on egress path.
+ * NULL if the 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 sw_flow          *flow;
-        struct sw_flow_key      *pkt_key;
-        struct ovs_key_ipv4_tunnel  *tun_key;
+        struct vport            *input_vport;
+        struct ovs_key_ipv4_tunnel  *egress_tun_key;
 };
 #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 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 *);
 int ovs_dp_upcall(struct datapath *, struct sk_buff *,
                   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,
                                          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);
 
+int action_fifos_init(void);
+void action_fifos_exit(void);
+
 #define OVS_NLERR(fmt, ...)                                     \
 do {                                                            \
         if (net_ratelimit())                                    \
diff --git a/net/openvswitch/flow.c b/net/openvswitch/flow.c
index 7064da92f420..4010423f2831 100644
--- a/net/openvswitch/flow.c
+++ b/net/openvswitch/flow.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2013 Nicira, Inc.
+ * Copyright (c) 2007-2014 Nicira, Inc.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
@@ -16,8 +16,6 @@
  * 02110-1301, USA
  */
 
-#include "flow.h"
-#include "datapath.h"
 #include <linux/uaccess.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
@@ -46,6 +44,10 @@
 #include <net/ipv6.h>
 #include <net/ndisc.h>
 
+#include "datapath.h"
+#include "flow.h"
+#include "flow_netlink.h"
+
 u64 ovs_flow_used_time(unsigned long flow_jiffies)
 {
         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
  * Ethernet header
- * @in_port: port number on which @skb was received.
  * @key: output flow key
  *
  * 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.
  *      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;
         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);
 
         /* 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;
 }
+
+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);
+}
diff --git a/net/openvswitch/flow.h b/net/openvswitch/flow.h
index 5e5aaed3a85b..0f5db4ec565d 100644
--- a/net/openvswitch/flow.h
+++ b/net/openvswitch/flow.h
@@ -72,6 +72,8 @@ struct sw_flow_key {
                 u32     skb_mark;       /* SKB mark. */
                 u16     in_port;        /* Input switch port (or DP_MAX_PORTS). */
         } __packed phy; /* Safe when right after 'tun_key'. */
+        u32 ovs_flow_hash;              /* Datapath computed hash value.  */
+        u32 recirc_id;                  /* Recirculation ID.  */
         struct {
                 u8     src[ETH_ALEN];   /* Ethernet source address. */
                 u8     dst[ETH_ALEN];   /* Ethernet destination address. */
@@ -187,6 +189,12 @@ void ovs_flow_stats_get(const struct sw_flow *, struct ovs_flow_stats *,
 void ovs_flow_stats_clear(struct sw_flow *);
 u64 ovs_flow_used_time(unsigned long flow_jiffies);
 
-int ovs_flow_extract(struct sk_buff *, u16 in_port, struct sw_flow_key *);
+int ovs_flow_key_update(struct sk_buff *skb, struct sw_flow_key *key);
+int ovs_flow_key_extract(struct ovs_key_ipv4_tunnel *tun_key,
+                         struct sk_buff *skb, struct sw_flow_key *key);
+/* Extract key from packet coming from userspace. */
+int ovs_flow_key_extract_userspace(const struct nlattr *attr,
+                                   struct sk_buff *skb,
+                                   struct sw_flow_key *key);
 
 #endif /* flow.h */
diff --git a/net/openvswitch/flow_netlink.c b/net/openvswitch/flow_netlink.c
index d757848da89c..f4c8daa73965 100644
--- a/net/openvswitch/flow_netlink.c
+++ b/net/openvswitch/flow_netlink.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2013 Nicira, Inc.
+ * Copyright (c) 2007-2014 Nicira, Inc.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
@@ -251,6 +251,8 @@ static const int ovs_key_lens[OVS_KEY_ATTR_MAX + 1] = {
         [OVS_KEY_ATTR_ICMPV6] = sizeof(struct ovs_key_icmpv6),
         [OVS_KEY_ATTR_ARP] = sizeof(struct ovs_key_arp),
         [OVS_KEY_ATTR_ND] = sizeof(struct ovs_key_nd),
+        [OVS_KEY_ATTR_RECIRC_ID] = sizeof(u32),
+        [OVS_KEY_ATTR_DP_HASH] = sizeof(u32),
         [OVS_KEY_ATTR_TUNNEL] = -1,
 };
 
@@ -454,6 +456,20 @@ static int ipv4_tun_to_nlattr(struct sk_buff *skb,
 static int metadata_from_nlattrs(struct sw_flow_match *match,  u64 *attrs,
                                  const struct nlattr **a, bool is_mask)
 {
+        if (*attrs & (1 << OVS_KEY_ATTR_DP_HASH)) {
+                u32 hash_val = nla_get_u32(a[OVS_KEY_ATTR_DP_HASH]);
+
+                SW_FLOW_KEY_PUT(match, ovs_flow_hash, hash_val, is_mask);
+                *attrs &= ~(1 << OVS_KEY_ATTR_DP_HASH);
+        }
+
+        if (*attrs & (1 << OVS_KEY_ATTR_RECIRC_ID)) {
+                u32 recirc_id = nla_get_u32(a[OVS_KEY_ATTR_RECIRC_ID]);
+
+                SW_FLOW_KEY_PUT(match, recirc_id, recirc_id, is_mask);
+                *attrs &= ~(1 << OVS_KEY_ATTR_RECIRC_ID);
+        }
+
         if (*attrs & (1 << OVS_KEY_ATTR_PRIORITY)) {
                 SW_FLOW_KEY_PUT(match, phy.priority,
                           nla_get_u32(a[OVS_KEY_ATTR_PRIORITY]), is_mask);
@@ -836,7 +852,7 @@ int ovs_nla_get_match(struct sw_flow_match *match,
 
 /**
  * ovs_nla_get_flow_metadata - parses Netlink attributes into a flow key.
- * @flow: Receives extracted in_port, priority, tun_key and skb_mark.
+ * @key: Receives extracted in_port, priority, tun_key and skb_mark.
  * @attr: Netlink attribute holding nested %OVS_KEY_ATTR_* Netlink attribute
  * sequence.
  *
@@ -846,32 +862,24 @@ int ovs_nla_get_match(struct sw_flow_match *match,
  * extracted from the packet itself.
  */
 
-int ovs_nla_get_flow_metadata(struct sw_flow *flow,
-                              const struct nlattr *attr)
+int ovs_nla_get_flow_metadata(const struct nlattr *attr,
+                              struct sw_flow_key *key)
 {
-        struct ovs_key_ipv4_tunnel *tun_key = &flow->key.tun_key;
         const struct nlattr *a[OVS_KEY_ATTR_MAX + 1];
+        struct sw_flow_match match;
         u64 attrs = 0;
         int err;
-        struct sw_flow_match match;
-
-        flow->key.phy.in_port = DP_MAX_PORTS;
-        flow->key.phy.priority = 0;
-        flow->key.phy.skb_mark = 0;
-        memset(tun_key, 0, sizeof(flow->key.tun_key));
 
         err = parse_flow_nlattrs(attr, a, &attrs);
         if (err)
                 return -EINVAL;
 
         memset(&match, 0, sizeof(match));
-        match.key = &flow->key;
+        match.key = key;
 
-        err = metadata_from_nlattrs(&match, &attrs, a, false);
-        if (err)
-                return err;
+        key->phy.in_port = DP_MAX_PORTS;
 
-        return 0;
+        return metadata_from_nlattrs(&match, &attrs, a, false);
 }
 
 int ovs_nla_put_flow(const struct sw_flow_key *swkey,
@@ -881,6 +889,12 @@ int ovs_nla_put_flow(const struct sw_flow_key *swkey,
         struct nlattr *nla, *encap;
         bool is_mask = (swkey != output);
 
+        if (nla_put_u32(skb, OVS_KEY_ATTR_RECIRC_ID, output->recirc_id))
+                goto nla_put_failure;
+
+        if (nla_put_u32(skb, OVS_KEY_ATTR_DP_HASH, output->ovs_flow_hash))
+                goto nla_put_failure;
+
         if (nla_put_u32(skb, OVS_KEY_ATTR_PRIORITY, output->phy.priority))
                 goto nla_put_failure;
 
@@ -1409,11 +1423,13 @@ int ovs_nla_copy_actions(const struct nlattr *attr,
                 /* Expected argument lengths, (u32)-1 for variable length. */
                 static const u32 action_lens[OVS_ACTION_ATTR_MAX + 1] = {
                         [OVS_ACTION_ATTR_OUTPUT] = sizeof(u32),
+                        [OVS_ACTION_ATTR_RECIRC] = sizeof(u32),
                         [OVS_ACTION_ATTR_USERSPACE] = (u32)-1,
                         [OVS_ACTION_ATTR_PUSH_VLAN] = sizeof(struct ovs_action_push_vlan),
                         [OVS_ACTION_ATTR_POP_VLAN] = 0,
                         [OVS_ACTION_ATTR_SET] = (u32)-1,
-                        [OVS_ACTION_ATTR_SAMPLE] = (u32)-1
+                        [OVS_ACTION_ATTR_SAMPLE] = (u32)-1,
+                        [OVS_ACTION_ATTR_HASH] = sizeof(struct ovs_action_hash)
                 };
                 const struct ovs_action_push_vlan *vlan;
                 int type = nla_type(a);
@@ -1440,6 +1456,18 @@ int ovs_nla_copy_actions(const struct nlattr *attr,
                                 return -EINVAL;
                         break;
 
+                case OVS_ACTION_ATTR_HASH: {
+                        const struct ovs_action_hash *act_hash = nla_data(a);
+
+                        switch (act_hash->hash_alg) {
+                        case OVS_HASH_ALG_L4:
+                                break;
+                        default:
+                                return  -EINVAL;
+                        }
+
+                        break;
+                }
 
                 case OVS_ACTION_ATTR_POP_VLAN:
                         break;
@@ -1452,6 +1480,9 @@ int ovs_nla_copy_actions(const struct nlattr *attr,
                                 return -EINVAL;
                         break;
 
+                case OVS_ACTION_ATTR_RECIRC:
+                        break;
+
                 case OVS_ACTION_ATTR_SET:
                         err = validate_set(a, key, sfa, &skip_copy);
                         if (err)
diff --git a/net/openvswitch/flow_netlink.h b/net/openvswitch/flow_netlink.h
index 440151045d39..206e45add888 100644
--- a/net/openvswitch/flow_netlink.h
+++ b/net/openvswitch/flow_netlink.h
@@ -42,8 +42,8 @@ void ovs_match_init(struct sw_flow_match *match,
 
 int ovs_nla_put_flow(const struct sw_flow_key *,
                      const struct sw_flow_key *, struct sk_buff *);
-int ovs_nla_get_flow_metadata(struct sw_flow *flow,
-                              const struct nlattr *attr);
+int ovs_nla_get_flow_metadata(const struct nlattr *, struct sw_flow_key *);
+
 int ovs_nla_get_match(struct sw_flow_match *match,
                       const struct nlattr *,
                       const struct nlattr *);
diff --git a/net/openvswitch/vport-gre.c b/net/openvswitch/vport-gre.c
index f49148a07da2..309cca6e816f 100644
--- a/net/openvswitch/vport-gre.c
+++ b/net/openvswitch/vport-gre.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2013 Nicira, Inc.
+ * Copyright (c) 2007-2014 Nicira, Inc.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
@@ -63,7 +63,7 @@ static __be16 filter_tnl_flags(__be16 flags)
 static struct sk_buff *__build_header(struct sk_buff *skb,
                                       int tunnel_hlen)
 {
-        const struct ovs_key_ipv4_tunnel *tun_key = OVS_CB(skb)->tun_key;
+        const struct ovs_key_ipv4_tunnel *tun_key = OVS_CB(skb)->egress_tun_key;
         struct tnl_ptk_info tpi;
 
         skb = gre_handle_offloads(skb, !!(tun_key->tun_flags & TUNNEL_CSUM));
@@ -129,6 +129,7 @@ static int gre_err(struct sk_buff *skb, u32 info,
 static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
 {
         struct net *net = ovs_dp_get_net(vport->dp);
+        struct ovs_key_ipv4_tunnel *tun_key;
         struct flowi4 fl;
         struct rtable *rt;
         int min_headroom;
@@ -136,16 +137,17 @@ static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
         __be16 df;
         int err;
 
-        if (unlikely(!OVS_CB(skb)->tun_key)) {
+        if (unlikely(!OVS_CB(skb)->egress_tun_key)) {
                 err = -EINVAL;
                 goto error;
         }
 
+        tun_key = OVS_CB(skb)->egress_tun_key;
         /* Route lookup */
         memset(&fl, 0, sizeof(fl));
-        fl.daddr = OVS_CB(skb)->tun_key->ipv4_dst;
-        fl.saddr = OVS_CB(skb)->tun_key->ipv4_src;
-        fl.flowi4_tos = RT_TOS(OVS_CB(skb)->tun_key->ipv4_tos);
+        fl.daddr = tun_key->ipv4_dst;
+        fl.saddr = tun_key->ipv4_src;
+        fl.flowi4_tos = RT_TOS(tun_key->ipv4_tos);
         fl.flowi4_mark = skb->mark;
         fl.flowi4_proto = IPPROTO_GRE;
 
@@ -153,7 +155,7 @@ static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
         if (IS_ERR(rt))
                 return PTR_ERR(rt);
 
-        tunnel_hlen = ip_gre_calc_hlen(OVS_CB(skb)->tun_key->tun_flags);
+        tunnel_hlen = ip_gre_calc_hlen(tun_key->tun_flags);
 
         min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
                         + tunnel_hlen + sizeof(struct iphdr)
@@ -185,15 +187,14 @@ static int gre_tnl_send(struct vport *vport, struct sk_buff *skb)
                 goto err_free_rt;
         }
 
-        df = OVS_CB(skb)->tun_key->tun_flags & TUNNEL_DONT_FRAGMENT ?
+        df = tun_key->tun_flags & TUNNEL_DONT_FRAGMENT ?
                 htons(IP_DF) : 0;
 
         skb->ignore_df = 1;
 
         return iptunnel_xmit(skb->sk, rt, skb, fl.saddr,
-                             OVS_CB(skb)->tun_key->ipv4_dst, IPPROTO_GRE,
-                             OVS_CB(skb)->tun_key->ipv4_tos,
-                             OVS_CB(skb)->tun_key->ipv4_ttl, df, false);
+                             tun_key->ipv4_dst, IPPROTO_GRE,
+                             tun_key->ipv4_tos, tun_key->ipv4_ttl, df, false);
 err_free_rt:
         ip_rt_put(rt);
 error:
diff --git a/net/openvswitch/vport-vxlan.c b/net/openvswitch/vport-vxlan.c
index d8b7e247bebf..f19539bb8adc 100644
--- a/net/openvswitch/vport-vxlan.c
+++ b/net/openvswitch/vport-vxlan.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Nicira, Inc.
+ * Copyright (c) 2014 Nicira, Inc.
  * Copyright (c) 2013 Cisco Systems, Inc.
  *
  * This program is free software; you can redistribute it and/or
@@ -140,22 +140,24 @@ static int vxlan_tnl_send(struct vport *vport, struct sk_buff *skb)
         struct net *net = ovs_dp_get_net(vport->dp);
         struct vxlan_port *vxlan_port = vxlan_vport(vport);
         __be16 dst_port = inet_sk(vxlan_port->vs->sock->sk)->inet_sport;
+        struct ovs_key_ipv4_tunnel *tun_key;
         struct rtable *rt;
         struct flowi4 fl;
         __be16 src_port;
         __be16 df;
         int err;
 
-        if (unlikely(!OVS_CB(skb)->tun_key)) {
+        if (unlikely(!OVS_CB(skb)->egress_tun_key)) {
                 err = -EINVAL;
                 goto error;
         }
 
+        tun_key = OVS_CB(skb)->egress_tun_key;
         /* Route lookup */
         memset(&fl, 0, sizeof(fl));
-        fl.daddr = OVS_CB(skb)->tun_key->ipv4_dst;
-        fl.saddr = OVS_CB(skb)->tun_key->ipv4_src;
-        fl.flowi4_tos = RT_TOS(OVS_CB(skb)->tun_key->ipv4_tos);
+        fl.daddr = tun_key->ipv4_dst;
+        fl.saddr = tun_key->ipv4_src;
+        fl.flowi4_tos = RT_TOS(tun_key->ipv4_tos);
         fl.flowi4_mark = skb->mark;
         fl.flowi4_proto = IPPROTO_UDP;
 
@@ -165,7 +167,7 @@ static int vxlan_tnl_send(struct vport *vport, struct sk_buff *skb)
                 goto error;
         }
 
-        df = OVS_CB(skb)->tun_key->tun_flags & TUNNEL_DONT_FRAGMENT ?
+        df = tun_key->tun_flags & TUNNEL_DONT_FRAGMENT ?
                 htons(IP_DF) : 0;
 
         skb->ignore_df = 1;
@@ -173,11 +175,10 @@ static int vxlan_tnl_send(struct vport *vport, struct sk_buff *skb)
         src_port = udp_flow_src_port(net, skb, 0, 0, true);
 
         err = vxlan_xmit_skb(vxlan_port->vs, rt, skb,
-                             fl.saddr, OVS_CB(skb)->tun_key->ipv4_dst,
-                             OVS_CB(skb)->tun_key->ipv4_tos,
-                             OVS_CB(skb)->tun_key->ipv4_ttl, df,
+                             fl.saddr, tun_key->ipv4_dst,
+                             tun_key->ipv4_tos, tun_key->ipv4_ttl, df,
                              src_port, dst_port,
-                             htonl(be64_to_cpu(OVS_CB(skb)->tun_key->tun_id) << 8),
+                             htonl(be64_to_cpu(tun_key->tun_id) << 8),
                              false);
         if (err < 0)
                 ip_rt_put(rt);
diff --git a/net/openvswitch/vport.c b/net/openvswitch/vport.c
index f7e63f9df7b9..5df8377fcfb1 100644
--- a/net/openvswitch/vport.c
+++ b/net/openvswitch/vport.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2012 Nicira, Inc.
+ * Copyright (c) 2007-2014 Nicira, Inc.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
@@ -435,6 +435,8 @@ void ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
                        struct ovs_key_ipv4_tunnel *tun_key)
 {
         struct pcpu_sw_netstats *stats;
+        struct sw_flow_key key;
+        int error;
 
         stats = this_cpu_ptr(vport->percpu_stats);
         u64_stats_update_begin(&stats->syncp);
@@ -442,8 +444,15 @@ void ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
         stats->rx_bytes += skb->len;
         u64_stats_update_end(&stats->syncp);
 
-        OVS_CB(skb)->tun_key = tun_key;
-        ovs_dp_process_received_packet(vport, skb);
+        OVS_CB(skb)->input_vport = vport;
+        OVS_CB(skb)->egress_tun_key = NULL;
+        /* Extract flow from 'skb' into 'key'. */
+        error = ovs_flow_key_extract(tun_key, skb, &key);
+        if (unlikely(error)) {
+                kfree_skb(skb);
+                return;
+        }
+        ovs_dp_process_packet(skb, &key);
 }
 
 /**