datapath: handle recirculation loop detection

[sliver-openvswitch.git] / datapath / actions.c

diff --git a/datapath/actions.c b/datapath/actions.c
index 82cfd2d..f71f1f6 100644 (file)
--- a/datapath/actions.c
+++ b/datapath/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
@@ -460,6 +460,21 @@ static int sample(struct datapath *dp, struct sk_buff *skb,
                                  nla_len(acts_list), true);
 }
 
+static void execute_hash(struct sk_buff *skb, const struct nlattr *attr)
+{
+       struct sw_flow_key *key = OVS_CB(skb)->pkt_key;
+       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_rxhash(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,
                                 const struct nlattr *nested_attr)
 {
@@ -506,6 +521,26 @@ static int execute_set_action(struct sk_buff *skb,
        return err;
 }
 
+static int execute_recirc(struct datapath *dp, struct sk_buff *skb,
+                                const struct nlattr *a)
+{
+       struct sw_flow_key recirc_key;
+       const struct vport *p = OVS_CB(skb)->input_vport;
+       uint32_t hash = OVS_CB(skb)->pkt_key->ovs_flow_hash;
+       int err;
+
+       err = ovs_flow_extract(skb, p->port_no, &recirc_key);
+       if (err)
+               return err;
+
+       recirc_key.ovs_flow_hash = hash;
+       recirc_key.recirc_id = nla_get_u32(a);
+
+       ovs_dp_process_packet_with_key(skb, &recirc_key, true);
+
+       return 0;
+}
+
 /* Execute a list of actions against 'skb'. */
 static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
                        const struct nlattr *attr, int len, bool keep_skb)
@@ -536,6 +571,10 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
                        output_userspace(dp, skb, a);
                        break;
 
+               case OVS_ACTION_ATTR_HASH:
+                       execute_hash(skb, a);
+                       break;
+
                case OVS_ACTION_ATTR_PUSH_VLAN:
                        err = push_vlan(skb, nla_data(a));
                        if (unlikely(err)) /* skb already freed. */
@@ -546,6 +585,23 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
                        err = pop_vlan(skb);
                        break;
 
+               case OVS_ACTION_ATTR_RECIRC: {
+                       struct sk_buff *recirc_skb;
+                       const bool last_action = (a->nla_len == rem);
+
+                       if (!last_action || keep_skb)
+                               recirc_skb = skb_clone(skb, GFP_ATOMIC);
+                       else
+                               recirc_skb = skb;
+
+                       err = execute_recirc(dp, recirc_skb, a);
+
+                       if (last_action || err)
+                               return err;
+
+                       break;
+               }
+
                case OVS_ACTION_ATTR_SET:
                        err = execute_set_action(skb, nla_data(a));
                        break;
@@ -575,11 +631,18 @@ static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
 }
 
 /* We limit the number of times that we pass into execute_actions()
- * to avoid blowing out the stack in the event that we have a loop. */
-#define MAX_LOOPS 4
+ * to avoid blowing out the stack in the event that we have a loop.
+ *
+ * Each loop adds some (estimated) cost to the kernel stack.
+ * The loop terminates when the max cost is exceeded.
+ * */
+#define RECIRC_STACK_COST 1
+#define DEFAULT_STACK_COST 4
+/* Allow up to 4 regular services, and up to 3 recirculations */
+#define MAX_STACK_COST (DEFAULT_STACK_COST * 4 + RECIRC_STACK_COST * 3)
 
 struct loop_counter {
-       u8 count;               /* Count. */
+       u8 stack_cost;          /* loop stack cost. */
        bool looping;           /* Loop detected? */
 };
 
@@ -588,22 +651,24 @@ static DEFINE_PER_CPU(struct loop_counter, loop_counters);
 static int loop_suppress(struct datapath *dp, struct sw_flow_actions *actions)
 {
        if (net_ratelimit())
-               pr_warn("%s: flow looped %d times, dropping\n",
-                               ovs_dp_name(dp), MAX_LOOPS);
+               pr_warn("%s: flow loop detected, dropping\n",
+                               ovs_dp_name(dp));
        actions->actions_len = 0;
        return -ELOOP;
 }
 
 /* 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, bool recirc)
 {
        struct sw_flow_actions *acts = rcu_dereference(OVS_CB(skb)->flow->sf_acts);
+       const u8 stack_cost = recirc ? RECIRC_STACK_COST : DEFAULT_STACK_COST;
        struct loop_counter *loop;
        int error;
 
        /* Check whether we've looped too much. */
        loop = &__get_cpu_var(loop_counters);
-       if (unlikely(++loop->count > MAX_LOOPS))
+       loop->stack_cost += stack_cost;
+       if (unlikely(loop->stack_cost > MAX_STACK_COST))
                loop->looping = true;
        if (unlikely(loop->looping)) {
                error = loop_suppress(dp, acts);
@@ -620,8 +685,9 @@ int ovs_execute_actions(struct datapath *dp, struct sk_buff *skb)
                error = loop_suppress(dp, acts);
 
 out_loop:
-       /* Decrement loop counter. */
-       if (!--loop->count)
+       /* Decrement loop stack cost. */
+       loop->stack_cost -= stack_cost;
+       if (!loop->stack_cost)
                loop->looping = false;
 
        return error;