2
0
mirror of https://github.com/openvswitch/ovs synced 2025-10-15 14:17:18 +00:00
Files
openvswitch/lib/bundle.c
Alex Wang 4e022ec09e Create specific types for ofp and odp port
Until now, datapath ports and openflow ports were both represented by
unsigned integers of various sizes. With implicit conversions, etc., it is
easy to mix them up and use one where the other is expected.  This commit
creates two typedefs, ofp_port_t and odp_port_t.  Both of these two types
are marked by "__attribute__((bitwise))" so that sparse can be used to
detect any misuse.

Signed-off-by: Alex Wang <alexw@nicira.com>
Signed-off-by: Ben Pfaff <blp@nicira.com>
2013-06-20 10:42:37 -07:00

405 lines
12 KiB
C

/* Copyright (c) 2011, 2012 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <config.h>
#include "bundle.h"
#include <arpa/inet.h>
#include <inttypes.h>
#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
VLOG_DEFINE_THIS_MODULE(bundle);
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;
if (bundle->n_slaves > 1) {
flow_mask_hash_fields(wc, bundle->fields);
}
flow_hash = flow_hash_fields(flow, bundle->fields, bundle->basis);
best = -1;
best_hash = 0;
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) {
best_hash = hash;
best = i;
}
}
}
return best >= 0 ? bundle->slaves[best] : OFPP_NONE;
}
/* 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)
{
switch (bundle->algorithm) {
case NX_BD_ALG_HRW:
return execute_hrw(bundle, flow, wc, slave_enabled, aux);
case NX_BD_ALG_ACTIVE_BACKUP:
return execute_ab(bundle, slave_enabled, aux);
default:
NOT_REACHED();
}
}
/* 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
* OFPERR_* error code. */
enum ofperr
bundle_from_openflow(const struct nx_action_bundle *nab,
struct ofpbuf *ofpacts)
{
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
struct ofpact_bundle *bundle;
uint16_t subtype;
uint32_t slave_type;
size_t slaves_size, i;
enum ofperr error;
bundle = ofpact_put_BUNDLE(ofpacts);
subtype = ntohs(nab->subtype);
bundle->n_slaves = ntohs(nab->n_slaves);
bundle->basis = ntohs(nab->basis);
bundle->fields = ntohs(nab->fields);
bundle->algorithm = ntohs(nab->algorithm);
slave_type = ntohl(nab->slave_type);
slaves_size = ntohs(nab->len) - sizeof *nab;
error = OFPERR_OFPBAC_BAD_ARGUMENT;
if (!flow_hash_fields_valid(bundle->fields)) {
VLOG_WARN_RL(&rl, "unsupported fields %d", (int) bundle->fields);
} else if (bundle->n_slaves > BUNDLE_MAX_SLAVES) {
VLOG_WARN_RL(&rl, "too may slaves");
} else if (bundle->algorithm != NX_BD_ALG_HRW
&& bundle->algorithm != NX_BD_ALG_ACTIVE_BACKUP) {
VLOG_WARN_RL(&rl, "unsupported algorithm %d", (int) bundle->algorithm);
} else if (slave_type != NXM_OF_IN_PORT) {
VLOG_WARN_RL(&rl, "unsupported slave type %"PRIu16, slave_type);
} else {
error = 0;
}
if (!is_all_zeros(nab->zero, sizeof nab->zero)) {
VLOG_WARN_RL(&rl, "reserved field is nonzero");
error = OFPERR_OFPBAC_BAD_ARGUMENT;
}
if (subtype == NXAST_BUNDLE && (nab->ofs_nbits || nab->dst)) {
VLOG_WARN_RL(&rl, "bundle action has nonzero reserved fields");
error = OFPERR_OFPBAC_BAD_ARGUMENT;
}
if (subtype == NXAST_BUNDLE_LOAD) {
bundle->dst.field = mf_from_nxm_header(ntohl(nab->dst));
bundle->dst.ofs = nxm_decode_ofs(nab->ofs_nbits);
bundle->dst.n_bits = nxm_decode_n_bits(nab->ofs_nbits);
if (bundle->dst.n_bits < 16) {
VLOG_WARN_RL(&rl, "bundle_load action requires at least 16 bit "
"destination.");
error = OFPERR_OFPBAC_BAD_ARGUMENT;
}
}
if (slaves_size < bundle->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,
bundle->n_slaves * sizeof(ovs_be16), bundle->n_slaves);
error = OFPERR_OFPBAC_BAD_LEN;
}
for (i = 0; i < bundle->n_slaves; i++) {
uint16_t ofp_port = ntohs(((ovs_be16 *)(nab + 1))[i]);
ofpbuf_put(ofpacts, &ofp_port, sizeof ofp_port);
}
bundle = ofpacts->l2;
ofpact_update_len(ofpacts, &bundle->ofpact);
if (!error) {
error = bundle_check(bundle, OFPP_MAX, NULL);
}
return error;
}
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 (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];
enum ofperr error;
error = ofputil_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");
return OFPERR_OFPBAC_BAD_OUT_PORT;
}
}
return 0;
}
void
bundle_to_nxast(const struct ofpact_bundle *bundle, struct ofpbuf *openflow)
{
int slaves_len = ROUND_UP(2 * bundle->n_slaves, OFP_ACTION_ALIGN);
struct nx_action_bundle *nab;
ovs_be16 *slaves;
size_t i;
nab = (bundle->dst.field
? ofputil_put_NXAST_BUNDLE_LOAD(openflow)
: ofputil_put_NXAST_BUNDLE(openflow));
nab->len = htons(ntohs(nab->len) + slaves_len);
nab->algorithm = htons(bundle->algorithm);
nab->fields = htons(bundle->fields);
nab->basis = htons(bundle->basis);
nab->slave_type = htonl(NXM_OF_IN_PORT);
nab->n_slaves = htons(bundle->n_slaves);
if (bundle->dst.field) {
nab->ofs_nbits = nxm_encode_ofs_nbits(bundle->dst.ofs,
bundle->dst.n_bits);
nab->dst = htonl(bundle->dst.field->nxm_header);
}
slaves = ofpbuf_put_zeros(openflow, slaves_len);
for (i = 0; i < bundle->n_slaves; i++) {
slaves[i] = htons(ofp_to_u16(bundle->slaves[i]));
}
}
/* Helper for bundle_parse and bundle_parse_load. */
static void
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);
}
if (strcasecmp(slave_delim, "slaves")) {
ovs_fatal(0, "%s: missing slave delimiter, expected `slaves' got `%s'",
s, slave_delim);
}
bundle = ofpact_put_BUNDLE(ofpacts);
for (;;) {
ofp_port_t slave_port;
char *slave;
slave = strtok_r(NULL, ", []", save_ptr);
if (!slave || bundle->n_slaves >= BUNDLE_MAX_SLAVES) {
break;
}
if (!ofputil_port_from_string(slave, &slave_port)) {
ovs_fatal(0, "%s: bad port number", slave);
}
ofpbuf_put(ofpacts, &slave_port, sizeof slave_port);
bundle = ofpacts->l2;
bundle->n_slaves++;
}
ofpact_update_len(ofpacts, &bundle->ofpact);
bundle->basis = atoi(basis);
if (!strcasecmp(fields, "eth_src")) {
bundle->fields = NX_HASH_FIELDS_ETH_SRC;
} else if (!strcasecmp(fields, "symmetric_l4")) {
bundle->fields = NX_HASH_FIELDS_SYMMETRIC_L4;
} else {
ovs_fatal(0, "%s: unknown fields `%s'", s, fields);
}
if (!strcasecmp(algorithm, "active_backup")) {
bundle->algorithm = NX_BD_ALG_ACTIVE_BACKUP;
} else if (!strcasecmp(algorithm, "hrw")) {
bundle->algorithm = NX_BD_ALG_HRW;
} else {
ovs_fatal(0, "%s: unknown algorithm `%s'", s, algorithm);
}
if (strcasecmp(slave_type, "ofport")) {
ovs_fatal(0, "%s: unknown slave_type `%s'", s, slave_type);
}
if (dst) {
mf_parse_subfield(&bundle->dst, dst);
}
}
/* 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(const char *s, struct ofpbuf *ofpacts)
{
char *fields, *basis, *algorithm, *slave_type, *slave_delim;
char *tokstr, *save_ptr;
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);
bundle_parse__(s, &save_ptr, fields, basis, algorithm, slave_type, NULL,
slave_delim, ofpacts);
free(tokstr);
}
/* 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. */
void
bundle_parse_load(const char *s, struct ofpbuf *ofpacts)
{
char *fields, *basis, *algorithm, *slave_type, *dst, *slave_delim;
char *tokstr, *save_ptr;
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);
bundle_parse__(s, &save_ptr, fields, basis, algorithm, slave_type, dst,
slave_delim, ofpacts);
free(tokstr);
}
/* Appends a human-readable representation of 'nab' to 's'. */
void
bundle_format(const struct ofpact_bundle *bundle, struct ds *s)
{
const char *action, *fields, *algorithm;
size_t i;
fields = flow_hash_fields_to_str(bundle->fields);
switch (bundle->algorithm) {
case NX_BD_ALG_HRW:
algorithm = "hrw";
break;
case NX_BD_ALG_ACTIVE_BACKUP:
algorithm = "active_backup";
break;
default:
algorithm = "<unknown>";
}
action = bundle->dst.field ? "bundle_load" : "bundle";
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, ",");
}
ds_put_cstr(s, "slaves:");
for (i = 0; i < bundle->n_slaves; i++) {
if (i) {
ds_put_cstr(s, ",");
}
ofputil_format_port(bundle->slaves[i], s);
}
ds_put_cstr(s, ")");
}