/*
- * Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks.
+ * Copyright (c) 2009, 2010, 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.
rule->flow.regs[reg_idx] = value & mask;
}
+void
+cls_rule_set_metadata(struct cls_rule *rule, ovs_be64 metadata)
+{
+ cls_rule_set_metadata_masked(rule, metadata, htonll(UINT64_MAX));
+}
+
+void
+cls_rule_set_metadata_masked(struct cls_rule *rule, ovs_be64 metadata,
+ ovs_be64 mask)
+{
+ rule->wc.metadata_mask = mask;
+ rule->flow.metadata = metadata & mask;
+}
+
void
cls_rule_set_tun_id(struct cls_rule *rule, ovs_be64 tun_id)
{
rule->flow.dl_type = dl_type;
}
+/* Modifies 'value_src' so that the Ethernet address must match
+ * 'value_dst' exactly. 'mask_dst' is set to all 1s */
+static void
+cls_rule_set_eth(const uint8_t value_src[ETH_ADDR_LEN],
+ uint8_t value_dst[ETH_ADDR_LEN],
+ uint8_t mask_dst[ETH_ADDR_LEN])
+{
+ memcpy(value_dst, value_src, ETH_ADDR_LEN);
+ memset(mask_dst, 0xff, ETH_ADDR_LEN);
+}
+
+/* Modifies 'value_src' so that the Ethernet address must match
+ * 'value_src' after each byte is ANDed with the appropriate byte in
+ * 'mask_src'. 'mask_dst' is set to 'mask_src' */
+static void
+cls_rule_set_eth_masked(const uint8_t value_src[ETH_ADDR_LEN],
+ const uint8_t mask_src[ETH_ADDR_LEN],
+ uint8_t value_dst[ETH_ADDR_LEN],
+ uint8_t mask_dst[ETH_ADDR_LEN])
+{
+ size_t i;
+
+ for (i = 0; i < ETH_ADDR_LEN; i++) {
+ value_dst[i] = value_src[i] & mask_src[i];
+ mask_dst[i] = mask_src[i];
+ }
+}
+
+/* Modifies 'rule' so that the source Ethernet address
+ * must match 'dl_src' exactly. */
void
cls_rule_set_dl_src(struct cls_rule *rule, const uint8_t dl_src[ETH_ADDR_LEN])
{
- rule->wc.wildcards &= ~FWW_DL_SRC;
- memcpy(rule->flow.dl_src, dl_src, ETH_ADDR_LEN);
+ cls_rule_set_eth(dl_src, rule->flow.dl_src, rule->wc.dl_src_mask);
+}
+
+/* Modifies 'rule' so that the source Ethernet address
+ * must match 'dl_src' after each byte is ANDed with
+ * the appropriate byte in 'mask'. */
+void
+cls_rule_set_dl_src_masked(struct cls_rule *rule,
+ const uint8_t dl_src[ETH_ADDR_LEN],
+ const uint8_t mask[ETH_ADDR_LEN])
+{
+ cls_rule_set_eth_masked(dl_src, mask,
+ rule->flow.dl_src, rule->wc.dl_src_mask);
}
-/* Modifies 'rule' so that the Ethernet address must match 'dl_dst' exactly. */
+/* Modifies 'rule' so that the destination Ethernet address
+ * must match 'dl_dst' exactly. */
void
cls_rule_set_dl_dst(struct cls_rule *rule, const uint8_t dl_dst[ETH_ADDR_LEN])
{
- rule->wc.wildcards &= ~(FWW_DL_DST | FWW_ETH_MCAST);
- memcpy(rule->flow.dl_dst, dl_dst, ETH_ADDR_LEN);
+ cls_rule_set_eth(dl_dst, rule->flow.dl_dst, rule->wc.dl_dst_mask);
}
-/* Modifies 'rule' so that the Ethernet address must match 'dl_dst' after each
- * byte is ANDed with the appropriate byte in 'mask'.
- *
- * This function will assert-fail if 'mask' is invalid. Only 'mask' values
- * accepted by flow_wildcards_is_dl_dst_mask_valid() are allowed. */
+/* Modifies 'rule' so that the destination Ethernet address
+ * must match 'dl_src' after each byte is ANDed with
+ * the appropriate byte in 'mask'. */
void
cls_rule_set_dl_dst_masked(struct cls_rule *rule,
const uint8_t dl_dst[ETH_ADDR_LEN],
const uint8_t mask[ETH_ADDR_LEN])
{
- flow_wildcards_t *wc = &rule->wc.wildcards;
- size_t i;
-
- *wc = flow_wildcards_set_dl_dst_mask(*wc, mask);
- for (i = 0; i < ETH_ADDR_LEN; i++) {
- rule->flow.dl_dst[i] = dl_dst[i] & mask[i];
- }
+ cls_rule_set_eth_masked(dl_dst, mask,
+ rule->flow.dl_dst, rule->wc.dl_dst_mask);
}
void
void
cls_rule_set_dl_vlan(struct cls_rule *rule, ovs_be16 dl_vlan)
{
- flow_set_vlan_vid(&rule->flow, dl_vlan);
- if (dl_vlan == htons(OFP_VLAN_NONE)) {
+ flow_set_dl_vlan(&rule->flow, dl_vlan);
+ if (dl_vlan == htons(OFP10_VLAN_NONE)) {
rule->wc.vlan_tci_mask = htons(UINT16_MAX);
} else {
rule->wc.vlan_tci_mask |= htons(VLAN_VID_MASK | VLAN_CFI);
}
}
+/* Sets the VLAN VID that 'flow' matches to 'vid', which is interpreted as an
+ * OpenFlow 1.2 "vlan_vid" value, that is, the low 13 bits of 'vlan_tci' (VID
+ * plus CFI). */
+void
+cls_rule_set_vlan_vid(struct cls_rule *rule, ovs_be16 vid)
+{
+ cls_rule_set_vlan_vid_masked(rule, vid, htons(VLAN_VID_MASK | VLAN_CFI));
+}
+
+
+/* Sets the VLAN VID that 'flow' matches to 'vid', which is interpreted as an
+ * OpenFlow 1.2 "vlan_vid" value, that is, the low 13 bits of 'vlan_tci' (VID
+ * plus CFI), with the corresponding 'mask'. */
+void
+cls_rule_set_vlan_vid_masked(struct cls_rule *rule,
+ ovs_be16 vid, ovs_be16 mask)
+{
+ ovs_be16 pcp_mask = htons(VLAN_PCP_MASK);
+ ovs_be16 vid_mask = htons(VLAN_VID_MASK | VLAN_CFI);
+
+ mask &= vid_mask;
+ flow_set_vlan_vid(&rule->flow, vid & mask);
+ rule->wc.vlan_tci_mask = mask | (rule->wc.vlan_tci_mask & pcp_mask);
+}
+
/* Modifies 'rule' so that the VLAN PCP is wildcarded. If the VID is already
* wildcarded, then 'rule' will match a packet regardless of whether it has an
* 802.1Q header or not. */
void
cls_rule_set_arp_sha(struct cls_rule *rule, const uint8_t sha[ETH_ADDR_LEN])
{
- rule->wc.wildcards &= ~FWW_ARP_SHA;
- memcpy(rule->flow.arp_sha, sha, ETH_ADDR_LEN);
+ cls_rule_set_eth(sha, rule->flow.arp_sha, rule->wc.arp_sha_mask);
+}
+
+void
+cls_rule_set_arp_sha_masked(struct cls_rule *rule,
+ const uint8_t arp_sha[ETH_ADDR_LEN],
+ const uint8_t mask[ETH_ADDR_LEN])
+{
+ cls_rule_set_eth_masked(arp_sha, mask,
+ rule->flow.arp_sha, rule->wc.arp_sha_mask);
}
void
cls_rule_set_arp_tha(struct cls_rule *rule, const uint8_t tha[ETH_ADDR_LEN])
{
- rule->wc.wildcards &= ~FWW_ARP_THA;
- memcpy(rule->flow.arp_tha, tha, ETH_ADDR_LEN);
+ cls_rule_set_eth(tha, rule->flow.arp_tha, rule->wc.arp_tha_mask);
+}
+
+void
+cls_rule_set_arp_tha_masked(struct cls_rule *rule,
+ const uint8_t arp_tha[ETH_ADDR_LEN],
+ const uint8_t mask[ETH_ADDR_LEN])
+{
+ cls_rule_set_eth_masked(arp_tha, mask,
+ rule->flow.arp_tha, rule->wc.arp_tha_mask);
}
void
void
cls_rule_set_ipv6_label(struct cls_rule *rule, ovs_be32 ipv6_label)
{
- rule->wc.wildcards &= ~FWW_IPV6_LABEL;
- rule->flow.ipv6_label = ipv6_label;
+ cls_rule_set_ipv6_label_masked(rule, ipv6_label, htonl(UINT32_MAX));
+}
+
+void
+cls_rule_set_ipv6_label_masked(struct cls_rule *rule, ovs_be32 ipv6_label,
+ ovs_be32 mask)
+{
+ rule->flow.ipv6_label = ipv6_label & mask;
+ rule->wc.ipv6_label_mask = mask;
}
void
return hash_int(rule->priority, h1);
}
+static void
+format_eth_masked(struct ds *s, const char *name, const uint8_t eth[6],
+ const uint8_t mask[6])
+{
+ if (!eth_addr_is_zero(mask)) {
+ ds_put_format(s, "%s=", name);
+ eth_format_masked(eth, mask, s);
+ ds_put_char(s, ',');
+ }
+}
+
static void
format_ip_netmask(struct ds *s, const char *name, ovs_be32 ip,
ovs_be32 netmask)
int i;
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 10);
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 14);
if (rule->priority != OFP_DEFAULT_PRIORITY) {
ds_put_format(s, "priority=%d,", rule->priority);
ntohll(f->tun_id), ntohll(wc->tun_id_mask));
break;
}
+ switch (wc->metadata_mask) {
+ case 0:
+ break;
+ case CONSTANT_HTONLL(UINT64_MAX):
+ ds_put_format(s, "metadata=%#"PRIx64",", ntohll(f->metadata));
+ break;
+ default:
+ ds_put_format(s, "metadata=%#"PRIx64"/%#"PRIx64",",
+ ntohll(f->metadata), ntohll(wc->metadata_mask));
+ break;
+ }
if (!(w & FWW_IN_PORT)) {
ds_put_format(s, "in_port=%"PRIu16",", f->in_port);
}
ntohs(f->vlan_tci), ntohs(wc->vlan_tci_mask));
}
}
- if (!(w & FWW_DL_SRC)) {
- ds_put_format(s, "dl_src="ETH_ADDR_FMT",", ETH_ADDR_ARGS(f->dl_src));
- }
- switch (w & (FWW_DL_DST | FWW_ETH_MCAST)) {
- case 0:
- ds_put_format(s, "dl_dst="ETH_ADDR_FMT",", ETH_ADDR_ARGS(f->dl_dst));
- break;
- case FWW_DL_DST:
- ds_put_format(s, "dl_dst="ETH_ADDR_FMT"/01:00:00:00:00:00,",
- ETH_ADDR_ARGS(f->dl_dst));
- break;
- case FWW_ETH_MCAST:
- ds_put_format(s, "dl_dst="ETH_ADDR_FMT"/fe:ff:ff:ff:ff:ff,",
- ETH_ADDR_ARGS(f->dl_dst));
- break;
- case FWW_DL_DST | FWW_ETH_MCAST:
- break;
- }
+ format_eth_masked(s, "dl_src", f->dl_src, wc->dl_src_mask);
+ format_eth_masked(s, "dl_dst", f->dl_dst, wc->dl_dst_mask);
if (!skip_type && !(w & FWW_DL_TYPE)) {
ds_put_format(s, "dl_type=0x%04"PRIx16",", ntohs(f->dl_type));
}
if (f->dl_type == htons(ETH_TYPE_IPV6)) {
format_ipv6_netmask(s, "ipv6_src", &f->ipv6_src, &wc->ipv6_src_mask);
format_ipv6_netmask(s, "ipv6_dst", &f->ipv6_dst, &wc->ipv6_dst_mask);
- if (!(w & FWW_IPV6_LABEL)) {
- ds_put_format(s, "ipv6_label=0x%05"PRIx32",", ntohl(f->ipv6_label));
+ if (wc->ipv6_label_mask) {
+ if (wc->ipv6_label_mask == htonl(UINT32_MAX)) {
+ ds_put_format(s, "ipv6_label=0x%05"PRIx32",",
+ ntohl(f->ipv6_label));
+ } else {
+ ds_put_format(s, "ipv6_label=0x%05"PRIx32"/0x%05"PRIx32",",
+ ntohl(f->ipv6_label),
+ ntohl(wc->ipv6_label_mask));
+ }
}
} else {
format_ip_netmask(s, "nw_src", f->nw_src, wc->nw_src_mask);
}
}
if (f->dl_type == htons(ETH_TYPE_ARP)) {
- if (!(w & FWW_ARP_SHA)) {
- ds_put_format(s, "arp_sha="ETH_ADDR_FMT",",
- ETH_ADDR_ARGS(f->arp_sha));
- }
- if (!(w & FWW_ARP_THA)) {
- ds_put_format(s, "arp_tha="ETH_ADDR_FMT",",
- ETH_ADDR_ARGS(f->arp_tha));
- }
+ format_eth_masked(s, "arp_sha", f->arp_sha, wc->arp_sha_mask);
+ format_eth_masked(s, "arp_tha", f->arp_tha, wc->arp_tha_mask);
}
if (!(w & FWW_NW_DSCP)) {
ds_put_format(s, "nw_tos=%"PRIu8",", f->nw_tos & IP_DSCP_MASK);
format_be16_masked(s, "icmp_code", f->tp_dst, wc->tp_dst_mask);
format_ipv6_netmask(s, "nd_target", &f->nd_target,
&wc->nd_target_mask);
- if (!(w & FWW_ARP_SHA)) {
- ds_put_format(s, "nd_sll="ETH_ADDR_FMT",",
- ETH_ADDR_ARGS(f->arp_sha));
- }
- if (!(w & FWW_ARP_THA)) {
- ds_put_format(s, "nd_tll="ETH_ADDR_FMT",",
- ETH_ADDR_ARGS(f->arp_tha));
- }
+ format_eth_masked(s, "nd_sll", f->arp_sha, wc->arp_sha_mask);
+ format_eth_masked(s, "nd_tll", f->arp_tha, wc->arp_tha_mask);
} else {
format_be16_masked(s, "tp_src", f->tp_src, wc->tp_src_mask);
format_be16_masked(s, "tp_dst", f->tp_dst, wc->tp_dst_mask);
return false;
}
+
+/* Returns true if 'rule' exactly matches 'criteria' or if 'rule' is more
+ * specific than 'criteria'. That is, 'rule' matches 'criteria' and this
+ * function returns true if, for every field:
+ *
+ * - 'criteria' and 'rule' specify the same (non-wildcarded) value for the
+ * field, or
+ *
+ * - 'criteria' wildcards the field,
+ *
+ * Conversely, 'rule' does not match 'criteria' and this function returns false
+ * if, for at least one field:
+ *
+ * - 'criteria' and 'rule' specify different values for the field, or
+ *
+ * - 'criteria' specifies a value for the field but 'rule' wildcards it.
+ *
+ * Equivalently, the truth table for whether a field matches is:
+ *
+ * rule
+ *
+ * c wildcard exact
+ * r +---------+---------+
+ * i wild | yes | yes |
+ * t card | | |
+ * e +---------+---------+
+ * r exact | no |if values|
+ * i | |are equal|
+ * a +---------+---------+
+ *
+ * This is the matching rule used by OpenFlow 1.0 non-strict OFPT_FLOW_MOD
+ * commands and by OpenFlow 1.0 aggregate and flow stats.
+ *
+ * Ignores rule->priority and criteria->priority. */
+bool
+cls_rule_is_loose_match(const struct cls_rule *rule,
+ const struct cls_rule *criteria)
+{
+ return (!flow_wildcards_has_extra(&rule->wc, &criteria->wc)
+ && flow_equal_except(&rule->flow, &criteria->flow, &criteria->wc));
+}
\f
/* Iteration. */
return NULL;
}
-/* Initializes 'cursor' for iterating through 'cls' rules that exactly match
- * 'target' or are more specific than 'target'. That is, a given 'rule'
- * matches 'target' if, for every field:
+/* Initializes 'cursor' for iterating through rules in 'cls':
*
- * - 'target' and 'rule' specify the same (non-wildcarded) value for the
- * field, or
- *
- * - 'target' wildcards the field,
- *
- * but not if:
- *
- * - 'target' and 'rule' specify different values for the field, or
- *
- * - 'target' specifies a value for the field but 'rule' wildcards it.
- *
- * Equivalently, the truth table for whether a field matches is:
- *
- * rule
- *
- * wildcard exact
- * +---------+---------+
- * t wild | yes | yes |
- * a card | | |
- * r +---------+---------+
- * g exact | no |if values|
- * e | |are equal|
- * t +---------+---------+
- *
- * This is the matching rule used by OpenFlow 1.0 non-strict OFPT_FLOW_MOD
- * commands and by OpenFlow 1.0 aggregate and flow stats.
+ * - If 'target' is null, the cursor will visit every rule in 'cls'.
*
- * Ignores target->priority.
+ * - If 'target' is nonnull, the cursor will visit each 'rule' in 'cls'
+ * such that cls_rule_is_loose_match(rule, target) returns true.
*
- * 'target' may be NULL to iterate over every rule in 'cls'. */
+ * Ignores target->priority. */
void
cls_cursor_init(struct cls_cursor *cursor, const struct classifier *cls,
const struct cls_rule *target)
const flow_wildcards_t wc = wildcards->wildcards;
int i;
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 10);
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 14);
for (i = 0; i < FLOW_N_REGS; i++) {
if ((a->regs[i] ^ b->regs[i]) & wildcards->reg_masks[i]) {
}
return (!((a->tun_id ^ b->tun_id) & wildcards->tun_id_mask)
+ && !((a->metadata ^ b->metadata) & wildcards->metadata_mask)
&& !((a->nw_src ^ b->nw_src) & wildcards->nw_src_mask)
&& !((a->nw_dst ^ b->nw_dst) & wildcards->nw_dst_mask)
&& (wc & FWW_IN_PORT || a->in_port == b->in_port)
&& (wc & FWW_DL_TYPE || a->dl_type == b->dl_type)
&& !((a->tp_src ^ b->tp_src) & wildcards->tp_src_mask)
&& !((a->tp_dst ^ b->tp_dst) & wildcards->tp_dst_mask)
- && (wc & FWW_DL_SRC || eth_addr_equals(a->dl_src, b->dl_src))
- && (wc & FWW_DL_DST
- || (!((a->dl_dst[0] ^ b->dl_dst[0]) & 0xfe)
- && a->dl_dst[1] == b->dl_dst[1]
- && a->dl_dst[2] == b->dl_dst[2]
- && a->dl_dst[3] == b->dl_dst[3]
- && a->dl_dst[4] == b->dl_dst[4]
- && a->dl_dst[5] == b->dl_dst[5]))
- && (wc & FWW_ETH_MCAST
- || !((a->dl_dst[0] ^ b->dl_dst[0]) & 0x01))
+ && eth_addr_equal_except(a->dl_src, b->dl_src,
+ wildcards->dl_src_mask)
+ && eth_addr_equal_except(a->dl_dst, b->dl_dst,
+ wildcards->dl_dst_mask)
&& (wc & FWW_NW_PROTO || a->nw_proto == b->nw_proto)
&& (wc & FWW_NW_TTL || a->nw_ttl == b->nw_ttl)
&& (wc & FWW_NW_DSCP || !((a->nw_tos ^ b->nw_tos) & IP_DSCP_MASK))
&& (wc & FWW_NW_ECN || !((a->nw_tos ^ b->nw_tos) & IP_ECN_MASK))
&& !((a->nw_frag ^ b->nw_frag) & wildcards->nw_frag_mask)
- && (wc & FWW_ARP_SHA || eth_addr_equals(a->arp_sha, b->arp_sha))
- && (wc & FWW_ARP_THA || eth_addr_equals(a->arp_tha, b->arp_tha))
- && (wc & FWW_IPV6_LABEL || a->ipv6_label == b->ipv6_label)
+ && eth_addr_equal_except(a->arp_sha, b->arp_sha,
+ wildcards->arp_sha_mask)
+ && eth_addr_equal_except(a->arp_tha, b->arp_tha,
+ wildcards->arp_tha_mask)
+ && !((a->ipv6_label ^ b->ipv6_label) & wildcards->ipv6_label_mask)
&& ipv6_equal_except(&a->ipv6_src, &b->ipv6_src,
&wildcards->ipv6_src_mask)
&& ipv6_equal_except(&a->ipv6_dst, &b->ipv6_dst,
projects / openvswitch / blobdiff