/*
- * 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.
\f
/* 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_ceil(n_links);
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)
&& 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;
}
\f
/* 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);
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;
-
- 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();
+ nxm_reg_load(mp->dst, mp->ofs_nbits, link, flow);
}
static uint16_t
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
{
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);
- mp->type = htons(OFPAT_VENDOR);
- mp->len = htons(sizeof *mp);
- mp->vendor = htonl(NX_VENDOR_ID);
- mp->subtype = htons(NXAST_MULTIPATH);
+ ofputil_init_NXAST_MULTIPATH(mp);
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")) {
} 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 (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);
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:
git://git.onelab.eu / sliver-openvswitch.git / blobdiff