X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;ds=sidebyside;f=lib%2Fmultipath.c;h=e85829a0619ed114ff3b77330b728c912524fd7f;hb=refs%2Fheads%2Freview;hp=7d4b541ed42922bcdd8be0d32ee23b81debd0130;hpb=53ddd40ab56b6c31a2ced6b984c33ae27f458101;p=sliver-openvswitch.git diff --git a/lib/multipath.c b/lib/multipath.c index 7d4b541ed..e85829a06 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. @@ -17,6 +17,7 @@ #include #include "multipath.h" +#include #include #include #include @@ -33,14 +34,20 @@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); /* multipath_check(). */ int -multipath_check(const struct nx_action_multipath *mp) +multipath_check(const struct nx_action_multipath *mp, const struct flow *flow) { - uint32_t dst = ntohl(mp->dst); + uint32_t n_links = ntohs(mp->max_link) + 1; + size_t min_n_bits = log_2_floor(n_links) + 1; int ofs = nxm_decode_ofs(mp->ofs_nbits); int n_bits = nxm_decode_n_bits(mp->ofs_nbits); + int error; - if (mp->fields != htons(NX_MP_FIELDS_ETH_SRC) - && mp->fields != htons(NX_MP_FIELDS_SYMMETRIC_L4)) { + error = nxm_dst_check(mp->dst, ofs, n_bits, flow); + if (error) { + return error; + } + + 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) @@ -48,12 +55,9 @@ multipath_check(const struct nx_action_multipath *mp) && mp->algorithm != htons(NX_MP_ALG_ITER_HASH)) { VLOG_WARN_RL(&rl, "unsupported algorithm %"PRIu16, ntohs(mp->algorithm)); - } else if (!NXM_IS_NX_REG(dst) || NXM_NX_REG_IDX(dst) >= FLOW_N_REGS) { - VLOG_WARN_RL(&rl, "unsupported destination field %#"PRIx32, dst); - } else if (ofs + n_bits > nxm_field_bits(dst)) { - VLOG_WARN_RL(&rl, "destination overflows output field"); - } else if (n_bits < 16 && ntohs(mp->max_link) > (1u << n_bits)) { - VLOG_WARN_RL(&rl, "max_link overflows output field"); + } else if (n_bits < min_n_bits) { + VLOG_WARN_RL(&rl, "multipath action requires at least %zu bits for " + "%"PRIu32" links", min_n_bits, n_links); } else { return 0; } @@ -63,8 +67,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); @@ -72,67 +74,13 @@ 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)); - /* Store it. */ - uint32_t *reg = &flow->regs[NXM_NX_REG_IDX(ntohl(mp->dst))]; - int ofs = nxm_decode_ofs(mp->ofs_nbits); - int n_bits = nxm_decode_n_bits(mp->ofs_nbits); - uint32_t mask = n_bits == 32 ? UINT32_MAX : (UINT32_C(1) << n_bits) - 1; - *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; - - 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(); + nxm_reg_load(mp->dst, mp->ofs_nbits, link, flow); } static uint16_t @@ -193,7 +141,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 @@ -214,18 +165,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); @@ -234,11 +186,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")) { @@ -250,12 +202,22 @@ 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); } - mp->max_link = htons(atoi(n_links) - 1); + 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(n_links - 1); mp->arg = htonl(atoi(arg)); nxm_parse_field_bits(dst, &header, &ofs, &n_bits); + 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); @@ -267,18 +229,12 @@ multipath_format(const struct nx_action_multipath *mp, struct ds *s) { const char *fields, *algorithm; - switch ((enum nx_mp_fields) ntohs(mp->fields)) { - case NX_MP_FIELDS_ETH_SRC: - fields = "eth_src"; - break; - case NX_MP_FIELDS_SYMMETRIC_L4: - fields = "symmetric_l4"; - break; - default: - fields = ""; - } + uint16_t mp_fields = ntohs(mp->fields); + uint16_t mp_algorithm = ntohs(mp->algorithm); + + fields = flow_hash_fields_to_str(mp_fields); - switch ((enum nx_mp_algorithm) ntohs(mp->algorithm)) { + switch ((enum nx_mp_algorithm) mp_algorithm) { case NX_MP_ALG_MODULO_N: algorithm = "modulo_n"; break;