Datapath: Bug fix: kernel rejects mega flow with encap masks

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

diff --git a/datapath/flow.c b/datapath/flow.c
index 3a7bc9b..778771f 100644 (file)
--- a/datapath/flow.c
+++ b/datapath/flow.c
@@ -443,7 +443,7 @@ static void free_buckets(struct flex_array *buckets)
        flex_array_free(buckets);
 }
 
-struct flow_table *ovs_flow_tbl_alloc(int new_size)
+static struct flow_table *__flow_tbl_alloc(int new_size)
 {
        struct flow_table *table = kmalloc(sizeof(*table), GFP_KERNEL);
 
@@ -461,7 +461,7 @@ struct flow_table *ovs_flow_tbl_alloc(int new_size)
        table->node_ver = 0;
        table->keep_flows = false;
        get_random_bytes(&table->hash_seed, sizeof(u32));
-       INIT_LIST_HEAD(&table->mask_list);
+       table->mask_list = NULL;
 
        return table;
 }
@@ -485,11 +485,32 @@ static void __flow_tbl_destroy(struct flow_table *table)
                }
        }
 
+       BUG_ON(!list_empty(table->mask_list));
+       kfree(table->mask_list);
+
 skip_flows:
        free_buckets(table->buckets);
        kfree(table);
 }
 
+struct flow_table *ovs_flow_tbl_alloc(int new_size)
+{
+       struct flow_table *table = __flow_tbl_alloc(new_size);
+
+       if (!table)
+               return NULL;
+
+       table->mask_list = kmalloc(sizeof(struct list_head), GFP_KERNEL);
+       if (!table->mask_list) {
+               table->keep_flows = true;
+               __flow_tbl_destroy(table);
+               return NULL;
+       }
+       INIT_LIST_HEAD(table->mask_list);
+
+       return table;
+}
+
 static void flow_tbl_destroy_rcu_cb(struct rcu_head *rcu)
 {
        struct flow_table *table = container_of(rcu, struct flow_table, rcu);
@@ -571,7 +592,7 @@ static struct flow_table *__flow_tbl_rehash(struct flow_table *table, int n_buck
 {
        struct flow_table *new_table;
 
-       new_table = ovs_flow_tbl_alloc(n_buckets);
+       new_table = __flow_tbl_alloc(n_buckets);
        if (!new_table)
                return ERR_PTR(-ENOMEM);
 
@@ -1030,7 +1051,7 @@ struct sw_flow *ovs_flow_lookup(struct flow_table *tbl,
        struct sw_flow *flow = NULL;
        struct sw_flow_mask *mask;
 
-       list_for_each_entry_rcu(mask, &tbl->mask_list, list) {
+       list_for_each_entry_rcu(mask, tbl->mask_list, list) {
                flow = ovs_masked_flow_lookup(tbl, key, mask);
                if (flow)  /* Found */
                        break;
@@ -1146,7 +1167,7 @@ int ipv4_tun_from_nlattr(const struct nlattr *attr,
        struct nlattr *a;
        int rem;
        bool ttl = false;
-       u16 tun_flags = 0;
+       __be16 tun_flags = 0;
 
        nla_for_each_nested(a, attr, rem) {
                int type = nla_type(a);
@@ -1168,7 +1189,7 @@ int ipv4_tun_from_nlattr(const struct nlattr *attr,
                case OVS_TUNNEL_KEY_ATTR_ID:
                        SW_FLOW_KEY_PUT(match, tun_key.tun_id,
                                        nla_get_be64(a), is_mask);
-                       tun_flags |= OVS_TNL_F_KEY;
+                       tun_flags |= TUNNEL_KEY;
                        break;
                case OVS_TUNNEL_KEY_ATTR_IPV4_SRC:
                        SW_FLOW_KEY_PUT(match, tun_key.ipv4_src,
@@ -1188,10 +1209,10 @@ int ipv4_tun_from_nlattr(const struct nlattr *attr,
                        ttl = true;
                        break;
                case OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT:
-                       tun_flags |= OVS_TNL_F_DONT_FRAGMENT;
+                       tun_flags |= TUNNEL_DONT_FRAGMENT;
                        break;
                case OVS_TUNNEL_KEY_ATTR_CSUM:
-                       tun_flags |= OVS_TNL_F_CSUM;
+                       tun_flags |= TUNNEL_CSUM;
                        break;
                default:
                        return -EINVAL;
@@ -1222,7 +1243,7 @@ int ipv4_tun_to_nlattr(struct sk_buff *skb,
        if (!nla)
                return -EMSGSIZE;
 
-       if (tun_key->tun_flags & OVS_TNL_F_KEY &&
+       if (tun_key->tun_flags & TUNNEL_KEY &&
            nla_put_be64(skb, OVS_TUNNEL_KEY_ATTR_ID, output->tun_id))
                return -EMSGSIZE;
        if (tun_key->ipv4_src &&
@@ -1235,10 +1256,10 @@ int ipv4_tun_to_nlattr(struct sk_buff *skb,
                return -EMSGSIZE;
        if (nla_put_u8(skb, OVS_TUNNEL_KEY_ATTR_TTL, output->ipv4_ttl))
                return -EMSGSIZE;
-       if ((tun_key->tun_flags & OVS_TNL_F_DONT_FRAGMENT) &&
+       if ((tun_key->tun_flags & TUNNEL_DONT_FRAGMENT) &&
                nla_put_flag(skb, OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT))
                return -EMSGSIZE;
-       if ((tun_key->tun_flags & OVS_TNL_F_CSUM) &&
+       if ((tun_key->tun_flags & TUNNEL_CSUM) &&
                nla_put_flag(skb, OVS_TUNNEL_KEY_ATTR_CSUM))
                return -EMSGSIZE;
 
@@ -1287,6 +1308,7 @@ static int ovs_key_from_nlattrs(struct sw_flow_match *match,  u64 attrs,
                const struct nlattr **a, bool is_mask)
 {
        int err;
+       u64 orig_attrs = attrs;
 
        err = metadata_from_nlattrs(match, &attrs, a, is_mask);
        if (err)
@@ -1401,10 +1423,17 @@ static int ovs_key_from_nlattrs(struct sw_flow_match *match,  u64 attrs,
                const struct ovs_key_tcp *tcp_key;
 
                tcp_key = nla_data(a[OVS_KEY_ATTR_TCP]);
-               SW_FLOW_KEY_PUT(match, ipv4.tp.src,
-                               tcp_key->tcp_src, is_mask);
-               SW_FLOW_KEY_PUT(match, ipv4.tp.dst,
-                               tcp_key->tcp_dst, is_mask);
+               if (orig_attrs & (1ULL << OVS_KEY_ATTR_IPV4)) {
+                       SW_FLOW_KEY_PUT(match, ipv4.tp.src,
+                                       tcp_key->tcp_src, is_mask);
+                       SW_FLOW_KEY_PUT(match, ipv4.tp.dst,
+                                       tcp_key->tcp_dst, is_mask);
+               } else {
+                       SW_FLOW_KEY_PUT(match, ipv6.tp.src,
+                                       tcp_key->tcp_src, is_mask);
+                       SW_FLOW_KEY_PUT(match, ipv6.tp.dst,
+                                       tcp_key->tcp_dst, is_mask);
+               }
                attrs &= ~(1ULL << OVS_KEY_ATTR_TCP);
        }
 
@@ -1412,10 +1441,17 @@ static int ovs_key_from_nlattrs(struct sw_flow_match *match,  u64 attrs,
                const struct ovs_key_udp *udp_key;
 
                udp_key = nla_data(a[OVS_KEY_ATTR_UDP]);
-               SW_FLOW_KEY_PUT(match, ipv4.tp.src,
-                               udp_key->udp_src, is_mask);
-               SW_FLOW_KEY_PUT(match, ipv4.tp.dst,
-                               udp_key->udp_dst, is_mask);
+               if (orig_attrs & (1ULL << OVS_KEY_ATTR_IPV4)) {
+                       SW_FLOW_KEY_PUT(match, ipv4.tp.src,
+                                       udp_key->udp_src, is_mask);
+                       SW_FLOW_KEY_PUT(match, ipv4.tp.dst,
+                                       udp_key->udp_dst, is_mask);
+               } else {
+                       SW_FLOW_KEY_PUT(match, ipv6.tp.src,
+                                       udp_key->udp_src, is_mask);
+                       SW_FLOW_KEY_PUT(match, ipv6.tp.dst,
+                                       udp_key->udp_dst, is_mask);
+               }
                attrs &= ~(1ULL << OVS_KEY_ATTR_UDP);
        }
 
@@ -1522,6 +1558,7 @@ int ovs_match_from_nlattrs(struct sw_flow_match *match,
                if ((mask_attrs & 1ULL << OVS_KEY_ATTR_ENCAP) && encap_valid) {
                        __be16 eth_type = 0;
 
+                       mask_attrs &= ~(1ULL << OVS_KEY_ATTR_ENCAP);
                        if (a[OVS_KEY_ATTR_ETHERTYPE])
                                eth_type = nla_get_be16(a[OVS_KEY_ATTR_ETHERTYPE]);
                        if (eth_type == htons(0xffff)) {
@@ -1580,7 +1617,8 @@ int ovs_flow_metadata_from_nlattrs(struct sw_flow *flow,
        if (err)
                return -EINVAL;
 
-       ovs_match_init(&match, &flow->key, NULL);
+       memset(&match, 0, sizeof(match));
+       match.key = &flow->key;
 
        err = metadata_from_nlattrs(&match, &attrs, a, false);
        if (err)
@@ -1843,7 +1881,7 @@ struct sw_flow_mask *ovs_sw_flow_mask_find(const struct flow_table *tbl,
 {
        struct list_head *ml;
 
-       list_for_each(ml, &tbl->mask_list) {
+       list_for_each(ml, tbl->mask_list) {
                struct sw_flow_mask *m;
                m = container_of(ml, struct sw_flow_mask, list);
                if (ovs_sw_flow_mask_equal(mask, m))
@@ -1860,7 +1898,7 @@ struct sw_flow_mask *ovs_sw_flow_mask_find(const struct flow_table *tbl,
  */
 void ovs_sw_flow_mask_insert(struct flow_table *tbl, struct sw_flow_mask *mask)
 {
-       list_add_rcu(&mask->list, &tbl->mask_list);
+       list_add_rcu(&mask->list, tbl->mask_list);
 }
 
 /**