-/* Copyright (c) 2011 Nicira Networks.
+/* Copyright (c) 2011, 2012, 2013, 2014, 2015 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 "dynamic-string.h"
#include "multipath.h"
+#include "meta-flow.h"
#include "nx-match.h"
#include "ofpbuf.h"
+#include "ofp-actions.h"
+#include "ofp-errors.h"
#include "ofp-util.h"
#include "openflow/nicira-ext.h"
-#include "vlog.h"
-
-#define BUNDLE_MAX_SLAVES 2048
+#include "openvswitch/vlog.h"
VLOG_DEFINE_THIS_MODULE(bundle);
-/* Executes 'nab' on 'flow'. Uses 'slave_enabled' to determine if the slave
- * designated by 'ofp_port' is up. Returns the chosen slave, or OFPP_NONE if
- * none of the slaves are acceptable. */
-uint16_t
-bundle_execute(const struct nx_action_bundle *nab, const struct flow *flow,
- bool (*slave_enabled)(uint16_t ofp_port, void *aux), void *aux)
+static ofp_port_t
+execute_ab(const struct ofpact_bundle *bundle,
+ bool (*slave_enabled)(ofp_port_t ofp_port, void *aux), void *aux)
+{
+ size_t i;
+
+ for (i = 0; i < bundle->n_slaves; i++) {
+ ofp_port_t slave = bundle->slaves[i];
+ if (slave_enabled(slave, aux)) {
+ return slave;
+ }
+ }
+
+ return OFPP_NONE;
+}
+
+static ofp_port_t
+execute_hrw(const struct ofpact_bundle *bundle,
+ const struct flow *flow, struct flow_wildcards *wc,
+ bool (*slave_enabled)(ofp_port_t ofp_port, void *aux), void *aux)
{
uint32_t flow_hash, best_hash;
int best, i;
- assert(nab->algorithm == htons(NX_BD_ALG_HRW));
+ if (bundle->n_slaves > 1) {
+ flow_mask_hash_fields(flow, wc, bundle->fields);
+ }
- flow_hash = flow_hash_fields(flow, ntohs(nab->fields), ntohs(nab->basis));
+ flow_hash = flow_hash_fields(flow, bundle->fields, bundle->basis);
best = -1;
best_hash = 0;
- for (i = 0; i < ntohs(nab->n_slaves); i++) {
- if (slave_enabled(bundle_get_slave(nab, i), aux)) {
+ for (i = 0; i < bundle->n_slaves; i++) {
+ if (slave_enabled(bundle->slaves[i], aux)) {
uint32_t hash = hash_2words(i, flow_hash);
if (best < 0 || hash > best_hash) {
}
}
- return best >= 0 ? bundle_get_slave(nab, best) : OFPP_NONE;
+ return best >= 0 ? bundle->slaves[best] : OFPP_NONE;
}
-/* Checks that 'nab' specifies a bundle action which is supported by this
- * bundle module. Uses the 'max_ports' parameter to validate each port using
- * ofputil_check_output_port(). Returns 0 if 'nab' is supported, otherwise an
- * OpenFlow error code (as returned by ofp_mkerr()). */
-int
-bundle_check(const struct nx_action_bundle *nab, int max_ports)
+/* Executes 'bundle' on 'flow'. Sets fields in 'wc' that were used to
+ * calculate the result. Uses 'slave_enabled' to determine if the slave
+ * designated by 'ofp_port' is up. Returns the chosen slave, or
+ * OFPP_NONE if none of the slaves are acceptable. */
+ofp_port_t
+bundle_execute(const struct ofpact_bundle *bundle,
+ const struct flow *flow, struct flow_wildcards *wc,
+ bool (*slave_enabled)(ofp_port_t ofp_port, void *aux),
+ void *aux)
{
- static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
- uint16_t n_slaves, fields, algorithm, subtype;
- uint32_t slave_type;
- size_t slaves_size, i;
- int error;
-
- subtype = ntohs(nab->subtype);
- n_slaves = ntohs(nab->n_slaves);
- fields = ntohs(nab->fields);
- algorithm = ntohs(nab->algorithm);
- slave_type = ntohl(nab->slave_type);
- slaves_size = ntohs(nab->len) - sizeof *nab;
-
- error = ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT);
- if (!flow_hash_fields_valid(fields)) {
- VLOG_WARN_RL(&rl, "unsupported fields %"PRIu16, fields);
- } else if (n_slaves > BUNDLE_MAX_SLAVES) {
- VLOG_WARN_RL(&rl, "too may slaves");
- } else if (algorithm != NX_BD_ALG_HRW) {
- VLOG_WARN_RL(&rl, "unsupported algorithm %"PRIu16, algorithm);
- } else if (slave_type != NXM_OF_IN_PORT) {
- VLOG_WARN_RL(&rl, "unsupported slave type %"PRIu16, slave_type);
- } else {
- error = 0;
- }
+ switch (bundle->algorithm) {
+ case NX_BD_ALG_HRW:
+ return execute_hrw(bundle, flow, wc, slave_enabled, aux);
- for (i = 0; i < sizeof(nab->zero); i++) {
- if (nab->zero[i]) {
- VLOG_WARN_RL(&rl, "reserved field is nonzero");
- error = ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT);
- }
- }
+ case NX_BD_ALG_ACTIVE_BACKUP:
+ return execute_ab(bundle, slave_enabled, aux);
- if (slaves_size < n_slaves * sizeof(ovs_be16)) {
- VLOG_WARN_RL(&rl, "Nicira action %"PRIu16" only has %zu bytes "
- "allocated for slaves. %zu bytes are required for "
- "%"PRIu16" slaves.", subtype, slaves_size,
- n_slaves * sizeof(ovs_be16), n_slaves);
- error = ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
+ default:
+ OVS_NOT_REACHED();
}
+}
- for (i = 0; i < n_slaves; i++) {
- uint16_t ofp_port = bundle_get_slave(nab, i);
- int ofputil_error = ofputil_check_output_port(ofp_port, max_ports);
+enum ofperr
+bundle_check(const struct ofpact_bundle *bundle, ofp_port_t max_ports,
+ const struct flow *flow)
+{
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+ size_t i;
- if (ofputil_error) {
- VLOG_WARN_RL(&rl, "invalid slave %"PRIu16, ofp_port);
- error = ofputil_error;
+ if (bundle->dst.field) {
+ enum ofperr error = mf_check_dst(&bundle->dst, flow);
+ if (error) {
+ return error;
}
+ }
+ for (i = 0; i < bundle->n_slaves; i++) {
+ ofp_port_t ofp_port = bundle->slaves[i];
+
+ if (ofp_port != OFPP_NONE) {
+ enum ofperr error = ofpact_check_output_port(ofp_port, max_ports);
+ if (error) {
+ VLOG_WARN_RL(&rl, "invalid slave %"PRIu16, ofp_port);
+ return error;
+ }
+ }
/* Controller slaves are unsupported due to the lack of a max_len
* argument. This may or may not change in the future. There doesn't
* seem to be a real-world use-case for supporting it. */
if (ofp_port == OFPP_CONTROLLER) {
VLOG_WARN_RL(&rl, "unsupported controller slave");
- error = ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT);
+ return OFPERR_OFPBAC_BAD_OUT_PORT;
}
}
- return error;
+ return 0;
}
-/* Converts a bundle action string contained in 's' to an nx_action_bundle and
- * stores it in 'b'. Sets 'b''s l2 pointer to NULL. */
-void
-bundle_parse(struct ofpbuf *b, const char *s)
-{
- char *fields, *basis, *algorithm, *slave_type, *slave_delim;
- struct nx_action_bundle *nab;
- char *tokstr, *save_ptr;
- uint16_t n_slaves;
- save_ptr = NULL;
- tokstr = xstrdup(s);
- fields = strtok_r(tokstr, ", ", &save_ptr);
- basis = strtok_r(NULL, ", ", &save_ptr);
- algorithm = strtok_r(NULL, ", ", &save_ptr);
- slave_type = strtok_r(NULL, ", ", &save_ptr);
- slave_delim = strtok_r(NULL, ": ", &save_ptr);
+/* Helper for bundle_parse and bundle_parse_load.
+ *
+ * Returns NULL if successful, otherwise a malloc()'d string describing the
+ * error. The caller is responsible for freeing the returned string.*/
+static char * OVS_WARN_UNUSED_RESULT
+bundle_parse__(const char *s, char **save_ptr,
+ const char *fields, const char *basis, const char *algorithm,
+ const char *slave_type, const char *dst,
+ const char *slave_delim, struct ofpbuf *ofpacts)
+{
+ struct ofpact_bundle *bundle;
if (!slave_delim) {
- ovs_fatal(0, "%s: not enough arguments to bundle action", s);
+ return xasprintf("%s: not enough arguments to bundle action", s);
}
if (strcasecmp(slave_delim, "slaves")) {
- ovs_fatal(0, "%s: missing slave delimiter, expected `slaves' got `%s'",
- s, slave_delim);
+ return xasprintf("%s: missing slave delimiter, expected `slaves' "
+ "got `%s'", s, slave_delim);
}
- b->l2 = ofpbuf_put_zeros(b, sizeof *nab);
+ bundle = ofpact_put_BUNDLE(ofpacts);
- n_slaves = 0;
for (;;) {
- ovs_be16 slave_be;
+ ofp_port_t slave_port;
char *slave;
- slave = strtok_r(NULL, ", ", &save_ptr);
- if (!slave || n_slaves >= BUNDLE_MAX_SLAVES) {
+ slave = strtok_r(NULL, ", []", save_ptr);
+ if (!slave || bundle->n_slaves >= BUNDLE_MAX_SLAVES) {
break;
}
- slave_be = htons(atoi(slave));
- ofpbuf_put(b, &slave_be, sizeof slave_be);
-
- n_slaves++;
- }
+ if (!ofputil_port_from_string(slave, &slave_port)) {
+ return xasprintf("%s: bad port number", slave);
+ }
+ ofpbuf_put(ofpacts, &slave_port, sizeof slave_port);
- /* Slaves array must be multiple of 8 bytes long. */
- if (b->size % 8) {
- ofpbuf_put_zeros(b, 8 - (b->size % 8));
+ bundle = ofpacts->header;
+ bundle->n_slaves++;
}
+ ofpact_finish(ofpacts, &bundle->ofpact);
- nab = b->l2;
- nab->type = htons(OFPAT_VENDOR);
- nab->len = htons(b->size - ((char *) b->l2 - (char *) b->data));
- nab->vendor = htonl(NX_VENDOR_ID);
- nab->subtype = htons(NXAST_BUNDLE);
- nab->n_slaves = htons(n_slaves);
- nab->basis = htons(atoi(basis));
+ bundle = ofpacts->header;
+ bundle->basis = atoi(basis);
if (!strcasecmp(fields, "eth_src")) {
- nab->fields = htons(NX_HASH_FIELDS_ETH_SRC);
+ bundle->fields = NX_HASH_FIELDS_ETH_SRC;
} else if (!strcasecmp(fields, "symmetric_l4")) {
- nab->fields = htons(NX_HASH_FIELDS_SYMMETRIC_L4);
+ bundle->fields = NX_HASH_FIELDS_SYMMETRIC_L4;
+ } else if (!strcasecmp(fields, "symmetric_l3l4")) {
+ bundle->fields = NX_HASH_FIELDS_SYMMETRIC_L3L4;
+ } else if (!strcasecmp(fields, "symmetric_l3l4+udp")) {
+ bundle->fields = NX_HASH_FIELDS_SYMMETRIC_L3L4_UDP;
} else {
- ovs_fatal(0, "%s: unknown fields `%s'", s, fields);
+ return xasprintf("%s: unknown fields `%s'", s, fields);
}
if (!strcasecmp(algorithm, "active_backup")) {
- nab->algorithm = htons(NX_BD_ALG_ACTIVE_BACKUP);
+ bundle->algorithm = NX_BD_ALG_ACTIVE_BACKUP;
} else if (!strcasecmp(algorithm, "hrw")) {
- nab->algorithm = htons(NX_BD_ALG_HRW);
+ bundle->algorithm = NX_BD_ALG_HRW;
} else {
- ovs_fatal(0, "%s: unknown algorithm `%s'", s, algorithm);
+ return xasprintf("%s: unknown algorithm `%s'", s, algorithm);
}
- if (!strcasecmp(slave_type, "ofport")) {
- nab->slave_type = htonl(NXM_OF_IN_PORT);
- } else {
- ovs_fatal(0, "%s: unknown slave_type `%s'", s, slave_type);
+ if (strcasecmp(slave_type, "ofport")) {
+ return xasprintf("%s: unknown slave_type `%s'", s, slave_type);
}
- b->l2 = NULL;
+ if (dst) {
+ char *error = mf_parse_subfield(&bundle->dst, dst);
+ if (error) {
+ return error;
+ }
+
+ if (!mf_nxm_header(bundle->dst.field->id)) {
+ return xasprintf("%s: experimenter OXM field '%s' not supported",
+ s, dst);
+ }
+ }
+
+ return NULL;
+}
+
+/* Converts a bundle action string contained in 's' to an nx_action_bundle and
+ * stores it in 'b'. Sets 'b''s l2 pointer to NULL.
+ *
+ * Returns NULL if successful, otherwise a malloc()'d string describing the
+ * error. The caller is responsible for freeing the returned string. */
+char * OVS_WARN_UNUSED_RESULT
+bundle_parse(const char *s, struct ofpbuf *ofpacts)
+{
+ char *fields, *basis, *algorithm, *slave_type, *slave_delim;
+ char *tokstr, *save_ptr;
+ char *error;
+
+ save_ptr = NULL;
+ tokstr = xstrdup(s);
+ fields = strtok_r(tokstr, ", ", &save_ptr);
+ basis = strtok_r(NULL, ", ", &save_ptr);
+ algorithm = strtok_r(NULL, ", ", &save_ptr);
+ slave_type = strtok_r(NULL, ", ", &save_ptr);
+ slave_delim = strtok_r(NULL, ": ", &save_ptr);
+
+ error = bundle_parse__(s, &save_ptr, fields, basis, algorithm, slave_type,
+ NULL, slave_delim, ofpacts);
free(tokstr);
+
+ return error;
+}
+
+/* Converts a bundle_load action string contained in 's' to an nx_action_bundle
+ * and stores it in 'b'. Sets 'b''s l2 pointer to NULL.
+ *
+ * Returns NULL if successful, otherwise a malloc()'d string describing the
+ * error. The caller is responsible for freeing the returned string.*/
+char * OVS_WARN_UNUSED_RESULT
+bundle_parse_load(const char *s, struct ofpbuf *ofpacts)
+{
+ char *fields, *basis, *algorithm, *slave_type, *dst, *slave_delim;
+ char *tokstr, *save_ptr;
+ char *error;
+
+ save_ptr = NULL;
+ tokstr = xstrdup(s);
+ fields = strtok_r(tokstr, ", ", &save_ptr);
+ basis = strtok_r(NULL, ", ", &save_ptr);
+ algorithm = strtok_r(NULL, ", ", &save_ptr);
+ slave_type = strtok_r(NULL, ", ", &save_ptr);
+ dst = strtok_r(NULL, ", ", &save_ptr);
+ slave_delim = strtok_r(NULL, ": ", &save_ptr);
+
+ error = bundle_parse__(s, &save_ptr, fields, basis, algorithm, slave_type,
+ dst, slave_delim, ofpacts);
+
+ free(tokstr);
+
+ return error;
}
/* Appends a human-readable representation of 'nab' to 's'. */
void
-bundle_format(const struct nx_action_bundle *nab, struct ds *s)
+bundle_format(const struct ofpact_bundle *bundle, struct ds *s)
{
- const char *fields, *algorithm, *slave_type;
+ const char *action, *fields, *algorithm;
size_t i;
- fields = flow_hash_fields_to_str(ntohs(nab->fields));
+ fields = flow_hash_fields_to_str(bundle->fields);
- switch (ntohs(nab->algorithm)) {
+ switch (bundle->algorithm) {
case NX_BD_ALG_HRW:
algorithm = "hrw";
break;
algorithm = "<unknown>";
}
- switch (ntohl(nab->slave_type)) {
- case NXM_OF_IN_PORT:
- slave_type = "ofport";
- break;
- default:
- slave_type = "<unknown>";
- }
+ action = bundle->dst.field ? "bundle_load" : "bundle";
- ds_put_format(s, "bundle(%s,%"PRIu16",%s,%s,slaves:", fields,
- ntohs(nab->basis), algorithm, slave_type);
+ ds_put_format(s, "%s(%s,%"PRIu16",%s,%s,", action, fields,
+ bundle->basis, algorithm, "ofport");
+
+ if (bundle->dst.field) {
+ mf_format_subfield(&bundle->dst, s);
+ ds_put_cstr(s, ",");
+ }
- for (i = 0; i < ntohs(nab->n_slaves); i++) {
+ ds_put_cstr(s, "slaves:");
+ for (i = 0; i < bundle->n_slaves; i++) {
if (i) {
ds_put_cstr(s, ",");
}
- ds_put_format(s, "%"PRIu16, bundle_get_slave(nab, i));
+ ofputil_format_port(bundle->slaves[i], s);
}
ds_put_cstr(s, ")");
projects / cascardo / ovs.git / blobdiff