X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fmultipath.c;h=a6f549ca6715ff138710d4f92f6fb748eaeb0062;hb=7d78f21c057ff50a823220d809ac38c3d907243c;hp=13f88ff023474151156a6abd69c32a12a13ef6b2;hpb=7cfb3c26b2abb82e95bbecaaf78317e7e7e343d4;p=sliver-openvswitch.git diff --git a/lib/multipath.c b/lib/multipath.c index 13f88ff02..a6f549ca6 100644 --- a/lib/multipath.c +++ b/lib/multipath.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010 Nicira Networks. + * Copyright (c) 2010, 2011, 2012, 2013 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,11 +17,14 @@ #include #include "multipath.h" +#include #include #include #include #include "dynamic-string.h" #include "nx-match.h" +#include "ofp-actions.h" +#include "ofp-errors.h" #include "ofp-util.h" #include "openflow/nicira-ext.h" #include "packets.h" @@ -31,109 +34,87 @@ VLOG_DEFINE_THIS_MODULE(multipath); static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); -/* multipath_check(). */ -int -multipath_check(const struct nx_action_multipath *mp) +/* Converts 'nam' into 'mp'. Returns 0 if successful, otherwise an + * OFPERR_*. */ +enum ofperr +multipath_from_openflow(const struct nx_action_multipath *nam, + struct ofpact_multipath *mp) { - uint32_t dst = ntohl(mp->dst); - 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)) { - 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) - && mp->algorithm != htons(NX_MP_ALG_HRW) - && 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 { - return 0; + uint32_t n_links = ntohs(nam->max_link) + 1; + size_t min_n_bits = log_2_ceil(n_links); + + ofpact_init_MULTIPATH(mp); + mp->fields = ntohs(nam->fields); + mp->basis = ntohs(nam->basis); + mp->algorithm = ntohs(nam->algorithm); + mp->max_link = ntohs(nam->max_link); + mp->arg = ntohl(nam->arg); + mp->dst.field = mf_from_nxm_header(ntohl(nam->dst)); + mp->dst.ofs = nxm_decode_ofs(nam->ofs_nbits); + mp->dst.n_bits = nxm_decode_n_bits(nam->ofs_nbits); + + if (!flow_hash_fields_valid(mp->fields)) { + VLOG_WARN_RL(&rl, "unsupported fields %d", (int) mp->fields); + return OFPERR_OFPBAC_BAD_ARGUMENT; + } else if (mp->algorithm != NX_MP_ALG_MODULO_N + && mp->algorithm != NX_MP_ALG_HASH_THRESHOLD + && mp->algorithm != NX_MP_ALG_HRW + && mp->algorithm != NX_MP_ALG_ITER_HASH) { + VLOG_WARN_RL(&rl, "unsupported algorithm %d", (int) mp->algorithm); + return OFPERR_OFPBAC_BAD_ARGUMENT; + } else if (mp->dst.n_bits < min_n_bits) { + VLOG_WARN_RL(&rl, "multipath action requires at least %"PRIuSIZE" bits for " + "%"PRIu32" links", min_n_bits, n_links); + return OFPERR_OFPBAC_BAD_ARGUMENT; } - return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); + return multipath_check(mp, NULL); +} + +/* Checks that 'mp' is valid on flow. Returns 0 if it is valid, otherwise an + * OFPERR_*. */ +enum ofperr +multipath_check(const struct ofpact_multipath *mp, + const struct flow *flow) +{ + return mf_check_dst(&mp->dst, flow); +} + +/* Converts 'mp' into an OpenFlow NXAST_MULTIPATH action, which it appends to + * 'openflow'. */ +void +multipath_to_nxast(const struct ofpact_multipath *mp, struct ofpbuf *openflow) +{ + struct nx_action_multipath *nam = ofputil_put_NXAST_MULTIPATH(openflow); + + nam->fields = htons(mp->fields); + nam->basis = htons(mp->basis); + nam->algorithm = htons(mp->algorithm); + nam->max_link = htons(mp->max_link); + nam->arg = htonl(mp->arg); + nam->ofs_nbits = nxm_encode_ofs_nbits(mp->dst.ofs, mp->dst.n_bits); + nam->dst = htonl(mp->dst.field->nxm_header); } /* 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); +/* Executes 'mp' based on the current contents of 'flow', writing the results + * back into 'flow'. Sets fields in 'wc' that were used to calculate + * the result. */ void -multipath_execute(const struct nx_action_multipath *mp, struct flow *flow) +multipath_execute(const struct ofpact_multipath *mp, struct flow *flow, + struct flow_wildcards *wc) { /* Calculate value to store. */ - uint32_t hash = multipath_hash(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; - - 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); - } + uint32_t hash = flow_hash_fields(flow, mp->fields, mp->basis); + uint16_t link = multipath_algorithm(hash, mp->algorithm, + mp->max_link + 1, mp->arg); - NOT_REACHED(); + flow_mask_hash_fields(flow, wc, mp->fields); + nxm_reg_load(&mp->dst, link, flow, wc); } static uint16_t @@ -194,7 +175,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 @@ -205,81 +189,97 @@ multipath_algorithm(uint32_t hash, enum nx_mp_algorithm algorithm, return algorithm_iter_hash(hash, n_links, arg); } - NOT_REACHED(); + OVS_NOT_REACHED(); } -/* multipath_parse(). */ - -void -multipath_parse(struct nx_action_multipath *mp, const char *s_) +/* Parses 's_' as a set of arguments to the "multipath" action and initializes + * 'mp' accordingly. ovs-ofctl(8) describes the format parsed. + * + * Returns NULL if successful, otherwise a malloc()'d string describing the + * error. The caller is responsible for freeing the returned string.*/ +static char * WARN_UNUSED_RESULT +multipath_parse__(struct ofpact_multipath *mp, const char *s_, char *s) { - char *s = xstrdup(s_); char *save_ptr = NULL; - char *fields, *basis, *algorithm, *n_links, *arg, *dst; - uint32_t header; - int ofs, n_bits; + char *fields, *basis, *algorithm, *n_links_str, *arg, *dst; + char *error; + 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); + return xasprintf("%s: not enough arguments to multipath action", s_); } - memset(mp, 0, sizeof *mp); - mp->type = htons(OFPAT_VENDOR); - mp->len = htons(sizeof *mp); - mp->vendor = htonl(NX_VENDOR_ID); - mp->subtype = htons(NXAST_MULTIPATH); + ofpact_init_MULTIPATH(mp); if (!strcasecmp(fields, "eth_src")) { - mp->fields = htons(NX_MP_FIELDS_ETH_SRC); + mp->fields = NX_HASH_FIELDS_ETH_SRC; } else if (!strcasecmp(fields, "symmetric_l4")) { - mp->fields = htons(NX_MP_FIELDS_SYMMETRIC_L4); + mp->fields = NX_HASH_FIELDS_SYMMETRIC_L4; } else { - ovs_fatal(0, "%s: unknown fields `%s'", s, fields); + return xasprintf("%s: unknown fields `%s'", s_, fields); } - mp->basis = htons(atoi(basis)); + mp->basis = atoi(basis); if (!strcasecmp(algorithm, "modulo_n")) { - mp->algorithm = htons(NX_MP_ALG_MODULO_N); + mp->algorithm = NX_MP_ALG_MODULO_N; } else if (!strcasecmp(algorithm, "hash_threshold")) { - mp->algorithm = htons(NX_MP_ALG_HASH_THRESHOLD); + mp->algorithm = NX_MP_ALG_HASH_THRESHOLD; } else if (!strcasecmp(algorithm, "hrw")) { - mp->algorithm = htons(NX_MP_ALG_HRW); + mp->algorithm = NX_MP_ALG_HRW; } else if (!strcasecmp(algorithm, "iter_hash")) { - mp->algorithm = htons(NX_MP_ALG_ITER_HASH); + mp->algorithm = NX_MP_ALG_ITER_HASH; } else { - ovs_fatal(0, "%s: unknown algorithm `%s'", s, algorithm); + return xasprintf("%s: unknown algorithm `%s'", s_, algorithm); + } + n_links = atoi(n_links_str); + if (n_links < 1 || n_links > 65536) { + return xasprintf("%s: n_links %d is not in valid range 1 to 65536", + s_, n_links); + } + mp->max_link = n_links - 1; + mp->arg = atoi(arg); + + error = mf_parse_subfield(&mp->dst, dst); + if (error) { + return error; + } + if (mp->dst.n_bits < 16 && n_links > (1u << mp->dst.n_bits)) { + return xasprintf("%s: %d-bit destination field has %u possible " + "values, less than specified n_links %d", + s_, mp->dst.n_bits, 1u << mp->dst.n_bits, n_links); } - mp->max_link = htons(atoi(n_links) - 1); - mp->arg = htonl(atoi(arg)); - nxm_parse_field_bits(dst, &header, &ofs, &n_bits); - mp->ofs_nbits = nxm_encode_ofs_nbits(ofs, n_bits); - mp->dst = htonl(header); + return NULL; +} +/* Parses 's_' as a set of arguments to the "multipath" action and initializes + * 'mp' accordingly. ovs-ofctl(8) describes the format parsed. + * + * Returns NULL if successful, otherwise a malloc()'d string describing the + * error. The caller is responsible for freeing the returned string. */ +char * WARN_UNUSED_RESULT +multipath_parse(struct ofpact_multipath *mp, const char *s_) +{ + char *s = xstrdup(s_); + char *error = multipath_parse__(mp, s_, s); free(s); + return error; } +/* Appends a description of 'mp' to 's', in the format that ovs-ofctl(8) + * describes. */ void -multipath_format(const struct nx_action_multipath *mp, struct ds *s) +multipath_format(const struct ofpact_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 = ""; - } + fields = flow_hash_fields_to_str(mp->fields); - switch ((enum nx_mp_algorithm) ntohs(mp->algorithm)) { + switch (mp->algorithm) { case NX_MP_ALG_MODULO_N: algorithm = "modulo_n"; break; @@ -297,9 +297,8 @@ multipath_format(const struct nx_action_multipath *mp, struct ds *s) } ds_put_format(s, "multipath(%s,%"PRIu16",%s,%d,%"PRIu16",", - fields, ntohs(mp->basis), algorithm, ntohs(mp->max_link) + 1, - ntohl(mp->arg)); - nxm_format_field_bits(s, ntohl(mp->dst), nxm_decode_ofs(mp->ofs_nbits), - nxm_decode_n_bits(mp->ofs_nbits)); + fields, mp->basis, algorithm, mp->max_link + 1, + mp->arg); + mf_format_subfield(&mp->dst, s); ds_put_char(s, ')'); }