#include "dynamic-string.h"
#include "ofp-errors.h"
#include "ofp-util.h"
+#include "ovs-thread.h"
#include "packets.h"
#include "random.h"
#include "shash.h"
0, NULL,
0, NULL,
}, {
- MFF_SKB_MARK, "skb_mark", NULL,
+ MFF_PKT_MARK, "pkt_mark", NULL,
MF_FIELD_SIZES(be32),
- MFM_NONE,
+ MFM_FULLY,
MFS_HEXADECIMAL,
MFP_NONE,
- false,
- 0, NULL,
- 0, NULL,
+ true,
+ NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
+ NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
},
#define REGISTER(IDX) \
OXM_OF_UDP_DST, "OXM_OF_UDP_DST",
},
+ {
+ MFF_SCTP_SRC, "sctp_src", NULL,
+ MF_FIELD_SIZES(be16),
+ MFM_FULLY,
+ MFS_DECIMAL,
+ MFP_SCTP,
+ true,
+ OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
+ OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
+ }, {
+ MFF_SCTP_DST, "sctp_dst", NULL,
+ MF_FIELD_SIZES(be16),
+ MFM_FULLY,
+ MFS_DECIMAL,
+ MFP_SCTP,
+ true,
+ OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
+ OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
+ },
+
{
MFF_ICMPV4_TYPE, "icmp_type", NULL,
MF_FIELD_SIZES(u8),
};
/* Contains 'struct nxm_field's. */
-static struct hmap all_fields = HMAP_INITIALIZER(&all_fields);
+static struct hmap all_fields;
+
+/* Maps from an mf_field's 'name' or 'extra_name' to the mf_field. */
+static struct shash mf_by_name;
/* Rate limit for parse errors. These always indicate a bug in an OpenFlow
* controller and so there's not much point in showing a lot of them. */
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
const struct mf_field *mf_from_nxm_header__(uint32_t header);
+static void nxm_init(void);
/* Returns the field with the given 'id'. */
const struct mf_field *
const struct mf_field *
mf_from_name(const char *name)
{
- static struct shash mf_by_name = SHASH_INITIALIZER(&mf_by_name);
-
- if (shash_is_empty(&mf_by_name)) {
- const struct mf_field *mf;
-
- for (mf = mf_fields; mf < &mf_fields[MFF_N_IDS]; mf++) {
- shash_add_once(&mf_by_name, mf->name, mf);
- if (mf->extra_name) {
- shash_add_once(&mf_by_name, mf->extra_name, mf);
- }
- }
- }
-
+ nxm_init();
return shash_find_data(&mf_by_name, name);
}
}
static void
-nxm_init(void)
+nxm_do_init(void)
{
const struct mf_field *mf;
+ hmap_init(&all_fields);
+ shash_init(&mf_by_name);
for (mf = mf_fields; mf < &mf_fields[MFF_N_IDS]; mf++) {
nxm_init_add_field(mf, mf->nxm_header);
if (mf->oxm_header != mf->nxm_header) {
nxm_init_add_field(mf, mf->oxm_header);
}
+
+ shash_add_once(&mf_by_name, mf->name, mf);
+ if (mf->extra_name) {
+ shash_add_once(&mf_by_name, mf->extra_name, mf);
+ }
}
}
+static void
+nxm_init(void)
+{
+ static pthread_once_t once = PTHREAD_ONCE_INIT;
+ pthread_once(&once, nxm_do_init);
+}
+
const struct mf_field *
mf_from_nxm_header(uint32_t header)
{
- if (hmap_is_empty(&all_fields)) {
- nxm_init();
- }
+ nxm_init();
return mf_from_nxm_header__(header);
}
return !wc->masks.metadata;
case MFF_IN_PORT:
case MFF_IN_PORT_OXM:
- return !wc->masks.in_port;
+ return !wc->masks.in_port.ofp_port;
case MFF_SKB_PRIORITY:
return !wc->masks.skb_priority;
- case MFF_SKB_MARK:
- return !wc->masks.skb_mark;
+ case MFF_PKT_MARK:
+ return !wc->masks.pkt_mark;
CASE_MFF_REGS:
return !wc->masks.regs[mf->id - MFF_REG0];
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV6_TYPE:
return !wc->masks.tp_src;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_CODE:
return !wc->masks.tp_dst;
return is_ip_any(flow) && flow->nw_proto == IPPROTO_TCP;
case MFP_UDP:
return is_ip_any(flow) && flow->nw_proto == IPPROTO_UDP;
+ case MFP_SCTP:
+ return is_ip_any(flow) && flow->nw_proto == IPPROTO_SCTP;
case MFP_ICMPV4:
return is_icmpv4(flow);
case MFP_ICMPV6:
case MFF_METADATA:
case MFF_IN_PORT:
case MFF_SKB_PRIORITY:
- case MFF_SKB_MARK:
+ case MFF_PKT_MARK:
CASE_MFF_REGS:
case MFF_ETH_SRC:
case MFF_ETH_DST:
case MFF_TCP_DST:
case MFF_UDP_SRC:
case MFF_UDP_DST:
+ case MFF_SCTP_SRC:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_TYPE:
return true;
case MFF_IN_PORT_OXM: {
- uint16_t port;
+ ofp_port_t port;
return !ofputil_port_from_ofp11(value->be32, &port);
}
break;
case MFF_IN_PORT:
- value->be16 = htons(flow->in_port);
+ value->be16 = htons(ofp_to_u16(flow->in_port.ofp_port));
break;
-
case MFF_IN_PORT_OXM:
- value->be32 = ofputil_port_to_ofp11(flow->in_port);
+ value->be32 = ofputil_port_to_ofp11(flow->in_port.ofp_port);
break;
case MFF_SKB_PRIORITY:
value->be32 = htonl(flow->skb_priority);
break;
- case MFF_SKB_MARK:
- value->be32 = htonl(flow->skb_mark);
+ case MFF_PKT_MARK:
+ value->be32 = htonl(flow->pkt_mark);
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
value->be16 = flow->tp_src;
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
value->be16 = flow->tp_dst;
break;
break;
case MFF_IN_PORT:
- match_set_in_port(match, ntohs(value->be16));
+ match_set_in_port(match, u16_to_ofp(ntohs(value->be16)));
break;
case MFF_IN_PORT_OXM: {
- uint16_t port;
+ ofp_port_t port;
ofputil_port_from_ofp11(value->be32, &port);
match_set_in_port(match, port);
break;
match_set_skb_priority(match, ntohl(value->be32));
break;
- case MFF_SKB_MARK:
- match_set_skb_mark(match, ntohl(value->be32));
+ case MFF_PKT_MARK:
+ match_set_pkt_mark(match, ntohl(value->be32));
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
match_set_tp_src(match, value->be16);
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
match_set_tp_dst(match, value->be16);
break;
}
}
-/* Makes 'match' match field 'mf' exactly, with the value matched taken from
- * 'value'. The caller is responsible for ensuring that 'match' meets 'mf''s
- * prerequisites. */
+/* Sets 'flow' member field described by 'mf' to 'value'. The caller is
+ * responsible for ensuring that 'flow' meets 'mf''s prerequisites.*/
void
mf_set_flow_value(const struct mf_field *mf,
const union mf_value *value, struct flow *flow)
break;
case MFF_IN_PORT:
- flow->in_port = ntohs(value->be16);
+ flow->in_port.ofp_port = u16_to_ofp(ntohs(value->be16));
break;
case MFF_IN_PORT_OXM: {
- uint16_t port;
+ ofp_port_t port;
ofputil_port_from_ofp11(value->be32, &port);
- flow->in_port = port;
+ flow->in_port.ofp_port = port;
break;
}
flow->skb_priority = ntohl(value->be32);
break;
- case MFF_SKB_MARK:
- flow->skb_mark = ntohl(value->be32);
+ case MFF_PKT_MARK:
+ flow->pkt_mark = ntohl(value->be32);
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
flow->tp_src = value->be16;
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
flow->tp_dst = value->be16;
break;
case MFF_IN_PORT:
case MFF_IN_PORT_OXM:
- match->flow.in_port = 0;
- match->wc.masks.in_port = 0;
+ match->flow.in_port.ofp_port = 0;
+ match->wc.masks.in_port.ofp_port = 0;
break;
case MFF_SKB_PRIORITY:
match->wc.masks.skb_priority = 0;
break;
- case MFF_SKB_MARK:
- match->flow.skb_mark = 0;
- match->wc.masks.skb_mark = 0;
+ case MFF_PKT_MARK:
+ match->flow.pkt_mark = 0;
+ match->wc.masks.pkt_mark = 0;
break;
CASE_MFF_REGS:
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV6_TYPE:
match->wc.masks.tp_src = htons(0);
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_CODE:
match->wc.masks.tp_dst = htons(0);
switch (mf->id) {
case MFF_IN_PORT:
case MFF_IN_PORT_OXM:
- case MFF_SKB_MARK:
case MFF_SKB_PRIORITY:
case MFF_ETH_TYPE:
case MFF_DL_VLAN:
ntohl(value->be32), ntohl(mask->be32));
break;
+ case MFF_PKT_MARK:
+ match_set_pkt_mark_masked(match, ntohl(value->be32),
+ ntohl(mask->be32));
+ break;
+
case MFF_ETH_DST:
match_set_dl_dst_masked(match, value->mac, mask->mac);
break;
case MFF_TCP_SRC:
case MFF_UDP_SRC:
+ case MFF_SCTP_SRC:
match_set_tp_src_masked(match, value->be16, mask->be16);
break;
case MFF_TCP_DST:
case MFF_UDP_DST:
+ case MFF_SCTP_DST:
match_set_tp_dst_masked(match, value->be16, mask->be16);
break;
case MFF_TUN_FLAGS:
case MFF_METADATA:
case MFF_IN_PORT:
- case MFF_SKB_MARK:
+ case MFF_PKT_MARK:
case MFF_SKB_PRIORITY:
CASE_MFF_REGS:
case MFF_ETH_SRC:
case MFF_TCP_DST:
case MFF_UDP_SRC:
case MFF_UDP_DST:
+ case MFF_SCTP_SRC:
+ case MFF_SCTP_DST:
case MFF_ICMPV4_TYPE:
case MFF_ICMPV4_CODE:
case MFF_ICMPV6_TYPE:
break;
case MFF_IN_PORT_OXM:
- value->be32 = ofputil_port_to_ofp11(ntohs(value->be16));
+ value->be32 = ofputil_port_to_ofp11(u16_to_ofp(ntohs(value->be16)));
break;
case MFF_IPV6_LABEL:
uint8_t mac[ETH_ADDR_LEN],
uint8_t mask[ETH_ADDR_LEN])
{
- ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
+ int n;
- switch (sscanf(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT,
- ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask))){
- case ETH_ADDR_SCAN_COUNT * 2:
- return NULL;
+ ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
- case ETH_ADDR_SCAN_COUNT:
+ n = -1;
+ if (sscanf(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(mac), &n) > 0
+ && n == strlen(s)) {
memset(mask, 0xff, ETH_ADDR_LEN);
return NULL;
+ }
- default:
- return xasprintf("%s: invalid Ethernet address", s);
+ n = -1;
+ if (sscanf(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"%n",
+ ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask), &n) > 0
+ && n == strlen(s)) {
+ return NULL;
}
+
+ return xasprintf("%s: invalid Ethernet address", s);
}
static char *
mf_from_ofp_port_string(const struct mf_field *mf, const char *s,
ovs_be16 *valuep, ovs_be16 *maskp)
{
- uint16_t port;
+ ofp_port_t port;
ovs_assert(mf->n_bytes == sizeof(ovs_be16));
if (ofputil_port_from_string(s, &port)) {
- *valuep = htons(port);
+ *valuep = htons(ofp_to_u16(port));
*maskp = htons(UINT16_MAX);
return NULL;
}
mf_from_ofp_port_string32(const struct mf_field *mf, const char *s,
ovs_be32 *valuep, ovs_be32 *maskp)
{
- uint16_t port;
+ ofp_port_t port;
ovs_assert(mf->n_bytes == sizeof(ovs_be32));
if (ofputil_port_from_string(s, &port)) {
switch (mf->string) {
case MFS_OFP_PORT_OXM:
if (!mask) {
- uint16_t port;
+ ofp_port_t port;
ofputil_port_from_ofp11(value->be32, &port);
ofputil_format_port(port, s);
break;
/* fall through */
case MFS_OFP_PORT:
if (!mask) {
- ofputil_format_port(ntohs(value->be16), s);
+ ofputil_format_port(u16_to_ofp(ntohs(value->be16)), s);
break;
}
/* fall through */
* bit indexes. "..end" may be omitted to indicate a single bit. "start..end"
* may both be omitted (the [] are still required) to indicate an entire
* field. */
-char *
+char * WARN_UNUSED_RESULT
mf_parse_subfield__(struct mf_subfield *sf, const char **sp)
{
const struct mf_field *field;
return NULL;
}
-/* Parses a subfield from the beginning of 's' into 'sf'. Returns the first
- * byte in 's' following the parsed string.
- *
- * Exits with an error message if 's' has incorrect syntax.
+/* Parses a subfield from the entirety of 's' into 'sf'. Returns NULL if
+ * successful, otherwise a malloc()'d string describing the error. The caller
+ * is responsible for freeing the returned string.
*
* The syntax parsed from 's' takes the form "header[start..end]" where
* 'header' is the name of an NXM field and 'start' and 'end' are (inclusive)
* bit indexes. "..end" may be omitted to indicate a single bit. "start..end"
* may both be omitted (the [] are still required) to indicate an entire
* field. */
-const char *
+char * WARN_UNUSED_RESULT
mf_parse_subfield(struct mf_subfield *sf, const char *s)
{
- char *msg = mf_parse_subfield__(sf, &s);
- if (msg) {
- ovs_fatal(0, "%s", msg);
+ char *error = mf_parse_subfield__(sf, &s);
+ if (!error && s[0]) {
+ error = xstrdup("unexpected input following field syntax");
}
- return s;
+ return error;
}
void
git://git.onelab.eu / sliver-openvswitch.git / blobdiff