/*
- * Copyright (c) 2010, 2011 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.
#include <netinet/in.h>
#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"
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
\f
-/* 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);
}
\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);
+/* 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
-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);
+ 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);
- case NX_MP_FIELDS_SYMMETRIC_L4:
- return flow_hash_symmetric_l4(flow, basis);
- }
-
- NOT_REACHED();
+ flow_mask_hash_fields(flow, wc, mp->fields);
+ nxm_reg_load(&mp->dst, link, flow, wc);
}
static uint16_t
return algorithm_iter_hash(hash, n_links, arg);
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
\f
-/* 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;
- 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) {
+ switch (mp->algorithm) {
case NX_MP_ALG_MODULO_N:
algorithm = "modulo_n";
break;
}
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, ')');
}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff