#include <inttypes.h>
#include <stdlib.h>
#include "byte-order.h"
+#include "classifier.h"
+#include "nx-match.h"
#include "ofp-util.h"
#include "ofpbuf.h"
#include "packets.h"
* in the peer and so there's not much point in showing a lot of them. */
static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5);
-/* XXX we should really use consecutive xids to avoid probabilistic
- * failures. */
-static inline uint32_t
+/* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns
+ * an IP netmask with a 1 in each bit that must match and a 0 in each bit that
+ * is wildcarded.
+ *
+ * The bits in 'wcbits' are in the format used in enum ofp_flow_wildcards: 0
+ * is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant bits,
+ * ..., 32 and higher wildcard the entire field. This is the *opposite* of the
+ * usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are
+ * wildcarded. */
+ovs_be32
+ofputil_wcbits_to_netmask(int wcbits)
+{
+ wcbits &= 0x3f;
+ return wcbits < 32 ? htonl(~((1u << wcbits) - 1)) : 0;
+}
+
+/* Given the IP netmask 'netmask', returns the number of bits of the IP address
+ * that it wildcards. 'netmask' must be a CIDR netmask (see ip_is_cidr()). */
+int
+ofputil_netmask_to_wcbits(ovs_be32 netmask)
+{
+ assert(ip_is_cidr(netmask));
+#if __GNUC__ >= 4
+ return netmask == htonl(0) ? 32 : __builtin_ctz(ntohl(netmask));
+#else
+ int wcbits;
+
+ for (wcbits = 32; netmask; wcbits--) {
+ netmask &= netmask - 1;
+ }
+
+ return wcbits;
+#endif
+}
+
+/* A list of the FWW_* and OFPFW_ bits that have the same value, meaning, and
+ * name. */
+#define WC_INVARIANT_LIST \
+ WC_INVARIANT_BIT(IN_PORT) \
+ WC_INVARIANT_BIT(DL_SRC) \
+ WC_INVARIANT_BIT(DL_DST) \
+ WC_INVARIANT_BIT(DL_TYPE) \
+ WC_INVARIANT_BIT(NW_PROTO) \
+ WC_INVARIANT_BIT(TP_SRC) \
+ WC_INVARIANT_BIT(TP_DST)
+
+/* Verify that all of the invariant bits (as defined on WC_INVARIANT_LIST)
+ * actually have the same names and values. */
+#define WC_INVARIANT_BIT(NAME) BUILD_ASSERT_DECL(FWW_##NAME == OFPFW_##NAME);
+ WC_INVARIANT_LIST
+#undef WC_INVARIANT_BIT
+
+/* WC_INVARIANTS is the invariant bits (as defined on WC_INVARIANT_LIST) all
+ * OR'd together. */
+enum {
+ WC_INVARIANTS = 0
+#define WC_INVARIANT_BIT(NAME) | FWW_##NAME
+ WC_INVARIANT_LIST
+#undef WC_INVARIANT_BIT
+};
+
+/* Converts the ofp_match in 'match' into a cls_rule in 'rule', with the given
+ * 'priority'.
+ *
+ * 'flow_format' must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE. In
+ * the latter case only, 'flow''s tun_id field will be taken from the high bits
+ * of 'cookie', if 'match''s wildcards do not indicate that tun_id is
+ * wildcarded. */
+void
+ofputil_cls_rule_from_match(const struct ofp_match *match,
+ unsigned int priority,
+ enum nx_flow_format flow_format,
+ uint64_t cookie, struct cls_rule *rule)
+{
+ struct flow_wildcards *wc = &rule->wc;
+ unsigned int ofpfw;
+ ovs_be16 vid, pcp;
+
+ /* Initialize rule->priority. */
+ ofpfw = ntohl(match->wildcards);
+ ofpfw &= flow_format == NXFF_TUN_ID_FROM_COOKIE ? OVSFW_ALL : OFPFW_ALL;
+ rule->priority = !ofpfw ? UINT16_MAX : priority;
+
+ /* Initialize most of rule->wc. */
+ wc->wildcards = ofpfw & WC_INVARIANTS;
+ if (ofpfw & OFPFW_NW_TOS) {
+ wc->wildcards |= FWW_NW_TOS;
+ }
+ memset(wc->reg_masks, 0, sizeof wc->reg_masks);
+ wc->nw_src_mask = ofputil_wcbits_to_netmask(ofpfw >> OFPFW_NW_SRC_SHIFT);
+ wc->nw_dst_mask = ofputil_wcbits_to_netmask(ofpfw >> OFPFW_NW_DST_SHIFT);
+
+ if (flow_format == NXFF_TUN_ID_FROM_COOKIE && !(ofpfw & NXFW_TUN_ID)) {
+ rule->flow.tun_id = htonl(ntohll(cookie) >> 32);
+ } else {
+ wc->wildcards |= FWW_TUN_ID;
+ rule->flow.tun_id = 0;
+ }
+
+ if (ofpfw & OFPFW_DL_DST) {
+ /* OpenFlow 1.0 OFPFW_DL_DST covers the whole Ethernet destination, but
+ * Open vSwitch breaks the Ethernet destination into bits as FWW_DL_DST
+ * and FWW_ETH_MCAST. */
+ wc->wildcards |= FWW_ETH_MCAST;
+ }
+
+ /* Initialize most of rule->flow. */
+ rule->flow.nw_src = match->nw_src;
+ rule->flow.nw_dst = match->nw_dst;
+ rule->flow.in_port = (match->in_port == htons(OFPP_LOCAL) ? ODPP_LOCAL
+ : ntohs(match->in_port));
+ rule->flow.dl_type = match->dl_type;
+ rule->flow.tp_src = match->tp_src;
+ rule->flow.tp_dst = match->tp_dst;
+ memcpy(rule->flow.dl_src, match->dl_src, ETH_ADDR_LEN);
+ memcpy(rule->flow.dl_dst, match->dl_dst, ETH_ADDR_LEN);
+ rule->flow.nw_tos = match->nw_tos;
+ rule->flow.nw_proto = match->nw_proto;
+
+ /* Translate VLANs. */
+ vid = match->dl_vlan & htons(VLAN_VID_MASK);
+ pcp = htons((match->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK);
+ switch (ofpfw & (OFPFW_DL_VLAN | OFPFW_DL_VLAN_PCP)) {
+ case OFPFW_DL_VLAN | OFPFW_DL_VLAN_PCP:
+ /* Wildcard everything. */
+ rule->flow.vlan_tci = htons(0);
+ rule->wc.vlan_tci_mask = htons(0);
+ break;
+
+ case OFPFW_DL_VLAN_PCP:
+ if (match->dl_vlan == htons(OFP_VLAN_NONE)) {
+ /* Match only packets without 802.1Q header. */
+ rule->flow.vlan_tci = htons(0);
+ rule->wc.vlan_tci_mask = htons(0xffff);
+ } else {
+ /* Wildcard PCP, specific VID. */
+ rule->flow.vlan_tci = vid | htons(VLAN_CFI);
+ rule->wc.vlan_tci_mask = htons(VLAN_VID_MASK | VLAN_CFI);
+ }
+ break;
+
+ case OFPFW_DL_VLAN:
+ /* Wildcard VID, specific PCP. */
+ rule->flow.vlan_tci = pcp | htons(VLAN_CFI);
+ rule->wc.vlan_tci_mask = htons(VLAN_PCP_MASK | VLAN_CFI);
+ break;
+
+ case 0:
+ if (match->dl_vlan == htons(OFP_VLAN_NONE)) {
+ /* This case is odd, since we can't have a specific PCP without an
+ * 802.1Q header. However, older versions of OVS treated this as
+ * matching packets withut an 802.1Q header, so we do here too. */
+ rule->flow.vlan_tci = htons(0);
+ rule->wc.vlan_tci_mask = htons(0xffff);
+ } else {
+ /* Specific VID and PCP. */
+ rule->flow.vlan_tci = vid | pcp | htons(VLAN_CFI);
+ rule->wc.vlan_tci_mask = htons(0xffff);
+ }
+ break;
+ }
+
+ /* Clean up. */
+ cls_rule_zero_wildcarded_fields(rule);
+}
+
+/* Extract 'flow' with 'wildcards' into the OpenFlow match structure
+ * 'match'.
+ *
+ * 'flow_format' must either NXFF_OPENFLOW10 or NXFF_TUN_ID_FROM_COOKIE. In
+ * the latter case only, 'match''s NXFW_TUN_ID bit will be filled in; otherwise
+ * it is always set to 0. */
+void
+ofputil_cls_rule_to_match(const struct cls_rule *rule,
+ enum nx_flow_format flow_format,
+ struct ofp_match *match)
+{
+ const struct flow_wildcards *wc = &rule->wc;
+ unsigned int ofpfw;
+
+ /* Figure out most OpenFlow wildcards. */
+ ofpfw = wc->wildcards & WC_INVARIANTS;
+ ofpfw |= ofputil_netmask_to_wcbits(wc->nw_src_mask) << OFPFW_NW_SRC_SHIFT;
+ ofpfw |= ofputil_netmask_to_wcbits(wc->nw_dst_mask) << OFPFW_NW_DST_SHIFT;
+ if (wc->wildcards & FWW_NW_TOS) {
+ ofpfw |= OFPFW_NW_TOS;
+ }
+ if (flow_format == NXFF_TUN_ID_FROM_COOKIE && wc->wildcards & FWW_TUN_ID) {
+ ofpfw |= NXFW_TUN_ID;
+ }
+
+ /* Translate VLANs. */
+ match->dl_vlan = htons(0);
+ match->dl_vlan_pcp = 0;
+ if (rule->wc.vlan_tci_mask == htons(0)) {
+ ofpfw |= OFPFW_DL_VLAN | OFPFW_DL_VLAN_PCP;
+ } else if (rule->wc.vlan_tci_mask & htons(VLAN_CFI)
+ && !(rule->flow.vlan_tci & htons(VLAN_CFI))) {
+ match->dl_vlan = htons(OFP_VLAN_NONE);
+ } else {
+ if (!(rule->wc.vlan_tci_mask & htons(VLAN_VID_MASK))) {
+ ofpfw |= OFPFW_DL_VLAN;
+ } else {
+ match->dl_vlan = htons(vlan_tci_to_vid(rule->flow.vlan_tci));
+ }
+
+ if (!(rule->wc.vlan_tci_mask & htons(VLAN_PCP_MASK))) {
+ ofpfw |= OFPFW_DL_VLAN_PCP;
+ } else {
+ match->dl_vlan_pcp = vlan_tci_to_pcp(rule->flow.vlan_tci);
+ }
+ }
+
+ /* Compose most of the match structure. */
+ match->wildcards = htonl(ofpfw);
+ match->in_port = htons(rule->flow.in_port == ODPP_LOCAL ? OFPP_LOCAL
+ : rule->flow.in_port);
+ memcpy(match->dl_src, rule->flow.dl_src, ETH_ADDR_LEN);
+ memcpy(match->dl_dst, rule->flow.dl_dst, ETH_ADDR_LEN);
+ match->dl_type = rule->flow.dl_type;
+ match->nw_src = rule->flow.nw_src;
+ match->nw_dst = rule->flow.nw_dst;
+ match->nw_tos = rule->flow.nw_tos;
+ match->nw_proto = rule->flow.nw_proto;
+ match->tp_src = rule->flow.tp_src;
+ match->tp_dst = rule->flow.tp_dst;
+ memset(match->pad1, '\0', sizeof match->pad1);
+ memset(match->pad2, '\0', sizeof match->pad2);
+}
+
+/* Returns a transaction ID to use for an outgoing OpenFlow message. */
+static ovs_be32
alloc_xid(void)
{
- return random_uint32();
+ static uint32_t next_xid = 1;
+ return htonl(next_xid++);
}
/* Allocates and stores in '*bufferp' a new ofpbuf with a size of
*
* Returns the header. */
void *
-make_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
+make_openflow_xid(size_t openflow_len, uint8_t type, ovs_be32 xid,
struct ofpbuf **bufferp)
{
*bufferp = ofpbuf_new(openflow_len);
/* Similar to make_openflow_xid() but creates a Nicira vendor extension message
* with the specific 'subtype'. 'subtype' should be in host byte order. */
void *
-make_nxmsg_xid(size_t openflow_len, uint32_t subtype, uint32_t xid,
+make_nxmsg_xid(size_t openflow_len, uint32_t subtype, ovs_be32 xid,
struct ofpbuf **bufferp)
{
struct nicira_header *nxh = make_openflow_xid(openflow_len, OFPT_VENDOR,
*
* Returns the header. */
void *
-put_openflow_xid(size_t openflow_len, uint8_t type, uint32_t xid,
+put_openflow_xid(size_t openflow_len, uint8_t type, ovs_be32 xid,
struct ofpbuf *buffer)
{
struct ofp_header *oh;
}
struct ofpbuf *
-make_flow_mod(uint16_t command, const struct flow *flow, size_t actions_len)
+make_flow_mod(uint16_t command, const struct cls_rule *rule,
+ size_t actions_len)
{
struct ofp_flow_mod *ofm;
size_t size = sizeof *ofm + actions_len;
ofm->header.type = OFPT_FLOW_MOD;
ofm->header.length = htons(size);
ofm->cookie = 0;
- ofm->match.wildcards = htonl(0);
- ofm->match.in_port = htons(flow->in_port == ODPP_LOCAL ? OFPP_LOCAL
- : flow->in_port);
- memcpy(ofm->match.dl_src, flow->dl_src, sizeof ofm->match.dl_src);
- memcpy(ofm->match.dl_dst, flow->dl_dst, sizeof ofm->match.dl_dst);
- ofm->match.dl_vlan = flow->dl_vlan;
- ofm->match.dl_vlan_pcp = flow->dl_vlan_pcp;
- ofm->match.dl_type = flow->dl_type;
- ofm->match.nw_src = flow->nw_src;
- ofm->match.nw_dst = flow->nw_dst;
- ofm->match.nw_proto = flow->nw_proto;
- ofm->match.nw_tos = flow->nw_tos;
- ofm->match.tp_src = flow->tp_src;
- ofm->match.tp_dst = flow->tp_dst;
+ ofm->priority = htons(MIN(rule->priority, UINT16_MAX));
+ ofputil_cls_rule_to_match(rule, NXFF_OPENFLOW10, &ofm->match);
ofm->command = htons(command);
return out;
}
struct ofpbuf *
-make_add_flow(const struct flow *flow, uint32_t buffer_id,
+make_add_flow(const struct cls_rule *rule, uint32_t buffer_id,
uint16_t idle_timeout, size_t actions_len)
{
- struct ofpbuf *out = make_flow_mod(OFPFC_ADD, flow, actions_len);
+ struct ofpbuf *out = make_flow_mod(OFPFC_ADD, rule, actions_len);
struct ofp_flow_mod *ofm = out->data;
ofm->idle_timeout = htons(idle_timeout);
ofm->hard_timeout = htons(OFP_FLOW_PERMANENT);
}
struct ofpbuf *
-make_del_flow(const struct flow *flow)
+make_del_flow(const struct cls_rule *rule)
{
- struct ofpbuf *out = make_flow_mod(OFPFC_DELETE_STRICT, flow, 0);
+ struct ofpbuf *out = make_flow_mod(OFPFC_DELETE_STRICT, rule, 0);
struct ofp_flow_mod *ofm = out->data;
ofm->out_port = htons(OFPP_NONE);
return out;
}
struct ofpbuf *
-make_add_simple_flow(const struct flow *flow,
+make_add_simple_flow(const struct cls_rule *rule,
uint32_t buffer_id, uint16_t out_port,
uint16_t idle_timeout)
{
struct ofp_action_output *oao;
struct ofpbuf *buffer;
- buffer = make_add_flow(flow, buffer_id, idle_timeout, sizeof *oao);
+ buffer = make_add_flow(rule, buffer_id, idle_timeout, sizeof *oao);
oao = ofpbuf_put_zeros(buffer, sizeof *oao);
oao->type = htons(OFPAT_OUTPUT);
oao->len = htons(sizeof *oao);
oao->port = htons(out_port);
return buffer;
} else {
- return make_add_flow(flow, buffer_id, idle_timeout, 0);
+ return make_add_flow(rule, buffer_id, idle_timeout, 0);
}
}
rq->version = OFP_VERSION;
rq->type = OFPT_ECHO_REQUEST;
rq->length = htons(sizeof *rq);
- rq->xid = 0;
+ rq->xid = htonl(0);
return out;
}
return fs;
}
-/* Alignment of ofp_actions. */
-#define ACTION_ALIGNMENT 8
-
static int
check_action_exact_len(const union ofp_action *a, unsigned int len,
unsigned int required_len)
}
static int
-check_nicira_action(const union ofp_action *a, unsigned int len)
+check_nicira_action(const union ofp_action *a, unsigned int len,
+ const struct flow *flow)
{
const struct nx_action_header *nah;
+ int error;
if (len < 16) {
VLOG_DBG_RL(&bad_ofmsg_rl,
case NXAST_SET_QUEUE:
case NXAST_POP_QUEUE:
return check_action_exact_len(a, len, 16);
+
+ case NXAST_REG_MOVE:
+ error = check_action_exact_len(a, len,
+ sizeof(struct nx_action_reg_move));
+ if (error) {
+ return error;
+ }
+ return nxm_check_reg_move((const struct nx_action_reg_move *) a, flow);
+
+ case NXAST_REG_LOAD:
+ error = check_action_exact_len(a, len,
+ sizeof(struct nx_action_reg_load));
+ if (error) {
+ return error;
+ }
+ return nxm_check_reg_load((const struct nx_action_reg_load *) a, flow);
+
+ case NXAST_NOTE:
+ return 0;
+
default:
return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE);
}
}
static int
-check_action(const union ofp_action *a, unsigned int len, int max_ports)
+check_action(const union ofp_action *a, unsigned int len,
+ const struct flow *flow, int max_ports)
{
int error;
case OFPAT_VENDOR:
return (a->vendor.vendor == htonl(NX_VENDOR_ID)
- ? check_nicira_action(a, len)
+ ? check_nicira_action(a, len, flow)
: ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR));
case OFPAT_ENQUEUE:
int
validate_actions(const union ofp_action *actions, size_t n_actions,
- int max_ports)
+ const struct flow *flow, int max_ports)
{
size_t i;
for (i = 0; i < n_actions; ) {
const union ofp_action *a = &actions[i];
unsigned int len = ntohs(a->header.len);
- unsigned int n_slots = len / ACTION_ALIGNMENT;
+ unsigned int n_slots = len / OFP_ACTION_ALIGN;
unsigned int slots_left = &actions[n_actions] - a;
int error;
} else if (!len) {
VLOG_DBG_RL(&bad_ofmsg_rl, "action has invalid length 0");
return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
- } else if (len % ACTION_ALIGNMENT) {
+ } else if (len % OFP_ACTION_ALIGN) {
VLOG_DBG_RL(&bad_ofmsg_rl, "action length %u is not a multiple "
- "of %d", len, ACTION_ALIGNMENT);
+ "of %d", len, OFP_ACTION_ALIGN);
return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_BAD_LEN);
}
- error = check_action(a, len, max_ports);
+ error = check_action(a, len, flow, max_ports);
if (error) {
return error;
}
if (iter->pos != iter->end) {
const union ofp_action *a = iter->pos;
unsigned int len = ntohs(a->header.len);
- iter->pos += len / ACTION_ALIGNMENT;
+ iter->pos += len / OFP_ACTION_ALIGN;
return a;
} else {
return NULL;
m->tp_src = m->tp_dst = 0;
}
if (wc & OFPFW_NW_SRC_MASK) {
- m->nw_src &= flow_nw_bits_to_mask(wc, OFPFW_NW_SRC_SHIFT);
+ m->nw_src &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_SRC_SHIFT);
}
if (wc & OFPFW_NW_DST_MASK) {
- m->nw_dst &= flow_nw_bits_to_mask(wc, OFPFW_NW_DST_SHIFT);
+ m->nw_dst &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_DST_SHIFT);
}
if (wc & OFPFW_NW_TOS) {
m->nw_tos = 0;
m->nw_proto = 0;
}
if (wc & OFPFW_NW_SRC_MASK) {
- m->nw_src &= flow_nw_bits_to_mask(wc, OFPFW_NW_SRC_SHIFT);
+ m->nw_src &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_SRC_SHIFT);
}
if (wc & OFPFW_NW_DST_MASK) {
- m->nw_dst &= flow_nw_bits_to_mask(wc, OFPFW_NW_DST_SHIFT);
+ m->nw_dst &= ofputil_wcbits_to_netmask(wc >> OFPFW_NW_DST_SHIFT);
}
m->tp_src = m->tp_dst = m->nw_tos = 0;
} else {
uint8_t vendor;
uint16_t type;
uint16_t code;
- uint32_t xid;
+ ovs_be32 xid;
if (!is_ofp_error(error)) {
/* We format 'error' with strerror() here since it seems likely to be
ofputil_pull_actions(struct ofpbuf *b, unsigned int actions_len,
union ofp_action **actionsp, size_t *n_actionsp)
{
- if (actions_len % ACTION_ALIGNMENT != 0) {
+ if (actions_len % OFP_ACTION_ALIGN != 0) {
VLOG_DBG_RL(&bad_ofmsg_rl, "OpenFlow message actions length %u "
- "is not a multiple of %d", actions_len, ACTION_ALIGNMENT);
+ "is not a multiple of %d", actions_len, OFP_ACTION_ALIGN);
goto error;
}
goto error;
}
- *n_actionsp = actions_len / ACTION_ALIGNMENT;
+ *n_actionsp = actions_len / OFP_ACTION_ALIGN;
return 0;
error:
projects / openvswitch / blobdiff