/*
- * Copyright (c) 2008, 2009, 2010 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
VLOG_DEFINE_THIS_MODULE(flow);
+COVERAGE_DEFINE(flow_extract);
+
static struct arp_eth_header *
pull_arp(struct ofpbuf *packet)
{
if (b->size >= sizeof(struct qtag_prefix) + sizeof(ovs_be16)) {
struct qtag_prefix *qp = ofpbuf_pull(b, sizeof *qp);
- flow->dl_vlan = qp->tci & htons(VLAN_VID_MASK);
- flow->dl_vlan_pcp = vlan_tci_to_pcp(qp->tci);
+ flow->vlan_tci = qp->tci | htons(VLAN_CFI);
}
}
* present and has a correct length, and otherwise NULL.
*/
int
-flow_extract(struct ofpbuf *packet, ovs_be32 tun_id, uint16_t in_port,
+flow_extract(struct ofpbuf *packet, ovs_be64 tun_id, uint16_t in_port,
struct flow *flow)
{
struct ofpbuf b = *packet;
memset(flow, 0, sizeof *flow);
flow->tun_id = tun_id;
flow->in_port = in_port;
- flow->dl_vlan = htons(OFP_VLAN_NONE);
packet->l2 = b.data;
packet->l3 = NULL;
memcpy(flow->dl_src, eth->eth_src, ETH_ADDR_LEN);
memcpy(flow->dl_dst, eth->eth_dst, ETH_ADDR_LEN);
- /* dl_type, dl_vlan, dl_vlan_pcp. */
+ /* dl_type, vlan_tci. */
ofpbuf_pull(&b, ETH_ADDR_LEN * 2);
if (eth->eth_type == htons(ETH_TYPE_VLAN)) {
parse_vlan(&b, flow);
if (flow->dl_type == htons(ETH_TYPE_IP)) {
const struct ip_header *nh = pull_ip(&b);
if (nh) {
- flow->nw_src = get_unaligned_u32(&nh->ip_src);
- flow->nw_dst = get_unaligned_u32(&nh->ip_dst);
+ flow->nw_src = get_unaligned_be32(&nh->ip_src);
+ flow->nw_dst = get_unaligned_be32(&nh->ip_dst);
flow->nw_tos = nh->ip_tos & IP_DSCP_MASK;
flow->nw_proto = nh->ip_proto;
packet->l4 = b.data;
void
flow_format(struct ds *ds, const struct flow *flow)
{
- ds_put_format(ds, "tunnel%08"PRIx32":in_port%04"PRIx16
- ":vlan%"PRIu16":pcp%"PRIu8
- " mac"ETH_ADDR_FMT"->"ETH_ADDR_FMT
+ ds_put_format(ds, "tunnel%#"PRIx64":in_port%04"PRIx16":tci(",
+ flow->tun_id, flow->in_port);
+ if (flow->vlan_tci) {
+ ds_put_format(ds, "vlan%"PRIu16",pcp%d",
+ vlan_tci_to_vid(flow->vlan_tci),
+ vlan_tci_to_pcp(flow->vlan_tci));
+ } else {
+ ds_put_char(ds, '0');
+ }
+ ds_put_format(ds, ") mac"ETH_ADDR_FMT"->"ETH_ADDR_FMT
" type%04"PRIx16
" proto%"PRIu8
" tos%"PRIu8
" ip"IP_FMT"->"IP_FMT
" port%"PRIu16"->%"PRIu16,
- ntohl(flow->tun_id),
- flow->in_port,
- ntohs(flow->dl_vlan),
- flow->dl_vlan_pcp,
ETH_ADDR_ARGS(flow->dl_src),
ETH_ADDR_ARGS(flow->dl_dst),
ntohs(flow->dl_type),
\f
/* flow_wildcards functions. */
-/* Return 'wildcards' in "normal form":
- *
- * - Forces unknown bits to 0.
- *
- * - Forces nw_src and nw_dst masks greater than 32 to exactly 32.
- */
-static inline uint32_t
-flow_wildcards_normalize(uint32_t wildcards)
-{
- wildcards &= wildcards & (OVSFW_ALL | FWW_ALL);
- if (wildcards & (0x20 << OFPFW_NW_SRC_SHIFT)) {
- wildcards &= ~(0x1f << OFPFW_NW_SRC_SHIFT);
- }
- if (wildcards & (0x20 << OFPFW_NW_DST_SHIFT)) {
- wildcards &= ~(0x1f << OFPFW_NW_DST_SHIFT);
- }
- return wildcards;
-}
-
-/* Initializes 'wc' from 'wildcards', which may be any combination of the
- * OFPFW_* and OVSFW_* wildcard bits.
- *
- * All registers (NXM_NX_REG*) are always completely wildcarded, because
- * 'wildcards' doesn't have enough bits to give the details on which
- * particular bits should be wildcarded (if any). The caller may use
- * flow_wildcards_set_reg_mask() to update the register wildcard masks. */
+/* Initializes 'wc' as a set of wildcards that matches every packet. */
void
-flow_wildcards_init(struct flow_wildcards *wc, uint32_t wildcards)
+flow_wildcards_init_catchall(struct flow_wildcards *wc)
{
- wc->wildcards = flow_wildcards_normalize(wildcards) | FWW_REGS;
- wc->nw_src_mask = ofputil_wcbits_to_netmask(wildcards >> OFPFW_NW_SRC_SHIFT);
- wc->nw_dst_mask = ofputil_wcbits_to_netmask(wildcards >> OFPFW_NW_DST_SHIFT);
+ wc->wildcards = FWW_ALL;
+ wc->tun_id_mask = htonll(0);
+ wc->nw_src_mask = htonl(0);
+ wc->nw_dst_mask = htonl(0);
memset(wc->reg_masks, 0, sizeof wc->reg_masks);
+ wc->vlan_tci_mask = htons(0);
+ wc->zero = 0;
}
/* Initializes 'wc' as an exact-match set of wildcards; that is, 'wc' does not
flow_wildcards_init_exact(struct flow_wildcards *wc)
{
wc->wildcards = 0;
+ wc->tun_id_mask = htonll(UINT64_MAX);
wc->nw_src_mask = htonl(UINT32_MAX);
wc->nw_dst_mask = htonl(UINT32_MAX);
memset(wc->reg_masks, 0xff, sizeof wc->reg_masks);
+ wc->vlan_tci_mask = htons(UINT16_MAX);
+ wc->zero = 0;
}
/* Returns true if 'wc' is exact-match, false if 'wc' wildcards any bits or
bool
flow_wildcards_is_exact(const struct flow_wildcards *wc)
{
- return !wc->wildcards;
-}
+ int i;
-static inline uint32_t
-combine_nw_bits(uint32_t wb1, uint32_t wb2, int shift)
-{
- uint32_t sb1 = (wb1 >> shift) & 0x3f;
- uint32_t sb2 = (wb2 >> shift) & 0x3f;
- return MAX(sb1, sb2) << shift;
+ if (wc->wildcards
+ || wc->tun_id_mask != htonll(UINT64_MAX)
+ || wc->nw_src_mask != htonl(UINT32_MAX)
+ || wc->nw_dst_mask != htonl(UINT32_MAX)
+ || wc->vlan_tci_mask != htons(UINT16_MAX)) {
+ return false;
+ }
+
+ for (i = 0; i < FLOW_N_REGS; i++) {
+ if (wc->reg_masks[i] != htonl(UINT32_MAX)) {
+ return false;
+ }
+ }
+
+ return true;
}
/* Initializes 'dst' as the combination of wildcards in 'src1' and 'src2'.
const struct flow_wildcards *src1,
const struct flow_wildcards *src2)
{
- uint32_t wb1 = src1->wildcards;
- uint32_t wb2 = src2->wildcards;
int i;
- dst->wildcards = (wb1 | wb2) & ~(OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK);
- dst->wildcards |= combine_nw_bits(wb1, wb2, OFPFW_NW_SRC_SHIFT);
- dst->wildcards |= combine_nw_bits(wb1, wb2, OFPFW_NW_DST_SHIFT);
+ dst->wildcards = src1->wildcards | src2->wildcards;
+ dst->tun_id_mask = src1->tun_id_mask & src2->tun_id_mask;
dst->nw_src_mask = src1->nw_src_mask & src2->nw_src_mask;
dst->nw_dst_mask = src1->nw_dst_mask & src2->nw_dst_mask;
for (i = 0; i < FLOW_N_REGS; i++) {
dst->reg_masks[i] = src1->reg_masks[i] & src2->reg_masks[i];
}
+ dst->vlan_tci_mask = src1->vlan_tci_mask & src2->vlan_tci_mask;
}
/* Returns a hash of the wildcards in 'wc'. */
uint32_t
flow_wildcards_hash(const struct flow_wildcards *wc)
{
- /* There is no need to include nw_src_mask or nw_dst_mask because they do
- * not add any information (they can be computed from wc->wildcards). */
- BUILD_ASSERT_DECL(sizeof wc->wildcards == 4);
- BUILD_ASSERT_DECL(sizeof wc->reg_masks == 4 * FLOW_N_REGS);
- BUILD_ASSERT_DECL(offsetof(struct flow_wildcards, wildcards) == 0);
- BUILD_ASSERT_DECL(offsetof(struct flow_wildcards, reg_masks) == 4);
- return hash_words((const uint32_t *) wc, 1 + FLOW_N_REGS, 0);
+ /* If you change struct flow_wildcards and thereby trigger this
+ * assertion, please check that the new struct flow_wildcards has no holes
+ * in it before you update the assertion. */
+ BUILD_ASSERT_DECL(sizeof *wc == 24 + FLOW_N_REGS * 4);
+ return hash_bytes(wc, sizeof *wc, 0);
}
/* Returns true if 'a' and 'b' represent the same wildcards, false if they are
{
int i;
- if (a->wildcards != b->wildcards) {
+ if (a->wildcards != b->wildcards
+ || a->tun_id_mask != b->tun_id_mask
+ || a->nw_src_mask != b->nw_src_mask
+ || a->nw_dst_mask != b->nw_dst_mask
+ || a->vlan_tci_mask != b->vlan_tci_mask) {
return false;
}
}
}
-#define OFPFW_NW_MASK (OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK)
- return ((a->wildcards & ~(b->wildcards | OFPFW_NW_MASK))
+ return (a->wildcards & ~b->wildcards
+ || (a->tun_id_mask & b->tun_id_mask) != b->tun_id_mask
|| (a->nw_src_mask & b->nw_src_mask) != b->nw_src_mask
- || (a->nw_dst_mask & b->nw_dst_mask) != b->nw_dst_mask);
+ || (a->nw_dst_mask & b->nw_dst_mask) != b->nw_dst_mask
+ || (a->vlan_tci_mask & b->vlan_tci_mask) != b->vlan_tci_mask);
}
static bool
-set_nw_mask(struct flow_wildcards *wc, ovs_be32 mask,
- ovs_be32 *maskp, int shift)
+set_nw_mask(ovs_be32 *maskp, ovs_be32 mask)
{
if (ip_is_cidr(mask)) {
- wc->wildcards &= ~(0x3f << shift);
- wc->wildcards |= ofputil_netmask_to_wcbits(mask) << shift;
*maskp = mask;
return true;
} else {
bool
flow_wildcards_set_nw_src_mask(struct flow_wildcards *wc, ovs_be32 mask)
{
- return set_nw_mask(wc, mask, &wc->nw_src_mask, OFPFW_NW_SRC_SHIFT);
+ return set_nw_mask(&wc->nw_src_mask, mask);
}
/* Sets the IP (or ARP) destination wildcard mask to CIDR 'mask' (consisting of
bool
flow_wildcards_set_nw_dst_mask(struct flow_wildcards *wc, ovs_be32 mask)
{
- return set_nw_mask(wc, mask, &wc->nw_dst_mask, OFPFW_NW_DST_SHIFT);
+ return set_nw_mask(&wc->nw_dst_mask, mask);
}
/* Sets the wildcard mask for register 'idx' in 'wc' to 'mask'.
void
flow_wildcards_set_reg_mask(struct flow_wildcards *wc, int idx, uint32_t mask)
{
- if (mask != wc->reg_masks[idx]) {
- wc->reg_masks[idx] = mask;
- if (mask != UINT32_MAX) {
- wc->wildcards |= FWW_REGS;
- } else {
- int i;
-
- for (i = 0; i < FLOW_N_REGS; i++) {
- if (wc->reg_masks[i] != UINT32_MAX) {
- wc->wildcards |= FWW_REGS;
- return;
- }
- }
- wc->wildcards &= ~FWW_REGS;
- }
- }
+ wc->reg_masks[idx] = mask;
}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff