X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fmultipath.c;h=4ee6fd025e4062ad664d00212537349a8086916d;hb=520e9a2acdcf6136bf0a20586df6351ecf72dd3e;hp=af0ebffe4284955bfdfaa275de3a4becfa08d4a5;hpb=19f62195a5d7f92bd22482db746d830c7cde40c4;p=openvswitch

diff --git a/lib/multipath.c b/lib/multipath.c
index af0ebffe..4ee6fd02 100644
--- a/lib/multipath.c
+++ b/lib/multipath.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010 Nicira Networks.
+ * Copyright (c) 2010, 2011 Nicira Networks.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,8 +40,7 @@ multipath_check(const struct nx_action_multipath *mp)
     int ofs = nxm_decode_ofs(mp->ofs_nbits);
     int n_bits = nxm_decode_n_bits(mp->ofs_nbits);
 
-    if (mp->fields != htons(NX_MP_FIELDS_ETH_SRC)
-        && mp->fields != htons(NX_MP_FIELDS_SYMMETRIC_L4)) {
+    if (!flow_hash_fields_valid(ntohs(mp->fields))) {
         VLOG_WARN_RL(&rl, "unsupported fields %"PRIu16, ntohs(mp->fields));
     } else if (mp->algorithm != htons(NX_MP_ALG_MODULO_N)
                && mp->algorithm != htons(NX_MP_ALG_HASH_THRESHOLD)
@@ -64,8 +63,6 @@ multipath_check(const struct nx_action_multipath *mp)
 
 /* multipath_execute(). */
 
-static uint32_t multipath_hash(const struct flow *, enum nx_mp_fields,
-                               uint16_t basis);
 static uint16_t multipath_algorithm(uint32_t hash, enum nx_mp_algorithm,
                                     unsigned int n_links, unsigned int arg);
 
@@ -73,7 +70,8 @@ void
 multipath_execute(const struct nx_action_multipath *mp, struct flow *flow)
 {
     /* Calculate value to store. */
-    uint32_t hash = multipath_hash(flow, ntohs(mp->fields), ntohs(mp->basis));
+    uint32_t hash = flow_hash_fields(flow, ntohs(mp->fields),
+                                     ntohs(mp->basis));
     uint16_t link = multipath_algorithm(hash, ntohs(mp->algorithm),
                                         ntohs(mp->max_link) + 1,
                                         ntohl(mp->arg));
@@ -86,57 +84,6 @@ multipath_execute(const struct nx_action_multipath *mp, struct flow *flow)
     *reg = (*reg & ~(mask << ofs)) | (link << ofs);
 }
 
-static uint32_t
-hash_symmetric_l4(const struct flow *flow, uint16_t basis)
-{
-    struct {
-        ovs_be32 ip_addr;
-        ovs_be16 eth_type;
-        ovs_be16 vlan_tci;
-        ovs_be16 tp_addr;
-        uint8_t eth_addr[ETH_ADDR_LEN];
-        uint8_t ip_proto;
-    } fields;
-
-    int i;
-
-    memset(&fields, 0, sizeof fields);
-    for (i = 0; i < ETH_ADDR_LEN; i++) {
-        fields.eth_addr[i] = flow->dl_src[i] ^ flow->dl_dst[i];
-    }
-    fields.vlan_tci = flow->vlan_tci & htons(VLAN_VID_MASK);
-    fields.eth_type = flow->dl_type;
-    if (fields.eth_type == htons(ETH_TYPE_IP)) {
-        fields.ip_addr = flow->nw_src ^ flow->nw_dst;
-        fields.ip_proto = flow->nw_proto;
-        if (fields.ip_proto == IP_TYPE_TCP || fields.ip_proto == IP_TYPE_UDP) {
-            fields.tp_addr = flow->tp_src ^ flow->tp_dst;
-        } else {
-            fields.tp_addr = htons(0);
-        }
-    } else {
-        fields.ip_addr = htonl(0);
-        fields.ip_proto = 0;
-        fields.tp_addr = htons(0);
-    }
-    return hash_bytes(&fields, sizeof fields, basis);
-}
-
-static uint32_t
-multipath_hash(const struct flow *flow, enum nx_mp_fields fields,
-               uint16_t basis)
-{
-    switch (fields) {
-    case NX_MP_FIELDS_ETH_SRC:
-        return hash_bytes(flow->dl_src, sizeof flow->dl_src, basis);
-
-    case NX_MP_FIELDS_SYMMETRIC_L4:
-        return hash_symmetric_l4(flow, basis);
-    }
-
-    NOT_REACHED();
-}
-
 static uint16_t
 algorithm_hrw(uint32_t hash, unsigned int n_links)
 {
@@ -195,7 +142,10 @@ multipath_algorithm(uint32_t hash, enum nx_mp_algorithm algorithm,
         return hash % n_links;
 
     case NX_MP_ALG_HASH_THRESHOLD:
-        return hash / (UINT32_MAX / n_links);
+        if (n_links == 1) {
+            return 0;
+        }
+        return hash / (UINT32_MAX / n_links + 1);
 
     case NX_MP_ALG_HRW:
         return (n_links <= 64
@@ -216,18 +166,19 @@ multipath_parse(struct nx_action_multipath *mp, const char *s_)
 {
     char *s = xstrdup(s_);
     char *save_ptr = NULL;
-    char *fields, *basis, *algorithm, *n_links, *arg, *dst;
+    char *fields, *basis, *algorithm, *n_links_str, *arg, *dst;
     uint32_t header;
     int ofs, n_bits;
+    int n_links;
 
     fields = strtok_r(s, ", ", &save_ptr);
     basis = strtok_r(NULL, ", ", &save_ptr);
     algorithm = strtok_r(NULL, ", ", &save_ptr);
-    n_links = strtok_r(NULL, ", ", &save_ptr);
+    n_links_str = strtok_r(NULL, ", ", &save_ptr);
     arg = strtok_r(NULL, ", ", &save_ptr);
     dst = strtok_r(NULL, ", ", &save_ptr);
     if (!dst) {
-        ovs_fatal(0, "%s: not enough arguments to multipath action", s);
+        ovs_fatal(0, "%s: not enough arguments to multipath action", s_);
     }
 
     memset(mp, 0, sizeof *mp);
@@ -236,11 +187,11 @@ multipath_parse(struct nx_action_multipath *mp, const char *s_)
     mp->vendor = htonl(NX_VENDOR_ID);
     mp->subtype = htons(NXAST_MULTIPATH);
     if (!strcasecmp(fields, "eth_src")) {
-        mp->fields = htons(NX_MP_FIELDS_ETH_SRC);
+        mp->fields = htons(NX_HASH_FIELDS_ETH_SRC);
     } else if (!strcasecmp(fields, "symmetric_l4")) {
-        mp->fields = htons(NX_MP_FIELDS_SYMMETRIC_L4);
+        mp->fields = htons(NX_HASH_FIELDS_SYMMETRIC_L4);
     } else {
-        ovs_fatal(0, "%s: unknown fields `%s'", s, fields);
+        ovs_fatal(0, "%s: unknown fields `%s'", s_, fields);
     }
     mp->basis = htons(atoi(basis));
     if (!strcasecmp(algorithm, "modulo_n")) {
@@ -252,12 +203,25 @@ multipath_parse(struct nx_action_multipath *mp, const char *s_)
     } else if (!strcasecmp(algorithm, "iter_hash")) {
         mp->algorithm = htons(NX_MP_ALG_ITER_HASH);
     } else {
-        ovs_fatal(0, "%s: unknown algorithm `%s'", s, algorithm);
+        ovs_fatal(0, "%s: unknown algorithm `%s'", s_, algorithm);
+    }
+    n_links = atoi(n_links_str);
+    if (n_links < 1 || n_links > 65536) {
+        ovs_fatal(0, "%s: n_links %d is not in valid range 1 to 65536",
+                  s_, n_links);
     }
-    mp->max_link = htons(atoi(n_links) - 1);
+    mp->max_link = htons(n_links - 1);
     mp->arg = htonl(atoi(arg));
 
     nxm_parse_field_bits(dst, &header, &ofs, &n_bits);
+    if (!NXM_IS_NX_REG(header) || NXM_NX_REG_IDX(header) >= FLOW_N_REGS) {
+        ovs_fatal(0, "%s: destination field must be register", s_);
+    }
+    if (n_bits < 16 && n_links > (1u << n_bits)) {
+        ovs_fatal(0, "%s: %d-bit destination field has %u possible values, "
+                  "less than specified n_links %d",
+                  s_, n_bits, 1u << n_bits, n_links);
+    }
     mp->ofs_nbits = nxm_encode_ofs_nbits(ofs, n_bits);
     mp->dst = htonl(header);
 
@@ -272,16 +236,7 @@ multipath_format(const struct nx_action_multipath *mp, struct ds *s)
     uint16_t mp_fields    = ntohs(mp->fields);
     uint16_t mp_algorithm = ntohs(mp->algorithm);
 
-    switch ((enum nx_mp_fields) mp_fields) {
-    case NX_MP_FIELDS_ETH_SRC:
-        fields = "eth_src";
-        break;
-    case NX_MP_FIELDS_SYMMETRIC_L4:
-        fields = "symmetric_l4";
-        break;
-    default:
-        fields = "<unknown>";
-    }
+    fields = flow_hash_fields_to_str(mp_fields);
 
     switch ((enum nx_mp_algorithm) mp_algorithm) {
     case NX_MP_ALG_MODULO_N: