Jed Daniels openvswitch@jeddaniels.com
Jeff Merrick jmerrick@vmware.com
Jeongkeun Lee jklee@hp.com
+Jian Qiu swordqiu@gmail.com
Joan Cirer joan@ev0.net
John Galgay john@galgay.net
Kevin Mancuso kevin.mancuso@rackspace.com
* OFPT_FLOW_MOD:
- * New flag OFPFF_RESET_COUNTS.
- [required for OF1.2+]
-
* Add ability to delete flow in all tables.
[required for OF1.2+]
size_t offset, size_t size, bool is_mask)
{
struct sw_flow_key_range *range = NULL;
- size_t start = offset;
- size_t end = offset + size;
+ size_t start = rounddown(offset, sizeof(long));
+ size_t end = roundup(offset + size, sizeof(long));
if (!is_mask)
range = &match->range;
} \
} while (0)
+static u16 range_n_bytes(const struct sw_flow_key_range *range)
+{
+ return range->end - range->start;
+}
+
void ovs_match_init(struct sw_flow_match *match,
struct sw_flow_key *key,
struct sw_flow_mask *mask)
void ovs_flow_key_mask(struct sw_flow_key *dst, const struct sw_flow_key *src,
const struct sw_flow_mask *mask)
{
- u8 *m = (u8 *)&mask->key + mask->range.start;
- u8 *s = (u8 *)src + mask->range.start;
- u8 *d = (u8 *)dst + mask->range.start;
+ const long *m = (long *)((u8 *)&mask->key + mask->range.start);
+ const long *s = (long *)((u8 *)src + mask->range.start);
+ long *d = (long *)((u8 *)dst + mask->range.start);
int i;
- memset(dst, 0, sizeof(*dst));
- for (i = 0; i < ovs_sw_flow_mask_size_roundup(mask); i++) {
- *d = *s & *m;
- d++, s++, m++;
- }
+ /* The memory outside of the 'mask->range' are not set since
+ * further operations on 'dst' only uses contents within
+ * 'mask->range'.
+ */
+ for (i = 0; i < range_n_bytes(&mask->range); i += sizeof(long))
+ *d++ = *s++ & *m++;
}
#define TCP_FLAGS_OFFSET 13
static u32 ovs_flow_hash(const struct sw_flow_key *key, int key_start,
int key_end)
{
- return jhash2((u32 *)((u8 *)key + key_start),
- DIV_ROUND_UP(key_end - key_start, sizeof(u32)), 0);
+ u32 *hash_key = (u32 *)((u8 *)key + key_start);
+ int hash_u32s = (key_end - key_start) >> 2;
+
+ /* Make sure number of hash bytes are multiple of u32. */
+ BUILD_BUG_ON(sizeof(long) % sizeof(u32));
+
+ return jhash2(hash_key, hash_u32s, 0);
}
static int flow_key_start(const struct sw_flow_key *key)
if (key->tun_key.ipv4_dst)
return 0;
else
- return offsetof(struct sw_flow_key, phy);
+ return rounddown(offsetof(struct sw_flow_key, phy),
+ sizeof(long));
}
static bool __cmp_key(const struct sw_flow_key *key1,
const struct sw_flow_key *key2, int key_start, int key_end)
{
- return !memcmp((u8 *)key1 + key_start,
- (u8 *)key2 + key_start, (key_end - key_start));
+ const long *cp1 = (long *)((u8 *)key1 + key_start);
+ const long *cp2 = (long *)((u8 *)key2 + key_start);
+ long diffs = 0;
+ int i;
+
+ for (i = key_start; i < key_end; i += sizeof(long))
+ diffs |= *cp1++ ^ *cp2++;
+
+ return diffs == 0;
}
-static bool __flow_cmp_key(const struct sw_flow *flow,
+static bool __flow_cmp_masked_key(const struct sw_flow *flow,
const struct sw_flow_key *key, int key_start, int key_end)
{
return __cmp_key(&flow->key, key, key_start, key_end);
}
static struct sw_flow *ovs_masked_flow_lookup(struct flow_table *table,
- const struct sw_flow_key *flow_key,
+ const struct sw_flow_key *unmasked,
struct sw_flow_mask *mask)
{
struct sw_flow *flow;
u32 hash;
struct sw_flow_key masked_key;
- ovs_flow_key_mask(&masked_key, flow_key, mask);
+ ovs_flow_key_mask(&masked_key, unmasked, mask);
hash = ovs_flow_hash(&masked_key, key_start, key_end);
head = find_bucket(table, hash);
hlist_for_each_entry_rcu(flow, head, hash_node[table->node_ver]) {
if (flow->mask == mask &&
- __flow_cmp_key(flow, &masked_key, key_start, key_end))
+ __flow_cmp_masked_key(flow, &masked_key,
+ key_start, key_end))
return flow;
}
return NULL;
* Returns zero if successful or a negative error code. */
int ovs_flow_init(void)
{
+ BUILD_BUG_ON(sizeof(struct sw_flow_key) % sizeof(long));
+
flow_cache = kmem_cache_create("sw_flow", sizeof(struct sw_flow), 0,
0, NULL);
if (flow_cache == NULL)
return (a->range.end == b->range.end)
&& (a->range.start == b->range.start)
- && (memcmp(a_, b_, ovs_sw_flow_mask_actual_size(a)) == 0);
+ && (memcmp(a_, b_, range_n_bytes(&a->range)) == 0);
}
struct sw_flow_mask *ovs_sw_flow_mask_find(const struct flow_table *tbl,
u8 *m = (u8 *)&mask->key + range->start;
mask->range = *range;
- memset(m, val, ovs_sw_flow_mask_size_roundup(mask));
+ memset(m, val, range_n_bytes(range));
}
} nd;
} ipv6;
};
-};
+} __aligned(__alignof__(long));
struct sw_flow {
struct rcu_head rcu;
size_t end;
};
-static inline u16 ovs_sw_flow_key_range_actual_size(const struct sw_flow_key_range *range)
-{
- return range->end - range->start;
-}
-
struct sw_flow_match {
struct sw_flow_key *key;
struct sw_flow_key_range range;
struct sw_flow_key key;
};
-static inline u16
-ovs_sw_flow_mask_actual_size(const struct sw_flow_mask *mask)
-{
- return ovs_sw_flow_key_range_actual_size(&mask->range);
-}
-
-static inline u16
-ovs_sw_flow_mask_size_roundup(const struct sw_flow_mask *mask)
-{
- return roundup(ovs_sw_flow_mask_actual_size(mask), sizeof(u32));
-}
-
struct sw_flow_mask *ovs_sw_flow_mask_alloc(void);
void ovs_sw_flow_mask_add_ref(struct sw_flow_mask *);
void ovs_sw_flow_mask_del_ref(struct sw_flow_mask *, bool deferred);
#define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
#endif
+#ifndef rounddown
+#define rounddown(x, y) ( \
+{ \
+ typeof(x) __x = (x); \
+ __x - (__x % (y)); \
+} \
+)
+#endif
+
#endif /* linux/kernel.h */
OFP_ASSERT(sizeof(struct ofp10_match) == 40);
enum ofp10_flow_mod_flags {
- OFPFF10_EMERG = 1 << 2 /* Ramark this is for emergency. */
+ OFPFF10_EMERG = 1 << 2 /* Part of "emergency flow cache". */
};
/* Flow setup and teardown (controller -> datapath). */
typedef __be32 ovs_be32;
typedef __be64 ovs_be64;
\f
-/* Netlink and OpenFlow both contain 64-bit values that are only guaranteed to
- * be aligned on 32-bit boundaries. These types help.
+/* These types help with a few funny situations:
+ *
+ * - The Ethernet header is 14 bytes long, which misaligns everything after
+ * that. One can put 2 "shim" bytes before the Ethernet header, but this
+ * helps only if there is exactly one Ethernet header. If there are two,
+ * as with GRE and VXLAN (and if the inner header doesn't use this
+ * trick--GRE and VXLAN don't) then you have the choice of aligning the
+ * inner data or the outer data. So it seems better to treat 32-bit fields
+ * in protocol headers as aligned only on 16-bit boundaries.
+ *
+ * - ARP headers contain misaligned 32-bit fields.
+ *
+ * - Netlink and OpenFlow contain 64-bit values that are only guaranteed to
+ * be aligned on 32-bit boundaries.
*
* lib/unaligned.h has helper functions for accessing these. */
+/* A 32-bit value, in host byte order, that is only aligned on a 16-bit
+ * boundary. */
+typedef struct {
+#ifdef WORDS_BIGENDIAN
+ uint16_t hi, lo;
+#else
+ uint16_t lo, hi;
+#endif
+} ovs_16aligned_u32;
+
+/* A 32-bit value, in network byte order, that is only aligned on a 16-bit
+ * boundary. */
+typedef struct {
+ ovs_be16 hi, lo;
+} ovs_16aligned_be32;
+
/* A 64-bit value, in host byte order, that is only aligned on a 32-bit
* boundary. */
typedef struct {
lib/ofpbuf.c \
lib/ofpbuf.h \
lib/ovs-atomic-c11.h \
+ lib/ovs-atomic-clang.h \
+ lib/ovs-atomic-flag-gcc4.7+.h \
lib/ovs-atomic-gcc4+.c \
lib/ovs-atomic-gcc4+.h \
lib/ovs-atomic-gcc4.7+.h \
#include "random.h"
#include "smap.h"
#include "timeval.h"
+#include "unaligned.h"
#include "unixctl.h"
#include "util.h"
#include "vlog.h"
ip->ip_ttl = MAXTTL;
ip->ip_tos = IPTOS_LOWDELAY | IPTOS_THROUGHPUT;
ip->ip_proto = IPPROTO_UDP;
- ip->ip_src = htonl(0xA9FE0100); /* 169.254.1.0 Link Local. */
- ip->ip_dst = htonl(0xA9FE0101); /* 169.254.1.1 Link Local. */
+ /* Use link local addresses: */
+ put_16aligned_be32(&ip->ip_src, htonl(0xA9FE0100)); /* 169.254.1.0. */
+ put_16aligned_be32(&ip->ip_dst, htonl(0xA9FE0101)); /* 169.254.1.1. */
ip->ip_csum = csum(ip, sizeof *ip);
udp = ofpbuf_put_zeros(p, sizeof *udp);
/* Initializes 'dst' as a copy of 'src'.
*
- * The caller must eventually destroy 'rule' with cls_rule_destroy(). */
+ * The caller must eventually destroy 'dst' with cls_rule_destroy(). */
void
cls_rule_clone(struct cls_rule *dst, const struct cls_rule *src)
{
dst->priority = src->priority;
}
+/* Initializes 'dst' with the data in 'src', destroying 'src'.
+ *
+ * The caller must eventually destroy 'dst' with cls_rule_destroy(). */
+void
+cls_rule_move(struct cls_rule *dst, struct cls_rule *src)
+{
+ minimatch_move(&dst->match, &src->match);
+ dst->priority = src->priority;
+}
+
/* Frees memory referenced by 'rule'. Doesn't free 'rule' itself (it's
* normally embedded into a larger structure).
*
/*
- * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
void cls_rule_init_from_minimatch(struct cls_rule *, const struct minimatch *,
unsigned int priority);
void cls_rule_clone(struct cls_rule *, const struct cls_rule *);
+void cls_rule_move(struct cls_rule *dst, struct cls_rule *src);
void cls_rule_destroy(struct cls_rule *);
bool cls_rule_equal(const struct cls_rule *, const struct cls_rule *);
#ifndef __has_feature
#define __has_feature(x) 0
#endif
+#ifndef __has_extension
+ #define __has_extension(x) 0
+#endif
#if __GNUC__ && !__CHECKER__
#define NO_RETURN __attribute__((__noreturn__))
/*
- * Copyright (c) 2008, 2009, 2010, 2011 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* contained 'old_csum' and in which a field that contained 'old_u32[4]' was
* changed to contain 'new_u32[4]'. */
ovs_be16
-recalc_csum128(ovs_be16 old_csum, ovs_be32 old_u32[4],
+recalc_csum128(ovs_be16 old_csum, ovs_16aligned_be32 old_u32[4],
const ovs_be32 new_u32[4])
{
ovs_be16 new_csum = old_csum;
int i;
for (i = 0; i < 4; ++i) {
- new_csum = recalc_csum32(new_csum, old_u32[i], new_u32[i]);
+ new_csum = recalc_csum32(new_csum,
+ get_16aligned_be32(&old_u32[i]), new_u32[i]);
}
return new_csum;
}
ovs_be16 csum_finish(uint32_t partial);
ovs_be16 recalc_csum16(ovs_be16 old_csum, ovs_be16 old_u16, ovs_be16 new_u16);
ovs_be16 recalc_csum32(ovs_be16 old_csum, ovs_be32 old_u32, ovs_be32 new_u32);
-ovs_be16 recalc_csum128(ovs_be16 old_csum, ovs_be32 old_u32[4],
+ovs_be16 recalc_csum128(ovs_be16 old_csum, ovs_16aligned_be32 old_u32[4],
const ovs_be32 new_u32[4]);
#endif /* csum.h */
static int
parse_ipv6(struct ofpbuf *packet, struct flow *flow)
{
- const struct ip6_hdr *nh;
+ const struct ovs_16aligned_ip6_hdr *nh;
ovs_be32 tc_flow;
int nexthdr;
nexthdr = nh->ip6_nxt;
- flow->ipv6_src = nh->ip6_src;
- flow->ipv6_dst = nh->ip6_dst;
+ memcpy(&flow->ipv6_src, &nh->ip6_src, sizeof flow->ipv6_src);
+ memcpy(&flow->ipv6_dst, &nh->ip6_dst, sizeof flow->ipv6_dst);
- tc_flow = get_unaligned_be32(&nh->ip6_flow);
+ tc_flow = get_16aligned_be32(&nh->ip6_flow);
flow->nw_tos = ntohl(tc_flow) >> 20;
flow->ipv6_label = tc_flow & htonl(IPV6_LABEL_MASK);
flow->nw_ttl = nh->ip6_hlim;
return EINVAL;
}
} else if (nexthdr == IPPROTO_FRAGMENT) {
- const struct ip6_frag *frag_hdr = packet->data;
+ const struct ovs_16aligned_ip6_frag *frag_hdr = packet->data;
nexthdr = frag_hdr->ip6f_nxt;
if (!ofpbuf_try_pull(packet, sizeof *frag_hdr)) {
if (nh) {
packet->l4 = b.data;
- flow->nw_src = get_unaligned_be32(&nh->ip_src);
- flow->nw_dst = get_unaligned_be32(&nh->ip_dst);
+ flow->nw_src = get_16aligned_be32(&nh->ip_src);
+ flow->nw_dst = get_16aligned_be32(&nh->ip_dst);
flow->nw_proto = nh->ip_proto;
flow->nw_tos = nh->ip_tos;
flow->nw_proto = ntohs(arp->ar_op);
}
- flow->nw_src = arp->ar_spa;
- flow->nw_dst = arp->ar_tpa;
+ flow->nw_src = get_16aligned_be32(&arp->ar_spa);
+ flow->nw_dst = get_16aligned_be32(&arp->ar_tpa);
memcpy(flow->arp_sha, arp->ar_sha, ETH_ADDR_LEN);
memcpy(flow->arp_tha, arp->ar_tha, ETH_ADDR_LEN);
}
ip->ip_tos = flow->nw_tos;
ip->ip_ttl = flow->nw_ttl;
ip->ip_proto = flow->nw_proto;
- ip->ip_src = flow->nw_src;
- ip->ip_dst = flow->nw_dst;
+ put_16aligned_be32(&ip->ip_src, flow->nw_src);
+ put_16aligned_be32(&ip->ip_dst, flow->nw_dst);
if (flow->nw_frag & FLOW_NW_FRAG_ANY) {
ip->ip_frag_off |= htons(IP_MORE_FRAGMENTS);
if (flow->nw_proto == ARP_OP_REQUEST ||
flow->nw_proto == ARP_OP_REPLY) {
- arp->ar_spa = flow->nw_src;
- arp->ar_tpa = flow->nw_dst;
+ put_16aligned_be32(&arp->ar_spa, flow->nw_src);
+ put_16aligned_be32(&arp->ar_tpa, flow->nw_dst);
memcpy(arp->ar_sha, flow->arp_sha, ETH_ADDR_LEN);
memcpy(arp->ar_tha, flow->arp_tha, ETH_ADDR_LEN);
}
memcpy(dst->values, src->values, n * sizeof *dst->values);
}
+/* Initializes 'dst' with the data in 'src', destroying 'src'.
+ * The caller must eventually free 'dst' with miniflow_destroy(). */
+void
+miniflow_move(struct miniflow *dst, struct miniflow *src)
+{
+ int n = miniflow_n_values(src);
+ if (n <= MINI_N_INLINE) {
+ dst->values = dst->inline_values;
+ memcpy(dst->values, src->values, n * sizeof *dst->values);
+ } else {
+ dst->values = src->values;
+ }
+ memcpy(dst->map, src->map, sizeof dst->map);
+}
+
/* Frees any memory owned by 'flow'. Does not free the storage in which 'flow'
* itself resides; the caller is responsible for that. */
void
miniflow_clone(&dst->masks, &src->masks);
}
+/* Initializes 'dst' with the data in 'src', destroying 'src'.
+ * The caller must eventually free 'dst' with minimask_destroy(). */
+void
+minimask_move(struct minimask *dst, struct minimask *src)
+{
+ miniflow_clone(&dst->masks, &src->masks);
+}
+
/* Initializes 'dst_' as the bit-wise "and" of 'a_' and 'b_'.
*
* The caller must provide room for FLOW_U32S "uint32_t"s in 'storage', for use
void miniflow_init(struct miniflow *, const struct flow *);
void miniflow_clone(struct miniflow *, const struct miniflow *);
+void miniflow_move(struct miniflow *dst, struct miniflow *);
void miniflow_destroy(struct miniflow *);
void miniflow_expand(const struct miniflow *, struct flow *);
void minimask_init(struct minimask *, const struct flow_wildcards *);
void minimask_clone(struct minimask *, const struct minimask *);
+void minimask_move(struct minimask *dst, struct minimask *src);
void minimask_combine(struct minimask *dst,
const struct minimask *a, const struct minimask *b,
uint32_t storage[FLOW_U32S]);
learn->hard_timeout = ntohs(nal->hard_timeout);
learn->priority = ntohs(nal->priority);
learn->cookie = ntohll(nal->cookie);
- learn->flags = ntohs(nal->flags);
learn->table_id = nal->table_id;
learn->fin_idle_timeout = ntohs(nal->fin_idle_timeout);
learn->fin_hard_timeout = ntohs(nal->fin_hard_timeout);
- if (learn->flags & ~OFPFF_SEND_FLOW_REM || learn->table_id == 0xff) {
+ /* We only support "send-flow-removed" for now. */
+ switch (ntohs(nal->flags)) {
+ case 0:
+ learn->flags = 0;
+ break;
+ case OFPFF_SEND_FLOW_REM:
+ learn->flags = OFPUTIL_FF_SEND_FLOW_REM;
+ break;
+ default:
+ return OFPERR_OFPBAC_BAD_ARGUMENT;
+ }
+
+ if (learn->table_id == 0xff) {
return OFPERR_OFPBAC_BAD_ARGUMENT;
}
* to set up the flow table. */
const struct ofputil_flow_mod *default_flows;
size_t n_default_flows;
+ enum ofputil_protocol usable_protocols;
};
/* The log messages here could actually be useful in debugging, so keep the
sw->default_flows = cfg->default_flows;
sw->n_default_flows = cfg->n_default_flows;
+ sw->usable_protocols = cfg->usable_protocols;
sw->queued = rconn_packet_counter_create();
protocol = ofputil_protocol_from_ofp_version(rconn_get_version(sw->rconn));
if (sw->default_flows) {
- enum ofputil_protocol usable_protocols;
struct ofpbuf *msg = NULL;
int error = 0;
size_t i;
* This could be improved by actually negotiating a mutually acceptable
* flow format with the switch, but that would require an asynchronous
* state machine. This version ought to work fine in practice. */
- usable_protocols = ofputil_flow_mod_usable_protocols(
- sw->default_flows, sw->n_default_flows);
- if (!(protocol & usable_protocols)) {
- enum ofputil_protocol want = rightmost_1bit(usable_protocols);
+ if (!(protocol & sw->usable_protocols)) {
+ enum ofputil_protocol want = rightmost_1bit(sw->usable_protocols);
while (!error) {
msg = ofputil_encode_set_protocol(protocol, want, &protocol);
if (!msg) {
error = rconn_send(sw->rconn, msg, NULL);
}
}
- if (protocol & usable_protocols) {
+ if (protocol & sw->usable_protocols) {
for (i = 0; !error && i < sw->n_default_flows; i++) {
msg = ofputil_encode_flow_mod(&sw->default_flows[i], protocol);
error = rconn_send(sw->rconn, msg, NULL);
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
+#include "ofp-util.h"
struct ofpbuf;
struct rconn;
* to set up the flow table. */
const struct ofputil_flow_mod *default_flows;
size_t n_default_flows;
+ enum ofputil_protocol usable_protocols;
/* The OpenFlow queue to use by default. Use UINT32_MAX to avoid
* specifying a particular queue. */
minimask_clone(&dst->mask, &src->mask);
}
+/* Initializes 'dst' with the data in 'src', destroying 'src'. The caller must
+ * eventually free 'dst' with minimatch_destroy(). */
+void
+minimatch_move(struct minimatch *dst, struct minimatch *src)
+{
+ miniflow_move(&dst->flow, &src->flow);
+ minimask_move(&dst->mask, &src->mask);
+}
+
/* Frees any memory owned by 'match'. Does not free the storage in which
* 'match' itself resides; the caller is responsible for that. */
void
/*
- * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
void minimatch_init(struct minimatch *, const struct match *);
void minimatch_clone(struct minimatch *, const struct minimatch *);
+void minimatch_move(struct minimatch *dst, struct minimatch *src);
void minimatch_destroy(struct minimatch *);
void minimatch_expand(const struct minimatch *, struct match *);
true,
NXM_NX_TUN_ID, "NXM_NX_TUN_ID",
OXM_OF_TUNNEL_ID, "OXM_OF_TUNNEL_ID",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TUN_SRC, "tun_src", NULL,
MF_FIELD_SIZES(be32),
true,
NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
NXM_NX_TUN_IPV4_SRC, "NXM_NX_TUN_IPV4_SRC",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TUN_DST, "tun_dst", NULL,
MF_FIELD_SIZES(be32),
true,
NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
NXM_NX_TUN_IPV4_DST, "NXM_NX_TUN_IPV4_DST",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TUN_FLAGS, "tun_flags", NULL,
MF_FIELD_SIZES(be16),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
MFF_TUN_TOS, "tun_tos", NULL,
MF_FIELD_SIZES(u8),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
MFF_TUN_TTL, "tun_ttl", NULL,
MF_FIELD_SIZES(u8),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
MFF_METADATA, "metadata", NULL,
MF_FIELD_SIZES(be64),
true,
OXM_OF_METADATA, "OXM_OF_METADATA",
OXM_OF_METADATA, "OXM_OF_METADATA",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_IN_PORT, "in_port", NULL,
MF_FIELD_SIZES(be16),
true,
NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
NXM_OF_IN_PORT, "NXM_OF_IN_PORT",
+ OFPUTIL_P_ANY, /* OF11+ via mapping to 32 bits. */
+ OFPUTIL_P_NONE,
}, {
MFF_IN_PORT_OXM, "in_port_oxm", NULL,
MF_FIELD_SIZES(be32),
true,
OXM_OF_IN_PORT, "OXM_OF_IN_PORT",
OXM_OF_IN_PORT, "OXM_OF_IN_PORT",
+ OFPUTIL_P_OF11_UP,
+ OFPUTIL_P_NONE,
}, {
MFF_SKB_PRIORITY, "skb_priority", NULL,
MF_FIELD_SIZES(be32),
false,
0, NULL,
0, NULL,
+ OFPUTIL_P_NONE,
+ OFPUTIL_P_NONE,
}, {
MFF_PKT_MARK, "pkt_mark", NULL,
MF_FIELD_SIZES(be32),
true,
NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
NXM_NX_PKT_MARK, "NXM_NX_PKT_MARK",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
#define REGISTER(IDX) \
true, \
NXM_NX_REG(IDX), "NXM_NX_REG" #IDX, \
NXM_NX_REG(IDX), "NXM_NX_REG" #IDX, \
+ OFPUTIL_P_NXM_OXM_ANY, \
+ OFPUTIL_P_NXM_OXM_ANY, \
}
#if FLOW_N_REGS > 0
REGISTER(0),
true,
NXM_OF_ETH_SRC, "NXM_OF_ETH_SRC",
OXM_OF_ETH_SRC, "OXM_OF_ETH_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP, /* Bitwise masking only with NXM and OF11+! */
}, {
MFF_ETH_DST, "eth_dst", "dl_dst",
MF_FIELD_SIZES(mac),
true,
NXM_OF_ETH_DST, "NXM_OF_ETH_DST",
OXM_OF_ETH_DST, "OXM_OF_ETH_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP, /* Bitwise masking only with NXM and OF11+! */
}, {
MFF_ETH_TYPE, "eth_type", "dl_type",
MF_FIELD_SIZES(be16),
false,
NXM_OF_ETH_TYPE, "NXM_OF_ETH_TYPE",
OXM_OF_ETH_TYPE, "OXM_OF_ETH_TYPE",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
},
{
true,
NXM_OF_VLAN_TCI, "NXM_OF_VLAN_TCI",
NXM_OF_VLAN_TCI, "NXM_OF_VLAN_TCI",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_DL_VLAN, "dl_vlan", NULL,
sizeof(ovs_be16), 12,
true,
0, NULL,
0, NULL,
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_VLAN_VID, "vlan_vid", NULL,
sizeof(ovs_be16), 12,
true,
OXM_OF_VLAN_VID, "OXM_OF_VLAN_VID",
OXM_OF_VLAN_VID, "OXM_OF_VLAN_VID",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_DL_VLAN_PCP, "dl_vlan_pcp", NULL,
1, 3,
true,
0, NULL,
0, NULL,
+ OFPUTIL_P_ANY, /* Will be mapped to NXM and OXM. */
+ OFPUTIL_P_NONE,
}, {
MFF_VLAN_PCP, "vlan_pcp", NULL,
1, 3,
true,
OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
+ OFPUTIL_P_ANY, /* Will be mapped to OF10 and NXM. */
+ OFPUTIL_P_NONE,
},
/* ## ---- ## */
true,
OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NONE,
}, {
MFF_MPLS_TC, "mpls_tc", NULL,
1, 3,
true,
OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NONE,
}, {
MFF_MPLS_BOS, "mpls_bos", NULL,
1, 1,
false,
OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
},
/* ## -- ## */
true,
NXM_OF_IP_SRC, "NXM_OF_IP_SRC",
OXM_OF_IPV4_SRC, "OXM_OF_IPV4_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_IPV4_DST, "ip_dst", "nw_dst",
MF_FIELD_SIZES(be32),
true,
NXM_OF_IP_DST, "NXM_OF_IP_DST",
OXM_OF_IPV4_DST, "OXM_OF_IPV4_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
},
{
true,
NXM_NX_IPV6_SRC, "NXM_NX_IPV6_SRC",
OXM_OF_IPV6_SRC, "OXM_OF_IPV6_SRC",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_IPV6_DST, "ipv6_dst", NULL,
MF_FIELD_SIZES(ipv6),
true,
NXM_NX_IPV6_DST, "NXM_NX_IPV6_DST",
OXM_OF_IPV6_DST, "OXM_OF_IPV6_DST",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
MFF_IPV6_LABEL, "ipv6_label", NULL,
false,
NXM_NX_IPV6_LABEL, "NXM_NX_IPV6_LABEL",
OXM_OF_IPV6_FLABEL, "OXM_OF_IPV6_FLABEL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
false,
NXM_OF_IP_PROTO, "NXM_OF_IP_PROTO",
OXM_OF_IP_PROTO, "OXM_OF_IP_PROTO",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_IP_DSCP, "nw_tos", NULL,
MF_FIELD_SIZES(u8),
true,
NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
NXM_OF_IP_TOS, "NXM_OF_IP_TOS",
+ OFPUTIL_P_ANY, /* Will be shifted for OXM. */
+ OFPUTIL_P_NONE,
}, {
MFF_IP_DSCP_SHIFTED, "nw_tos_shifted", NULL,
MF_FIELD_SIZES(u8),
true,
OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
OXM_OF_IP_DSCP, "OXM_OF_IP_DSCP",
+ OFPUTIL_P_ANY, /* Will be shifted for non-OXM. */
+ OFPUTIL_P_NONE,
}, {
MFF_IP_ECN, "nw_ecn", NULL,
1, 2,
true,
NXM_NX_IP_ECN, "NXM_NX_IP_ECN",
OXM_OF_IP_ECN, "OXM_OF_IP_ECN",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_IP_TTL, "nw_ttl", NULL,
MF_FIELD_SIZES(u8),
true,
NXM_NX_IP_TTL, "NXM_NX_IP_TTL",
NXM_NX_IP_TTL, "NXM_NX_IP_TTL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_IP_FRAG, "ip_frag", NULL,
1, 2,
false,
NXM_NX_IP_FRAG, "NXM_NX_IP_FRAG",
NXM_NX_IP_FRAG, "NXM_NX_IP_FRAG",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
false,
NXM_OF_ARP_OP, "NXM_OF_ARP_OP",
OXM_OF_ARP_OP, "OXM_OF_ARP_OP",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_ARP_SPA, "arp_spa", NULL,
MF_FIELD_SIZES(be32),
false,
NXM_OF_ARP_SPA, "NXM_OF_ARP_SPA",
OXM_OF_ARP_SPA, "OXM_OF_ARP_SPA",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_ARP_TPA, "arp_tpa", NULL,
MF_FIELD_SIZES(be32),
false,
NXM_OF_ARP_TPA, "NXM_OF_ARP_TPA",
OXM_OF_ARP_TPA, "OXM_OF_ARP_TPA",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OF11_UP,
}, {
MFF_ARP_SHA, "arp_sha", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ARP_SHA, "NXM_NX_ARP_SHA",
OXM_OF_ARP_SHA, "OXM_OF_ARP_SHA",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_ARP_THA, "arp_tha", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ARP_THA, "NXM_NX_ARP_THA",
OXM_OF_ARP_THA, "OXM_OF_ARP_THA",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
/* ## -- ## */
true,
NXM_OF_TCP_SRC, "NXM_OF_TCP_SRC",
OXM_OF_TCP_SRC, "OXM_OF_TCP_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_TCP_DST, "tcp_dst", "tp_dst",
MF_FIELD_SIZES(be16),
true,
NXM_OF_TCP_DST, "NXM_OF_TCP_DST",
OXM_OF_TCP_DST, "OXM_OF_TCP_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
true,
NXM_OF_UDP_SRC, "NXM_OF_UDP_SRC",
OXM_OF_UDP_SRC, "OXM_OF_UDP_SRC",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_UDP_DST, "udp_dst", NULL,
MF_FIELD_SIZES(be16),
true,
NXM_OF_UDP_DST, "NXM_OF_UDP_DST",
OXM_OF_UDP_DST, "OXM_OF_UDP_DST",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
true,
OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
OXM_OF_SCTP_SRC, "OXM_OF_SCTP_SRC",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_SCTP_DST, "sctp_dst", NULL,
MF_FIELD_SIZES(be16),
true,
OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
OXM_OF_SCTP_DST, "OXM_OF_SCTP_DST",
+ OFPUTIL_P_NXM_OF11_UP,
+ OFPUTIL_P_NXM_OXM_ANY,
},
{
false,
NXM_OF_ICMP_TYPE, "NXM_OF_ICMP_TYPE",
OXM_OF_ICMPV4_TYPE, "OXM_OF_ICMPV4_TYPE",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_ICMPV4_CODE, "icmp_code", NULL,
MF_FIELD_SIZES(u8),
false,
NXM_OF_ICMP_CODE, "NXM_OF_ICMP_CODE",
OXM_OF_ICMPV4_CODE, "OXM_OF_ICMPV4_CODE",
+ OFPUTIL_P_ANY,
+ OFPUTIL_P_NONE,
},
{
false,
NXM_NX_ICMPV6_TYPE, "NXM_NX_ICMPV6_TYPE",
OXM_OF_ICMPV6_TYPE, "OXM_OF_ICMPV6_TYPE",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
}, {
MFF_ICMPV6_CODE, "icmpv6_code", NULL,
MF_FIELD_SIZES(u8),
false,
NXM_NX_ICMPV6_CODE, "NXM_NX_ICMPV6_CODE",
OXM_OF_ICMPV6_CODE, "OXM_OF_ICMPV6_CODE",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NONE,
},
/* ## ---- ## */
false,
NXM_NX_ND_TARGET, "NXM_NX_ND_TARGET",
OXM_OF_IPV6_ND_TARGET, "OXM_OF_IPV6_ND_TARGET",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_ND_SLL, "nd_sll", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ND_SLL, "NXM_NX_ND_SLL",
OXM_OF_IPV6_ND_SLL, "OXM_OF_IPV6_ND_SLL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}, {
MFF_ND_TLL, "nd_tll", NULL,
MF_FIELD_SIZES(mac),
false,
NXM_NX_ND_TLL, "NXM_NX_ND_TLL",
OXM_OF_IPV6_ND_TLL, "OXM_OF_IPV6_ND_TLL",
+ OFPUTIL_P_NXM_OXM_ANY,
+ OFPUTIL_P_NXM_OXM_ANY,
}
};
*
* 'mask' must be a valid mask for 'mf' (see mf_is_mask_valid()). The caller
* is responsible for ensuring that 'match' meets 'mf''s prerequisites. */
-void
+enum ofputil_protocol
mf_set(const struct mf_field *mf,
const union mf_value *value, const union mf_value *mask,
struct match *match)
{
if (!mask || is_all_ones((const uint8_t *) mask, mf->n_bytes)) {
mf_set_value(mf, value, match);
- return;
+ return mf->usable_protocols;
} else if (is_all_zeros((const uint8_t *) mask, mf->n_bytes)) {
mf_set_wild(mf, match);
- return;
+ return OFPUTIL_P_ANY;
}
switch (mf->id) {
case MFF_IPV4_SRC:
match_set_nw_src_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_IPV4_DST:
match_set_nw_dst_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_IPV6_SRC:
match_set_ipv6_src_masked(match, &value->ipv6, &mask->ipv6);
case MFF_ARP_SPA:
match_set_nw_src_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_ARP_TPA:
match_set_nw_dst_masked(match, value->be32, mask->be32);
- break;
+ goto cidr_check;
case MFF_TCP_SRC:
case MFF_UDP_SRC:
default:
NOT_REACHED();
}
+
+ return mf->usable_protocols_bitwise;
+
+cidr_check:
+ return ip_is_cidr(mask->be32) ? mf->usable_protocols :
+ mf->usable_protocols_bitwise;
}
static enum ofperr
#include <netinet/ip6.h>
#include "flow.h"
#include "ofp-errors.h"
+#include "ofp-util.h"
#include "packets.h"
struct ds;
uint32_t nxm_header; /* An NXM_* (or OXM_*) constant. */
const char *nxm_name; /* The nxm_header constant's name. */
uint32_t oxm_header; /* An OXM_* (or NXM_*) constant. */
- const char *oxm_name; /* The oxm_header constant's name */
+ const char *oxm_name; /* The oxm_header constant's name */
+
+ /* Usable protocols.
+ * NXM and OXM are extensible, allowing later extensions to be sent in
+ * earlier protocol versions, so this does not necessarily correspond to
+ * the OpenFlow protocol version the field was introduced in.
+ * Also, some field types are tranparently mapped to each other via the
+ * struct flow (like vlan and dscp/tos fields), so each variant supports
+ * all protocols. */
+ enum ofputil_protocol usable_protocols; /* If fully/cidr masked. */
+ /* If partially/non-cidr masked. */
+ enum ofputil_protocol usable_protocols_bitwise;
};
/* The representation of a field's value. */
void mf_get(const struct mf_field *, const struct match *,
union mf_value *value, union mf_value *mask);
-void mf_set(const struct mf_field *,
- const union mf_value *value, const union mf_value *mask,
- struct match *);
+
+/* Returns the set of usable protocols. */
+enum ofputil_protocol mf_set(const struct mf_field *,
+ const union mf_value *value,
+ const union mf_value *mask,
+ struct match *);
void mf_set_wild(const struct mf_field *, struct match *);
NULL, /* set_queue */
NULL, /* delete_queue */
NULL, /* get_queue_stats */
- NULL, /* dump_queue */
+ NULL, /* queue_dump_start */
+ NULL, /* queue_dump_next */
+ NULL, /* queue_dump_done */
NULL, /* dump_queue_stats */
netdev_bsd_get_in4,
NULL, /* set_queue */
NULL, /* delete_queue */
NULL, /* get_queue_stats */
- NULL, /* dump_queue */
+ NULL, /* queue_dump_start */
+ NULL, /* queue_dump_next */
+ NULL, /* queue_dump_done */
NULL, /* dump_queue_stats */
netdev_bsd_get_in4,
NULL, /* set_queue */
NULL, /* delete_queue */
NULL, /* get_queue_stats */
- NULL, /* dump_queues */
+ NULL, /* queue_dump_start */
+ NULL, /* queue_dump_next */
+ NULL, /* queue_dump_done */
NULL, /* dump_queue_stats */
NULL, /* get_in4 */
return true;
}
+struct netdev_linux_queue_state {
+ unsigned int *queues;
+ size_t cur_queue;
+ size_t n_queues;
+};
+
static int
-netdev_linux_dump_queues(const struct netdev *netdev_,
- netdev_dump_queues_cb *cb, void *aux)
+netdev_linux_queue_dump_start(const struct netdev *netdev_, void **statep)
{
- struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ const struct netdev_linux *netdev = netdev_linux_cast(netdev_);
int error;
ovs_mutex_lock(&netdev->mutex);
error = tc_query_qdisc(netdev_);
if (!error) {
if (netdev->tc->ops->class_get) {
- struct tc_queue *queue, *next_queue;
- struct smap details;
-
- smap_init(&details);
- HMAP_FOR_EACH_SAFE (queue, next_queue, hmap_node,
- &netdev->tc->queues) {
- int retval;
-
- smap_clear(&details);
-
- retval = netdev->tc->ops->class_get(netdev_, queue, &details);
- if (!retval) {
- (*cb)(queue->queue_id, &details, aux);
- } else {
- error = retval;
- }
+ struct netdev_linux_queue_state *state;
+ struct tc_queue *queue;
+ size_t i;
+
+ *statep = state = xmalloc(sizeof *state);
+ state->n_queues = hmap_count(&netdev->tc->queues);
+ state->cur_queue = 0;
+ state->queues = xmalloc(state->n_queues * sizeof *state->queues);
+
+ i = 0;
+ HMAP_FOR_EACH (queue, hmap_node, &netdev->tc->queues) {
+ state->queues[i++] = queue->queue_id;
}
- smap_destroy(&details);
} else {
error = EOPNOTSUPP;
}
return error;
}
+static int
+netdev_linux_queue_dump_next(const struct netdev *netdev_, void *state_,
+ unsigned int *queue_idp, struct smap *details)
+{
+ const struct netdev_linux *netdev = netdev_linux_cast(netdev_);
+ struct netdev_linux_queue_state *state = state_;
+ int error = EOF;
+
+ ovs_mutex_lock(&netdev->mutex);
+ while (state->cur_queue < state->n_queues) {
+ unsigned int queue_id = state->queues[state->cur_queue++];
+ struct tc_queue *queue = tc_find_queue(netdev_, queue_id);
+
+ if (queue) {
+ *queue_idp = queue_id;
+ error = netdev->tc->ops->class_get(netdev_, queue, details);
+ break;
+ }
+ }
+ ovs_mutex_unlock(&netdev->mutex);
+
+ return error;
+}
+
+static int
+netdev_linux_queue_dump_done(const struct netdev *netdev OVS_UNUSED,
+ void *state_)
+{
+ struct netdev_linux_queue_state *state = state_;
+
+ free(state->queues);
+ free(state);
+ return 0;
+}
+
static int
netdev_linux_dump_queue_stats(const struct netdev *netdev_,
netdev_dump_queue_stats_cb *cb, void *aux)
netdev_linux_set_queue, \
netdev_linux_delete_queue, \
netdev_linux_get_queue_stats, \
- netdev_linux_dump_queues, \
+ netdev_linux_queue_dump_start, \
+ netdev_linux_queue_dump_next, \
+ netdev_linux_queue_dump_done, \
netdev_linux_dump_queue_stats, \
\
netdev_linux_get_in4, \
int (*get_queue_stats)(const struct netdev *netdev, unsigned int queue_id,
struct netdev_queue_stats *stats);
- /* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's
- * ID, its configuration, and the 'aux' specified by the caller. The order
- * of iteration is unspecified, but (when successful) each queue is visited
- * exactly once.
- *
- * 'cb' will not modify or free the 'details' argument passed in. It may
- * delete or modify the queue passed in as its 'queue_id' argument. It may
- * modify but will not delete any other queue within 'netdev'. If 'cb'
- * adds new queues, then ->dump_queues is allowed to visit some queues
- * twice or not at all.
- */
- int (*dump_queues)(const struct netdev *netdev,
- void (*cb)(unsigned int queue_id,
- const struct smap *details,
- void *aux),
- void *aux);
+ /* Attempts to begin dumping the queues in 'netdev'. On success, returns 0
+ * and initializes '*statep' with any data needed for iteration. On
+ * failure, returns a positive errno value.
+ *
+ * May be NULL if 'netdev' does not support QoS at all. */
+ int (*queue_dump_start)(const struct netdev *netdev, void **statep);
+
+ /* Attempts to retrieve another queue from 'netdev' for 'state', which was
+ * initialized by a successful call to the 'queue_dump_start' function for
+ * 'netdev'. On success, stores a queue ID into '*queue_id' and fills
+ * 'details' with the configuration of the queue with that ID. Returns EOF
+ * if the last queue has been dumped, or a positive errno value on error.
+ * This function will not be called again once it returns nonzero once for
+ * a given iteration (but the 'queue_dump_done' function will be called
+ * afterward).
+ *
+ * The caller initializes and clears 'details' before calling this
+ * function. The caller takes ownership of the string key-values pairs
+ * added to 'details'.
+ *
+ * The returned contents of 'details' should be documented as valid for the
+ * given 'type' in the "other_config" column in the "Queue" table in
+ * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
+ *
+ * May be NULL if 'netdev' does not support QoS at all. */
+ int (*queue_dump_next)(const struct netdev *netdev, void *state,
+ unsigned int *queue_id, struct smap *details);
+
+ /* Releases resources from 'netdev' for 'state', which was initialized by a
+ * successful call to the 'queue_dump_start' function for 'netdev'.
+ *
+ * May be NULL if 'netdev' does not support QoS at all. */
+ int (*queue_dump_done)(const struct netdev *netdev, void *state);
/* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's
* ID, its statistics, and the 'aux' specified by the caller. The order of
NULL, /* set_queue */ \
NULL, /* delete_queue */ \
NULL, /* get_queue_stats */ \
- NULL, /* dump_queues */ \
+ NULL, /* queue_dump_start */ \
+ NULL, /* queue_dump_next */ \
+ NULL, /* queue_dump_done */ \
NULL, /* dump_queue_stats */ \
\
NULL, /* get_in4 */ \
return retval;
}
-/* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's ID,
- * its configuration, and the 'aux' specified by the caller. The order of
- * iteration is unspecified, but (when successful) each queue is visited
- * exactly once.
+/* Initializes 'dump' to begin dumping the queues in a netdev.
+ *
+ * This function provides no status indication. An error status for the entire
+ * dump operation is provided when it is completed by calling
+ * netdev_queue_dump_done().
+ */
+void
+netdev_queue_dump_start(struct netdev_queue_dump *dump,
+ const struct netdev *netdev)
+{
+ dump->netdev = netdev_ref(netdev);
+ if (netdev->netdev_class->queue_dump_start) {
+ dump->error = netdev->netdev_class->queue_dump_start(netdev,
+ &dump->state);
+ } else {
+ dump->error = EOPNOTSUPP;
+ }
+}
+
+/* Attempts to retrieve another queue from 'dump', which must have been
+ * initialized with netdev_queue_dump_start(). On success, stores a new queue
+ * ID into '*queue_id', fills 'details' with configuration details for the
+ * queue, and returns true. On failure, returns false.
*
- * Calling this function may be more efficient than calling netdev_get_queue()
- * for every queue.
+ * Queues are not necessarily dumped in increasing order of queue ID (or any
+ * other predictable order).
*
- * 'cb' must not modify or free the 'details' argument passed in. It may
- * delete or modify the queue passed in as its 'queue_id' argument. It may
- * modify but must not delete any other queue within 'netdev'. 'cb' should not
- * add new queues because this may cause some queues to be visited twice or not
- * at all.
+ * Failure might indicate an actual error or merely that the last queue has
+ * been dumped. An error status for the entire dump operation is provided when
+ * it is completed by calling netdev_queue_dump_done().
*
- * Returns 0 if successful, otherwise a positive errno value. On error, some
- * configured queues may not have been included in the iteration. */
+ * The returned contents of 'details' should be documented as valid for the
+ * given 'type' in the "other_config" column in the "Queue" table in
+ * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
+ *
+ * The caller must initialize 'details' (e.g. with smap_init()) before calling
+ * this function. This function will clear and replace its contents. The
+ * caller must free 'details' when it is no longer needed (e.g. with
+ * smap_destroy()). */
+bool
+netdev_queue_dump_next(struct netdev_queue_dump *dump,
+ unsigned int *queue_id, struct smap *details)
+{
+ const struct netdev *netdev = dump->netdev;
+
+ if (dump->error) {
+ return false;
+ }
+
+ dump->error = netdev->netdev_class->queue_dump_next(netdev, dump->state,
+ queue_id, details);
+
+ if (dump->error) {
+ netdev->netdev_class->queue_dump_done(netdev, dump->state);
+ return false;
+ }
+ return true;
+}
+
+/* Completes queue table dump operation 'dump', which must have been
+ * initialized with netdev_queue_dump_start(). Returns 0 if the dump operation
+ * was error-free, otherwise a positive errno value describing the problem. */
int
-netdev_dump_queues(const struct netdev *netdev,
- netdev_dump_queues_cb *cb, void *aux)
+netdev_queue_dump_done(struct netdev_queue_dump *dump)
{
- const struct netdev_class *class = netdev->netdev_class;
- return (class->dump_queues
- ? class->dump_queues(netdev, cb, aux)
- : EOPNOTSUPP);
+ const struct netdev *netdev = dump->netdev;
+ if (!dump->error && netdev->netdev_class->queue_dump_done) {
+ dump->error = netdev->netdev_class->queue_dump_done(netdev,
+ dump->state);
+ }
+ netdev_close(dump->netdev);
+ return dump->error == EOF ? 0 : dump->error;
}
/* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's ID,
* These functions are conditionally thread-safe: they may be called from
* different threads only on different netdev_rx objects. (The client may
* create multiple netdev_rx objects for a single netdev and access each
- * of those from a different thread.) */
+ * of those from a different thread.)
+ *
+ * NETDEV_FOR_EACH_QUEUE
+ * netdev_queue_dump_next()
+ * netdev_queue_dump_done()
+ *
+ * These functions are conditionally thread-safe: they may be called from
+ * different threads only on different netdev_queue_dump objects. (The
+ * client may create multiple netdev_queue_dump objects for a single
+ * netdev and access each of those from a different thread.)
+ */
struct netdev;
struct netdev_class;
int netdev_get_queue_stats(const struct netdev *, unsigned int queue_id,
struct netdev_queue_stats *);
-typedef void netdev_dump_queues_cb(unsigned int queue_id,
- const struct smap *details, void *aux);
-int netdev_dump_queues(const struct netdev *,
- netdev_dump_queues_cb *, void *aux);
+struct netdev_queue_dump {
+ struct netdev *netdev;
+ int error;
+ void *state;
+};
+void netdev_queue_dump_start(struct netdev_queue_dump *,
+ const struct netdev *);
+bool netdev_queue_dump_next(struct netdev_queue_dump *,
+ unsigned int *queue_id, struct smap *details);
+int netdev_queue_dump_done(struct netdev_queue_dump *);
+
+/* Iterates through each queue in NETDEV, using DUMP as state. Fills QUEUE_ID
+ * and DETAILS with information about queues. The client must initialize and
+ * destroy DETAILS.
+ *
+ * Arguments all have pointer type.
+ *
+ * If you break out of the loop, then you need to free the dump structure by
+ * hand using netdev_queue_dump_done(). */
+#define NETDEV_QUEUE_FOR_EACH(QUEUE_ID, DETAILS, DUMP, NETDEV) \
+ for (netdev_queue_dump_start(DUMP, NETDEV); \
+ (netdev_queue_dump_next(DUMP, QUEUE_ID, DETAILS) \
+ ? true \
+ : (netdev_queue_dump_done(DUMP), false)); \
+ )
typedef void netdev_dump_queue_stats_cb(unsigned int queue_id,
struct netdev_queue_stats *,
uint16_t hard_timeout; /* Max time before discarding (seconds). */
uint16_t priority; /* Priority level of flow entry. */
uint64_t cookie; /* Cookie for new flow. */
- uint16_t flags; /* Either 0 or OFPFF_SEND_FLOW_REM. */
+ enum ofputil_flow_mod_flags flags;
uint8_t table_id; /* Table to insert flow entry. */
uint16_t fin_idle_timeout; /* Idle timeout after FIN, if nonzero. */
uint16_t fin_hard_timeout; /* Hard timeout after FIN, if nonzero. */
/* OF1.0(3,4), OF1.1+(5,6). Unsupported or unknown command. */
OFPERR_OFPFMFC_BAD_COMMAND,
- /* OF1.2+(5,7). Unsupported or unknown flags. */
+ /* NX1.0(3,258), NX1.1(5,258), OF1.2+(5,7). Unsupported or unknown
+ * flags. */
OFPERR_OFPFMFC_BAD_FLAGS,
/* OF1.0(3,5). Unsupported action list - cannot process in the order
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
-set_field_parse__(char *arg, struct ofpbuf *ofpacts)
+set_field_parse__(char *arg, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
{
struct ofpact_reg_load *load = ofpact_put_REG_LOAD(ofpacts);
char *value;
}
ofpact_set_field_init(load, mf, &mf_value);
+ *usable_protocols &= mf->usable_protocols;
return NULL;
}
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
-set_field_parse(const char *arg, struct ofpbuf *ofpacts)
+set_field_parse(const char *arg, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
{
char *copy = xstrdup(arg);
- char *error = set_field_parse__(copy, ofpacts);
+ char *error = set_field_parse__(copy, ofpacts, usable_protocols);
free(copy);
return error;
}
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
parse_named_action(enum ofputil_action_code code,
- char *arg, struct ofpbuf *ofpacts)
+ char *arg, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
{
size_t orig_size = ofpacts->size;
struct ofpact_tunnel *tunnel;
break;
case OFPUTIL_OFPAT12_SET_FIELD:
- return set_field_parse(arg, ofpacts);
+ return set_field_parse(arg, ofpacts, usable_protocols);
case OFPUTIL_OFPAT10_STRIP_VLAN:
case OFPUTIL_OFPAT11_POP_VLAN:
break;
case OFPUTIL_OFPAT11_PUSH_VLAN:
+ *usable_protocols &= OFPUTIL_P_OF11_UP;
error = str_to_u16(arg, "ethertype", ðertype);
if (error) {
return error;
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
str_to_ofpact__(char *pos, char *act, char *arg,
- struct ofpbuf *ofpacts, int n_actions)
+ struct ofpbuf *ofpacts, int n_actions,
+ enum ofputil_protocol *usable_protocols)
{
int code = ofputil_action_code_from_name(act);
if (code >= 0) {
- return parse_named_action(code, arg, ofpacts);
+ return parse_named_action(code, arg, ofpacts, usable_protocols);
} else if (!strcasecmp(act, "drop")) {
if (n_actions) {
return xstrdup("Drop actions must not be preceded by other "
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
-str_to_ofpacts(char *str, struct ofpbuf *ofpacts)
+str_to_ofpacts(char *str, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
{
size_t orig_size = ofpacts->size;
char *pos, *act, *arg;
pos = str;
n_actions = 0;
while (ofputil_parse_key_value(&pos, &act, &arg)) {
- char *error = str_to_ofpact__(pos, act, arg, ofpacts, n_actions);
+ char *error = str_to_ofpact__(pos, act, arg, ofpacts, n_actions,
+ usable_protocols);
if (error) {
ofpacts->size = orig_size;
return error;
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
parse_named_instruction(enum ovs_instruction_type type,
- char *arg, struct ofpbuf *ofpacts)
+ char *arg, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
{
char *error_s = NULL;
enum ofperr error;
+ *usable_protocols &= OFPUTIL_P_OF11_UP;
+
switch (type) {
case OVSINST_OFPIT11_APPLY_ACTIONS:
NOT_REACHED(); /* This case is handled by str_to_inst_ofpacts() */
break;
case OVSINST_OFPIT13_METER:
+ *usable_protocols &= OFPUTIL_P_OF13_UP;
error_s = str_to_u32(arg, &ofpact_put_METER(ofpacts)->meter_id);
break;
case OVSINST_OFPIT11_WRITE_METADATA:
+ *usable_protocols &= OFPUTIL_P_NXM_OF11_UP;
error_s = parse_metadata(ofpacts, arg);
break;
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
-str_to_inst_ofpacts(char *str, struct ofpbuf *ofpacts)
+str_to_inst_ofpacts(char *str, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
{
size_t orig_size = ofpacts->size;
char *pos, *inst, *arg;
while (ofputil_parse_key_value(&pos, &inst, &arg)) {
type = ovs_instruction_type_from_name(inst);
if (type < 0) {
- char *error = str_to_ofpact__(pos, inst, arg, ofpacts, n_actions);
+ char *error = str_to_ofpact__(pos, inst, arg, ofpacts, n_actions,
+ usable_protocols);
if (error) {
ofpacts->size = orig_size;
return error;
return xasprintf("%s isn't supported. Just write actions then "
"it is interpreted as apply_actions", inst);
} else {
- char *error = parse_named_instruction(type, arg, ofpacts);
+ char *error = parse_named_instruction(type, arg, ofpacts,
+ usable_protocols);
if (error) {
ofpacts->size = orig_size;
return error;
}
/* Parses 's' as the (possibly masked) value of field 'mf', and updates
- * 'match' appropriately.
+ * 'match' appropriately. Restricts the set of usable protocols to ones
+ * supporting the parsed field.
*
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
-parse_field(const struct mf_field *mf, const char *s, struct match *match)
+parse_field(const struct mf_field *mf, const char *s, struct match *match,
+ enum ofputil_protocol *usable_protocols)
{
union mf_value value, mask;
char *error;
error = mf_parse(mf, s, &value, &mask);
if (!error) {
- mf_set(mf, &value, &mask, match);
+ *usable_protocols &= mf_set(mf, &value, &mask, match);
}
return error;
}
static char * WARN_UNUSED_RESULT
-parse_ofp_str__(struct ofputil_flow_mod *fm, int command, char *string)
+parse_ofp_str__(struct ofputil_flow_mod *fm, int command, char *string,
+ enum ofputil_protocol *usable_protocols)
{
enum {
F_OUT_PORT = 1 << 0,
char *act_str = NULL;
char *name;
+ *usable_protocols = OFPUTIL_P_ANY;
+
switch (command) {
case -1:
fields = F_OUT_PORT;
match_set_nw_proto(&fm->match, p->nw_proto);
}
} else if (fields & F_FLAGS && !strcmp(name, "send_flow_rem")) {
- fm->flags |= OFPFF_SEND_FLOW_REM;
+ fm->flags |= OFPUTIL_FF_SEND_FLOW_REM;
} else if (fields & F_FLAGS && !strcmp(name, "check_overlap")) {
- fm->flags |= OFPFF_CHECK_OVERLAP;
+ fm->flags |= OFPUTIL_FF_CHECK_OVERLAP;
} else if (fields & F_FLAGS && !strcmp(name, "reset_counts")) {
- fm->flags |= OFPFF12_RESET_COUNTS;
+ fm->flags |= OFPUTIL_FF_RESET_COUNTS;
+ *usable_protocols &= OFPUTIL_P_OF12_UP;
} else if (fields & F_FLAGS && !strcmp(name, "no_packet_counts")) {
- fm->flags |= OFPFF13_NO_PKT_COUNTS;
+ fm->flags |= OFPUTIL_FF_NO_PKT_COUNTS;
+ *usable_protocols &= OFPUTIL_P_OF13_UP;
} else if (fields & F_FLAGS && !strcmp(name, "no_byte_counts")) {
- fm->flags |= OFPFF13_NO_BYT_COUNTS;
+ fm->flags |= OFPUTIL_FF_NO_BYT_COUNTS;
+ *usable_protocols &= OFPUTIL_P_OF13_UP;
} else {
char *value;
if (!strcmp(name, "table")) {
error = str_to_u8(value, "table", &fm->table_id);
+ if (fm->table_id != 0xff) {
+ *usable_protocols &= OFPUTIL_P_TID;
+ }
} else if (!strcmp(name, "out_port")) {
if (!ofputil_port_from_string(value, &fm->out_port)) {
error = xasprintf("%s is not a valid OpenFlow port",
return error;
}
error = str_to_be64(mask + 1, &fm->cookie_mask);
+
+ /* Matching of the cookie is only supported through NXM or
+ * OF1.1+. */
+ if (fm->cookie_mask != htonll(0)) {
+ *usable_protocols &= OFPUTIL_P_NXM_OF11_UP;
+ }
} else {
/* No mask means that the cookie is being set. */
if (command != OFPFC_ADD && command != OFPFC_MODIFY
fm->modify_cookie = true;
}
} else if (mf_from_name(name)) {
- error = parse_field(mf_from_name(name), value, &fm->match);
+ error = parse_field(mf_from_name(name), value, &fm->match,
+ usable_protocols);
} else if (!strcmp(name, "duration")
|| !strcmp(name, "n_packets")
|| !strcmp(name, "n_bytes")
}
}
}
+ /* Check for usable protocol interdependencies between match fields. */
+ if (fm->match.flow.dl_type == htons(ETH_TYPE_IPV6)) {
+ const struct flow_wildcards *wc = &fm->match.wc;
+ /* Only NXM and OXM support matching L3 and L4 fields within IPv6.
+ *
+ * (IPv6 specific fields as well as arp_sha, arp_tha, nw_frag, and
+ * nw_ttl are covered elsewhere so they don't need to be included in
+ * this test too.)
+ */
+ if (wc->masks.nw_proto || wc->masks.nw_tos
+ || wc->masks.tp_src || wc->masks.tp_dst) {
+ *usable_protocols &= OFPUTIL_P_NXM_OXM_ANY;
+ }
+ }
if (!fm->cookie_mask && fm->new_cookie == htonll(UINT64_MAX)
&& (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT)) {
/* On modifies without a mask, we are supposed to add a flow if
char *error;
ofpbuf_init(&ofpacts, 32);
- error = str_to_inst_ofpacts(act_str, &ofpacts);
+ error = str_to_inst_ofpacts(act_str, &ofpacts, usable_protocols);
if (!error) {
enum ofperr err;
/* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
* page) into 'fm' for sending the specified flow_mod 'command' to a switch.
+ * Returns the set of usable protocols in '*usable_protocols'.
*
* To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
* constant for 'command'. To parse syntax for an OFPST_FLOW or
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
char * WARN_UNUSED_RESULT
-parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_)
+parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
+ enum ofputil_protocol *usable_protocols)
{
char *string = xstrdup(str_);
char *error;
- error = parse_ofp_str__(fm, command, string);
+ error = parse_ofp_str__(fm, command, string, usable_protocols);
if (error) {
fm->ofpacts = NULL;
fm->ofpacts_len = 0;
static char * WARN_UNUSED_RESULT
parse_ofp_meter_mod_str__(struct ofputil_meter_mod *mm, char *string,
- struct ofpbuf *bands, int command)
+ struct ofpbuf *bands, int command,
+ enum ofputil_protocol *usable_protocols)
{
enum {
F_METER = 1 << 0,
char *band_str = NULL;
char *name;
+ /* Meters require at least OF 1.3. */
+ *usable_protocols &= OFPUTIL_P_OF13_UP;
+
switch (command) {
case -1:
fields = F_METER;
* error. The caller is responsible for freeing the returned string. */
char * WARN_UNUSED_RESULT
parse_ofp_meter_mod_str(struct ofputil_meter_mod *mm, const char *str_,
- int command)
+ int command, enum ofputil_protocol *usable_protocols)
{
struct ofpbuf bands;
char *string;
ofpbuf_init(&bands, 64);
string = xstrdup(str_);
- error = parse_ofp_meter_mod_str__(mm, string, &bands, command);
+ error = parse_ofp_meter_mod_str__(mm, string, &bands, command,
+ usable_protocols);
free(string);
ofpbuf_uninit(&bands);
static char * WARN_UNUSED_RESULT
parse_flow_monitor_request__(struct ofputil_flow_monitor_request *fmr,
- const char *str_, char *string)
+ const char *str_, char *string,
+ enum ofputil_protocol *usable_protocols)
{
static atomic_uint32_t id = ATOMIC_VAR_INIT(0);
char *save_ptr = NULL;
} else if (mf_from_name(name)) {
char *error;
- error = parse_field(mf_from_name(name), value, &fmr->match);
+ error = parse_field(mf_from_name(name), value, &fmr->match,
+ usable_protocols);
if (error) {
return error;
}
* error. The caller is responsible for freeing the returned string. */
char * WARN_UNUSED_RESULT
parse_flow_monitor_request(struct ofputil_flow_monitor_request *fmr,
- const char *str_)
+ const char *str_,
+ enum ofputil_protocol *usable_protocols)
{
char *string = xstrdup(str_);
- char *error = parse_flow_monitor_request__(fmr, str_, string);
+ char *error = parse_flow_monitor_request__(fmr, str_, string,
+ usable_protocols);
free(string);
return error;
}
* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
char * WARN_UNUSED_RESULT
-parse_ofpacts(const char *s_, struct ofpbuf *ofpacts)
+parse_ofpacts(const char *s_, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
{
char *s = xstrdup(s_);
- char *error = str_to_ofpacts(s, ofpacts);
+ char *error;
+
+ *usable_protocols = OFPUTIL_P_ANY;
+
+ error = str_to_ofpacts(s, ofpacts, usable_protocols);
free(s);
return error;
* error. The caller is responsible for freeing the returned string. */
char * WARN_UNUSED_RESULT
parse_ofp_flow_mod_str(struct ofputil_flow_mod *fm, const char *string,
- uint16_t command)
+ uint16_t command,
+ enum ofputil_protocol *usable_protocols)
{
- char *error = parse_ofp_str(fm, command, string);
+ char *error = parse_ofp_str(fm, command, string, usable_protocols);
if (!error) {
/* Normalize a copy of the match. This ensures that non-normalized
* flows get logged but doesn't affect what gets sent to the switch, so
* error. The caller is responsible for freeing the returned string. */
char * WARN_UNUSED_RESULT
parse_ofp_flow_mod_file(const char *file_name, uint16_t command,
- struct ofputil_flow_mod **fms, size_t *n_fms)
+ struct ofputil_flow_mod **fms, size_t *n_fms,
+ enum ofputil_protocol *usable_protocols)
{
size_t allocated_fms;
int line_number;
FILE *stream;
struct ds s;
+ *usable_protocols = OFPUTIL_P_ANY;
+
*fms = NULL;
*n_fms = 0;
line_number = 0;
while (!ds_get_preprocessed_line(&s, stream, &line_number)) {
char *error;
+ enum ofputil_protocol usable;
if (*n_fms >= allocated_fms) {
*fms = x2nrealloc(*fms, &allocated_fms, sizeof **fms);
}
- error = parse_ofp_flow_mod_str(&(*fms)[*n_fms], ds_cstr(&s), command);
+ error = parse_ofp_flow_mod_str(&(*fms)[*n_fms], ds_cstr(&s), command,
+ &usable);
if (error) {
size_t i;
return xasprintf("%s:%d: %s", file_name, line_number, error);
}
+ *usable_protocols &= usable; /* Each line can narrow the set. */
*n_fms += 1;
}
char * WARN_UNUSED_RESULT
parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
- bool aggregate, const char *string)
+ bool aggregate, const char *string,
+ enum ofputil_protocol *usable_protocols)
{
struct ofputil_flow_mod fm;
char *error;
- error = parse_ofp_str(&fm, -1, string);
+ error = parse_ofp_str(&fm, -1, string, usable_protocols);
if (error) {
return error;
}
+ /* Special table ID support not required for stats requests. */
+ if (*usable_protocols & OFPUTIL_P_OF10_STD_TID) {
+ *usable_protocols |= OFPUTIL_P_OF10_STD;
+ }
+ if (*usable_protocols & OFPUTIL_P_OF10_NXM_TID) {
+ *usable_protocols |= OFPUTIL_P_OF10_NXM;
+ }
+
fsr->aggregate = aggregate;
fsr->cookie = fm.cookie;
fsr->cookie_mask = fm.cookie_mask;
struct ofputil_flow_monitor_request;
struct ofputil_flow_stats_request;
struct ofputil_meter_mod;
+enum ofputil_protocol;
-char *parse_ofp_str(struct ofputil_flow_mod *, int command, const char *str_)
+char *parse_ofp_str(struct ofputil_flow_mod *, int command, const char *str_,
+ enum ofputil_protocol *usable_protocols)
WARN_UNUSED_RESULT;
char *parse_ofp_flow_mod_str(struct ofputil_flow_mod *, const char *string,
- uint16_t command)
+ uint16_t command,
+ enum ofputil_protocol *usable_protocols)
WARN_UNUSED_RESULT;
char *parse_ofp_flow_mod_file(const char *file_name, uint16_t command,
- struct ofputil_flow_mod **fms, size_t *n_fms)
+ struct ofputil_flow_mod **fms, size_t *n_fms,
+ enum ofputil_protocol *usable_protocols)
WARN_UNUSED_RESULT;
char *parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *,
- bool aggregate, const char *string)
+ bool aggregate, const char *string,
+ enum ofputil_protocol *usable_protocols)
WARN_UNUSED_RESULT;
-char *parse_ofpacts(const char *, struct ofpbuf *ofpacts)
+char *parse_ofpacts(const char *, struct ofpbuf *ofpacts,
+ enum ofputil_protocol *usable_protocols)
WARN_UNUSED_RESULT;
char *parse_ofp_exact_flow(struct flow *, const char *);
char *parse_ofp_meter_mod_str(struct ofputil_meter_mod *, const char *string,
- int command)
+ int command,
+ enum ofputil_protocol *usable_protocols)
WARN_UNUSED_RESULT;
char *parse_flow_monitor_request(struct ofputil_flow_monitor_request *,
- const char *)
+ const char *,
+ enum ofputil_protocol *usable_protocols)
WARN_UNUSED_RESULT;
#endif /* ofp-parse.h */
}
static void
-ofp_print_flow_flags(struct ds *s, uint16_t flags)
+ofp_print_flow_flags(struct ds *s, enum ofputil_flow_mod_flags flags)
{
- if (flags & OFPFF_SEND_FLOW_REM) {
+ if (flags & OFPUTIL_FF_SEND_FLOW_REM) {
ds_put_cstr(s, "send_flow_rem ");
}
- if (flags & OFPFF_CHECK_OVERLAP) {
+ if (flags & OFPUTIL_FF_CHECK_OVERLAP) {
ds_put_cstr(s, "check_overlap ");
}
- if (flags & OFPFF12_RESET_COUNTS) {
+ if (flags & OFPUTIL_FF_RESET_COUNTS) {
ds_put_cstr(s, "reset_counts ");
}
- if (flags & OFPFF13_NO_PKT_COUNTS) {
+ if (flags & OFPUTIL_FF_NO_PKT_COUNTS) {
ds_put_cstr(s, "no_packet_counts ");
}
- if (flags & OFPFF13_NO_BYT_COUNTS) {
+ if (flags & OFPUTIL_FF_NO_BYT_COUNTS) {
ds_put_cstr(s, "no_byte_counts ");
}
-
- flags &= ~(OFPFF_SEND_FLOW_REM | OFPFF_CHECK_OVERLAP
- | OFPFF12_RESET_COUNTS
- | OFPFF13_NO_PKT_COUNTS | OFPFF13_NO_BYT_COUNTS);
- if (flags) {
- ds_put_format(s, "flags:0x%"PRIx16" ", flags);
- }
}
static void
ofputil_format_port(fm.out_port, s);
ds_put_char(s, ' ');
}
- if (fm.flags != 0) {
- ofp_print_flow_flags(s, fm.flags);
+
+ if (oh->version == OFP10_VERSION || oh->version == OFP11_VERSION) {
+ /* Don't print the reset_counts flag for OF1.0 and OF1.1 because those
+ * versions don't really have such a flag and printing one is likely to
+ * confuse people. */
+ fm.flags &= ~OFPUTIL_FF_RESET_COUNTS;
}
+ ofp_print_flow_flags(s, fm.flags);
ofpacts_format(fm.ofpacts, fm.ofpacts_len, s);
ofpbuf_uninit(&ofpacts);
: -1);
}
-static bool
-regs_fully_wildcarded(const struct flow_wildcards *wc)
-{
- int i;
-
- for (i = 0; i < FLOW_N_REGS; i++) {
- if (wc->masks.regs[i] != 0) {
- return false;
- }
- }
- return true;
-}
-
-/* Returns a bit-mask of ofputil_protocols that can be used for sending 'match'
- * to a switch (e.g. to add or remove a flow). Only NXM can handle tunnel IDs,
- * registers, or fixing the Ethernet multicast bit. Otherwise, it's better to
- * use OpenFlow 1.0 protocol for backward compatibility. */
-enum ofputil_protocol
-ofputil_usable_protocols(const struct match *match)
-{
- const struct flow_wildcards *wc = &match->wc;
-
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20);
-
- /* These tunnel params can't be sent in a flow_mod */
- if (wc->masks.tunnel.ip_ttl
- || wc->masks.tunnel.ip_tos || wc->masks.tunnel.flags) {
- return OFPUTIL_P_NONE;
- }
-
- /* skb_priority can't be sent in a flow_mod */
- if (wc->masks.skb_priority) {
- return OFPUTIL_P_NONE;
- }
-
- /* NXM and OXM support pkt_mark */
- if (wc->masks.pkt_mark) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM, OXM, and OF1.1 support bitwise matching on ethernet addresses. */
- if (!eth_mask_is_exact(wc->masks.dl_src)
- && !eth_addr_is_zero(wc->masks.dl_src)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
- if (!eth_mask_is_exact(wc->masks.dl_dst)
- && !eth_addr_is_zero(wc->masks.dl_dst)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM, OXM, and OF1.1+ support matching metadata. */
- if (wc->masks.metadata != htonll(0)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support matching ARP hardware addresses. */
- if (!eth_addr_is_zero(wc->masks.arp_sha) ||
- !eth_addr_is_zero(wc->masks.arp_tha)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support matching L3 and L4 fields within IPv6.
- *
- * (arp_sha, arp_tha, nw_frag, and nw_ttl are covered elsewhere so they
- * don't need to be included in this test too.) */
- if (match->flow.dl_type == htons(ETH_TYPE_IPV6)
- && (!ipv6_mask_is_any(&wc->masks.ipv6_src)
- || !ipv6_mask_is_any(&wc->masks.ipv6_dst)
- || !ipv6_mask_is_any(&wc->masks.nd_target)
- || wc->masks.ipv6_label
- || wc->masks.tp_src
- || wc->masks.tp_dst
- || wc->masks.nw_proto
- || wc->masks.nw_tos)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support matching registers. */
- if (!regs_fully_wildcarded(wc)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support matching tun_id, tun_src, and tun_dst. */
- if (wc->masks.tunnel.tun_id != htonll(0)
- || wc->masks.tunnel.ip_src != htonl(0)
- || wc->masks.tunnel.ip_dst != htonl(0)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support matching fragments. */
- if (wc->masks.nw_frag) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support matching IP ECN bits. */
- if (wc->masks.nw_tos & IP_ECN_MASK) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support matching IP TTL/hop limit. */
- if (wc->masks.nw_ttl) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support non-CIDR IPv4 address masks. */
- if (!ip_is_cidr(wc->masks.nw_src) || !ip_is_cidr(wc->masks.nw_dst)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OXM support bitwise matching on transport port. */
- if ((wc->masks.tp_src && wc->masks.tp_src != htons(UINT16_MAX)) ||
- (wc->masks.tp_dst && wc->masks.tp_dst != htons(UINT16_MAX))) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OF1.1+ support matching MPLS label */
- if (wc->masks.mpls_lse & htonl(MPLS_LABEL_MASK)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OF1.1+ support matching MPLS TC */
- if (wc->masks.mpls_lse & htonl(MPLS_TC_MASK)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* NXM and OF1.3+ support matching MPLS stack flag */
- /* Allow for OF1.2 as there doesn't seem to be a
- * particularly good reason not to */
- if (wc->masks.mpls_lse & htonl(MPLS_BOS_MASK)) {
- return OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
-
- /* Other formats can express this rule. */
- return OFPUTIL_P_ANY;
-}
-
void
ofputil_format_version(struct ds *msg, enum ofp_version version)
{
return msg;
}
+struct ofputil_flow_mod_flag {
+ uint16_t raw_flag;
+ enum ofp_version min_version, max_version;
+ enum ofputil_flow_mod_flags flag;
+};
+
+static const struct ofputil_flow_mod_flag ofputil_flow_mod_flags[] = {
+ { OFPFF_SEND_FLOW_REM, OFP10_VERSION, 0, OFPUTIL_FF_SEND_FLOW_REM },
+ { OFPFF_CHECK_OVERLAP, OFP10_VERSION, 0, OFPUTIL_FF_CHECK_OVERLAP },
+ { OFPFF10_EMERG, OFP10_VERSION, OFP10_VERSION,
+ OFPUTIL_FF_EMERG },
+ { OFPFF12_RESET_COUNTS, OFP12_VERSION, 0, OFPUTIL_FF_RESET_COUNTS },
+ { OFPFF13_NO_PKT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_PKT_COUNTS },
+ { OFPFF13_NO_BYT_COUNTS, OFP13_VERSION, 0, OFPUTIL_FF_NO_BYT_COUNTS },
+ { 0, 0, 0, 0 },
+};
+
+static enum ofperr
+ofputil_decode_flow_mod_flags(ovs_be16 raw_flags_,
+ enum ofp_flow_mod_command command,
+ enum ofp_version version,
+ enum ofputil_flow_mod_flags *flagsp)
+{
+ uint16_t raw_flags = ntohs(raw_flags_);
+ const struct ofputil_flow_mod_flag *f;
+
+ *flagsp = 0;
+ for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
+ if (raw_flags & f->raw_flag
+ && version >= f->min_version
+ && (!f->max_version || version <= f->max_version)) {
+ raw_flags &= ~f->raw_flag;
+ *flagsp |= f->flag;
+ }
+ }
+
+ /* In OF1.0 and OF1.1, "add" always resets counters, and other commands
+ * never do.
+ *
+ * In OF1.2 and later, OFPFF12_RESET_COUNTS controls whether each command
+ * resets counters. */
+ if ((version == OFP10_VERSION || version == OFP11_VERSION)
+ && command == OFPFC_ADD) {
+ *flagsp |= OFPUTIL_FF_RESET_COUNTS;
+ }
+
+ return raw_flags ? OFPERR_OFPFMFC_BAD_FLAGS : 0;
+}
+
+static ovs_be16
+ofputil_encode_flow_mod_flags(enum ofputil_flow_mod_flags flags,
+ enum ofp_version version)
+{
+ const struct ofputil_flow_mod_flag *f;
+ uint16_t raw_flags;
+
+ raw_flags = 0;
+ for (f = ofputil_flow_mod_flags; f->raw_flag; f++) {
+ if (f->flag & flags
+ && version >= f->min_version
+ && (!f->max_version || version <= f->max_version)) {
+ raw_flags |= f->raw_flag;
+ }
+ }
+
+ return htons(raw_flags);
+}
+
/* Converts an OFPT_FLOW_MOD or NXT_FLOW_MOD message 'oh' into an abstract
* flow_mod in 'fm'. Returns 0 if successful, otherwise an OpenFlow error
* code.
enum ofputil_protocol protocol,
struct ofpbuf *ofpacts)
{
- uint16_t command;
+ ovs_be16 raw_flags;
+ enum ofperr error;
struct ofpbuf b;
enum ofpraw raw;
ofpbuf_use_const(&b, oh, ntohs(oh->length));
raw = ofpraw_pull_assert(&b);
if (raw == OFPRAW_OFPT11_FLOW_MOD) {
- /* Standard OpenFlow 1.1 flow_mod. */
+ /* Standard OpenFlow 1.1+ flow_mod. */
const struct ofp11_flow_mod *ofm;
- enum ofperr error;
ofm = ofpbuf_pull(&b, sizeof *ofm);
&& ofm->out_group != htonl(OFPG_ANY)) {
return OFPERR_OFPFMFC_UNKNOWN;
}
- fm->flags = ntohs(ofm->flags);
+ raw_flags = ofm->flags;
} else {
+ uint16_t command;
+
if (raw == OFPRAW_OFPT10_FLOW_MOD) {
/* Standard OpenFlow 1.0 flow_mod. */
const struct ofp10_flow_mod *ofm;
- enum ofperr error;
/* Get the ofp10_flow_mod. */
ofm = ofpbuf_pull(&b, sizeof *ofm);
fm->hard_timeout = ntohs(ofm->hard_timeout);
fm->buffer_id = ntohl(ofm->buffer_id);
fm->out_port = u16_to_ofp(ntohs(ofm->out_port));
- fm->flags = ntohs(ofm->flags);
+ raw_flags = ofm->flags;
} else if (raw == OFPRAW_NXT_FLOW_MOD) {
/* Nicira extended flow_mod. */
const struct nx_flow_mod *nfm;
- enum ofperr error;
/* Dissect the message. */
nfm = ofpbuf_pull(&b, sizeof *nfm);
fm->hard_timeout = ntohs(nfm->hard_timeout);
fm->buffer_id = ntohl(nfm->buffer_id);
fm->out_port = u16_to_ofp(ntohs(nfm->out_port));
- fm->flags = ntohs(nfm->flags);
+ raw_flags = nfm->flags;
} else {
NOT_REACHED();
}
- if (fm->flags & OFPFF10_EMERG) {
- /* We do not support the OpenFlow 1.0 emergency flow cache, which
- * is not required in OpenFlow 1.0.1 and removed from OpenFlow 1.1.
- *
- * OpenFlow 1.0 specifies the error code to use when idle_timeout
- * or hard_timeout is nonzero. Otherwise, there is no good error
- * code, so just state that the flow table is full. */
- return (fm->hard_timeout || fm->idle_timeout
- ? OFPERR_OFPFMFC_BAD_EMERG_TIMEOUT
- : OFPERR_OFPFMFC_TABLE_FULL);
- }
-
fm->modify_cookie = fm->new_cookie != htonll(UINT64_MAX);
if (protocol & OFPUTIL_P_TID) {
fm->command = command & 0xff;
fm->ofpacts = ofpacts->data;
fm->ofpacts_len = ofpacts->size;
+ error = ofputil_decode_flow_mod_flags(raw_flags, fm->command,
+ oh->version, &fm->flags);
+ if (error) {
+ return error;
+ }
+
+ if (fm->flags & OFPUTIL_FF_EMERG) {
+ /* We do not support the OpenFlow 1.0 emergency flow cache, which
+ * is not required in OpenFlow 1.0.1 and removed from OpenFlow 1.1.
+ *
+ * OpenFlow 1.0 specifies the error code to use when idle_timeout
+ * or hard_timeout is nonzero. Otherwise, there is no good error
+ * code, so just state that the flow table is full. */
+ return (fm->hard_timeout || fm->idle_timeout
+ ? OFPERR_OFPFMFC_BAD_EMERG_TIMEOUT
+ : OFPERR_OFPFMFC_TABLE_FULL);
+ }
+
return 0;
}
ofputil_encode_flow_mod(const struct ofputil_flow_mod *fm,
enum ofputil_protocol protocol)
{
+ enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
+ ovs_be16 raw_flags = ofputil_encode_flow_mod_flags(fm->flags, version);
struct ofpbuf *msg;
switch (protocol) {
int tailroom;
tailroom = ofputil_match_typical_len(protocol) + fm->ofpacts_len;
- msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD,
- ofputil_protocol_to_ofp_version(protocol),
- tailroom);
+ msg = ofpraw_alloc(OFPRAW_OFPT11_FLOW_MOD, version, tailroom);
ofm = ofpbuf_put_zeros(msg, sizeof *ofm);
if ((protocol == OFPUTIL_P_OF11_STD
&& (fm->command == OFPFC_MODIFY ||
ofm->buffer_id = htonl(fm->buffer_id);
ofm->out_port = ofputil_port_to_ofp11(fm->out_port);
ofm->out_group = htonl(OFPG11_ANY);
- ofm->flags = htons(fm->flags);
+ ofm->flags = raw_flags;
ofputil_put_ofp11_match(msg, &fm->match, protocol);
ofpacts_put_openflow11_instructions(fm->ofpacts, fm->ofpacts_len, msg);
break;
ofm->priority = htons(fm->priority);
ofm->buffer_id = htonl(fm->buffer_id);
ofm->out_port = htons(ofp_to_u16(fm->out_port));
- ofm->flags = htons(fm->flags);
+ ofm->flags = raw_flags;
ofpacts_put_openflow10(fm->ofpacts, fm->ofpacts_len, msg);
break;
}
nfm->priority = htons(fm->priority);
nfm->buffer_id = htonl(fm->buffer_id);
nfm->out_port = htons(ofp_to_u16(fm->out_port));
- nfm->flags = htons(fm->flags);
+ nfm->flags = raw_flags;
nfm->match_len = htons(match_len);
ofpacts_put_openflow10(fm->ofpacts, fm->ofpacts_len, msg);
break;
return msg;
}
-/* Returns a bitmask with a 1-bit for each protocol that could be used to
- * send all of the 'n_fm's flow table modification requests in 'fms', and a
- * 0-bit for each protocol that is inadequate.
- *
- * (The return value will have at least one 1-bit.) */
-enum ofputil_protocol
-ofputil_flow_mod_usable_protocols(const struct ofputil_flow_mod *fms,
- size_t n_fms)
-{
- enum ofputil_protocol usable_protocols;
- size_t i;
-
- usable_protocols = OFPUTIL_P_ANY;
- for (i = 0; i < n_fms; i++) {
- const struct ofputil_flow_mod *fm = &fms[i];
-
- usable_protocols &= ofputil_usable_protocols(&fm->match);
- if (fm->table_id != 0xff) {
- usable_protocols &= OFPUTIL_P_TID;
- }
-
- /* Matching of the cookie is only supported through NXM or OF1.1+. */
- if (fm->cookie_mask != htonll(0)) {
- usable_protocols &= (OFPUTIL_P_OF10_NXM_ANY
- | OFPUTIL_P_OF11_STD
- | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM);
- }
- }
-
- return usable_protocols;
-}
-
static enum ofperr
ofputil_decode_ofpst10_flow_request(struct ofputil_flow_stats_request *fsr,
const struct ofp10_flow_stats_request *ofsr,
return msg;
}
-/* Returns a bitmask with a 1-bit for each protocol that could be used to
- * accurately encode 'fsr', and a 0-bit for each protocol that is inadequate.
- *
- * (The return value will have at least one 1-bit.) */
-enum ofputil_protocol
-ofputil_flow_stats_request_usable_protocols(
- const struct ofputil_flow_stats_request *fsr)
-{
- enum ofputil_protocol usable_protocols;
-
- usable_protocols = ofputil_usable_protocols(&fsr->match);
- if (fsr->cookie_mask != htonll(0)) {
- usable_protocols &= OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF12_OXM
- | OFPUTIL_P_OF13_OXM;
- }
- return usable_protocols;
-}
-
/* Converts an OFPST_FLOW or NXST_FLOW reply in 'msg' into an abstract
* ofputil_flow_stats in 'fs'.
*
bool flow_age_extension,
struct ofpbuf *ofpacts)
{
+ const struct ofp_header *oh;
enum ofperr error;
enum ofpraw raw;
if (error) {
return error;
}
+ oh = msg->l2;
if (!msg->size) {
return EOF;
fs->duration_nsec = ntohl(ofs->duration_nsec);
fs->idle_timeout = ntohs(ofs->idle_timeout);
fs->hard_timeout = ntohs(ofs->hard_timeout);
- fs->flags = (raw == OFPRAW_OFPST13_FLOW_REPLY) ? ntohs(ofs->flags) : 0;
+ if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
+ error = ofputil_decode_flow_mod_flags(ofs->flags, -1, oh->version,
+ &fs->flags);
+ if (error) {
+ return error;
+ }
+ } else {
+ fs->flags = 0;
+ }
fs->idle_age = -1;
fs->hard_age = -1;
fs->cookie = ofs->cookie;
ofpraw_decode_partial(&raw, reply->data, reply->size);
if (raw == OFPRAW_OFPST11_FLOW_REPLY || raw == OFPRAW_OFPST13_FLOW_REPLY) {
+ const struct ofp_header *oh = reply->data;
struct ofp11_flow_stats *ofs;
ofpbuf_put_uninit(reply, sizeof *ofs);
ofs->priority = htons(fs->priority);
ofs->idle_timeout = htons(fs->idle_timeout);
ofs->hard_timeout = htons(fs->hard_timeout);
- ofs->flags = (raw == OFPRAW_OFPST13_FLOW_REPLY) ? htons(fs->flags) : 0;
+ if (raw == OFPRAW_OFPST13_FLOW_REPLY) {
+ ofs->flags = ofputil_encode_flow_mod_flags(fs->flags, oh->version);
+ } else {
+ ofs->flags = 0;
+ }
memset(ofs->pad2, 0, sizeof ofs->pad2);
ofs->cookie = fs->cookie;
ofs->packet_count = htonll(unknown_to_zero(fs->packet_count));
OFPUTIL_P_OF13_OXM = 1 << 6,
#define OFPUTIL_P_ANY_OXM (OFPUTIL_P_OF12_OXM | OFPUTIL_P_OF13_OXM)
+#define OFPUTIL_P_NXM_OF11_UP (OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_OF11_STD | \
+ OFPUTIL_P_ANY_OXM)
+
+#define OFPUTIL_P_NXM_OXM_ANY (OFPUTIL_P_OF10_NXM_ANY | OFPUTIL_P_ANY_OXM)
+
+#define OFPUTIL_P_OF11_UP (OFPUTIL_P_OF11_STD | OFPUTIL_P_ANY_OXM)
+
+#define OFPUTIL_P_OF12_UP (OFPUTIL_P_ANY_OXM)
+
+#define OFPUTIL_P_OF13_UP (OFPUTIL_P_OF13_OXM)
+
/* All protocols. */
#define OFPUTIL_P_ANY ((1 << 7) - 1)
const char *ofputil_protocol_to_string(enum ofputil_protocol);
char *ofputil_protocols_to_string(enum ofputil_protocol);
enum ofputil_protocol ofputil_protocols_from_string(const char *);
-enum ofputil_protocol ofputil_usable_protocols(const struct match *);
void ofputil_format_version(struct ds *, enum ofp_version);
void ofputil_format_version_name(struct ds *, enum ofp_version);
/* NXT_FLOW_MOD_TABLE_ID extension. */
struct ofpbuf *ofputil_make_flow_mod_table_id(bool flow_mod_table_id);
+/* Protocol-independent flow_mod flags. */
+enum ofputil_flow_mod_flags {
+ OFPUTIL_FF_SEND_FLOW_REM = 1 << 0, /* All versions. */
+ OFPUTIL_FF_CHECK_OVERLAP = 1 << 1, /* All versions. */
+ OFPUTIL_FF_EMERG = 1 << 2, /* OpenFlow 1.0 only. */
+ OFPUTIL_FF_RESET_COUNTS = 1 << 3, /* OpenFlow 1.2+. */
+ OFPUTIL_FF_NO_PKT_COUNTS = 1 << 4, /* OpenFlow 1.3+. */
+ OFPUTIL_FF_NO_BYT_COUNTS = 1 << 5 /* OpenFlow 1.3+. */
+};
+
/* Protocol-independent flow_mod.
*
* The handling of cookies across multiple versions of OpenFlow is a bit
uint16_t hard_timeout;
uint32_t buffer_id;
ofp_port_t out_port;
- uint16_t flags;
+ enum ofputil_flow_mod_flags flags;
struct ofpact *ofpacts; /* Series of "struct ofpact"s. */
size_t ofpacts_len; /* Length of ofpacts, in bytes. */
};
struct ofpbuf *ofputil_encode_flow_mod(const struct ofputil_flow_mod *,
enum ofputil_protocol);
-enum ofputil_protocol ofputil_flow_mod_usable_protocols(
- const struct ofputil_flow_mod *fms, size_t n_fms);
-
/* Flow stats or aggregate stats request, independent of protocol. */
struct ofputil_flow_stats_request {
bool aggregate; /* Aggregate results? */
struct ofputil_flow_stats_request *, const struct ofp_header *);
struct ofpbuf *ofputil_encode_flow_stats_request(
const struct ofputil_flow_stats_request *, enum ofputil_protocol);
-enum ofputil_protocol ofputil_flow_stats_request_usable_protocols(
- const struct ofputil_flow_stats_request *);
/* Flow stats reply, independent of protocol. */
struct ofputil_flow_stats {
uint64_t byte_count; /* Byte count, UINT64_MAX if unknown. */
struct ofpact *ofpacts;
size_t ofpacts_len;
- uint16_t flags; /* Added for OF 1.3 */
+ enum ofputil_flow_mod_flags flags;
};
int ofputil_decode_flow_stats_reply(struct ofputil_flow_stats *,
--- /dev/null
+/*
+ * Copyright (c) 2013 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.
+ */
+
+/* This header implements atomic operation primitives on Clang. */
+#ifndef IN_OVS_ATOMIC_H
+#error "This header should only be included indirectly via ovs-atomic.h."
+#endif
+
+#define OVS_ATOMIC_CLANG_IMPL 1
+
+/* Standard atomic types. */
+typedef _Atomic(_Bool) atomic_bool;
+
+typedef _Atomic(char) atomic_char;
+typedef _Atomic(signed char) atomic_schar;
+typedef _Atomic(unsigned char) atomic_uchar;
+
+typedef _Atomic(short) atomic_short;
+typedef _Atomic(unsigned short) atomic_ushort;
+
+typedef _Atomic(int) atomic_int;
+typedef _Atomic(unsigned int) atomic_uint;
+
+typedef _Atomic(long) atomic_long;
+typedef _Atomic(unsigned long) atomic_ulong;
+
+typedef _Atomic(long long) atomic_llong;
+typedef _Atomic(unsigned long long) atomic_ullong;
+
+typedef _Atomic(size_t) atomic_size_t;
+typedef _Atomic(ptrdiff_t) atomic_ptrdiff_t;
+
+typedef _Atomic(intmax_t) atomic_intmax_t;
+typedef _Atomic(uintmax_t) atomic_uintmax_t;
+
+typedef _Atomic(intptr_t) atomic_intptr_t;
+typedef _Atomic(uintptr_t) atomic_uintptr_t;
+
+/* Nonstandard atomic types. */
+typedef _Atomic(uint8_t) atomic_uint8_t;
+typedef _Atomic(uint16_t) atomic_uint16_t;
+typedef _Atomic(uint32_t) atomic_uint32_t;
+typedef _Atomic(uint64_t) atomic_uint64_t;
+
+typedef _Atomic(int8_t) atomic_int8_t;
+typedef _Atomic(int16_t) atomic_int16_t;
+typedef _Atomic(int32_t) atomic_int32_t;
+typedef _Atomic(int64_t) atomic_int64_t;
+
+#define ATOMIC_VAR_INIT(VALUE) (VALUE)
+
+#define atomic_init(OBJECT, VALUE) __c11_atomic_init(OBJECT, VALUE)
+
+/* Clang hard-codes these exact values internally but does not appear to
+ * export any names for them. */
+typedef enum {
+ memory_order_relaxed = 0,
+ memory_order_consume = 1,
+ memory_order_acquire = 2,
+ memory_order_release = 3,
+ memory_order_acq_rel = 4,
+ memory_order_seq_cst = 5
+} memory_order;
+
+#define atomic_thread_fence(ORDER) __c11_atomic_thread_fence(ORDER)
+#define atomic_signal_fence(ORDER) __c11_atomic_signal_fence(ORDER)
+
+#define atomic_store(DST, SRC) \
+ atomic_store_explicit(DST, SRC, memory_order_seq_cst)
+#define atomic_store_explicit(DST, SRC, ORDER) \
+ __c11_atomic_store(DST, SRC, ORDER)
+
+
+#define atomic_read(SRC, DST) \
+ atomic_read_explicit(SRC, DST, memory_order_seq_cst)
+#define atomic_read_explicit(SRC, DST, ORDER) \
+ (*(DST) = __c11_atomic_load(SRC, ORDER), \
+ (void) 0)
+
+#define atomic_add(RMW, ARG, ORIG) \
+ atomic_add_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_sub(RMW, ARG, ORIG) \
+ atomic_sub_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_or(RMW, ARG, ORIG) \
+ atomic_or_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_xor(RMW, ARG, ORIG) \
+ atomic_xor_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_and(RMW, ARG, ORIG) \
+ atomic_and_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+
+#define atomic_add_explicit(RMW, ARG, ORIG, ORDER) \
+ (*(ORIG) = __c11_atomic_fetch_add(RMW, ARG, ORDER), (void) 0)
+#define atomic_sub_explicit(RMW, ARG, ORIG, ORDER) \
+ (*(ORIG) = __c11_atomic_fetch_sub(RMW, ARG, ORDER), (void) 0)
+#define atomic_or_explicit(RMW, ARG, ORIG, ORDER) \
+ (*(ORIG) = __c11_atomic_fetch_or(RMW, ARG, ORDER), (void) 0)
+#define atomic_xor_explicit(RMW, ARG, ORIG, ORDER) \
+ (*(ORIG) = __c11_atomic_fetch_xor(RMW, ARG, ORDER), (void) 0)
+#define atomic_and_explicit(RMW, ARG, ORIG, ORDER) \
+ (*(ORIG) = __c11_atomic_fetch_and(RMW, ARG, ORDER), (void) 0)
+
+#include "ovs-atomic-flag-gcc4.7+.h"
--- /dev/null
+/*
+ * Copyright (c) 2013 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.
+ */
+
+/* This header implements atomic_flag on Clang and on GCC 4.7 and later. */
+#ifndef IN_OVS_ATOMIC_H
+#error "This header should only be included indirectly via ovs-atomic.h."
+#endif
+
+/* atomic_flag */
+
+typedef struct {
+ unsigned char b;
+} atomic_flag;
+#define ATOMIC_FLAG_INIT { .b = false }
+
+static inline bool
+atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
+ memory_order order)
+{
+ return __atomic_test_and_set(&object->b, order);
+}
+
+static inline bool
+atomic_flag_test_and_set(volatile atomic_flag *object)
+{
+ return atomic_flag_test_and_set_explicit(object, memory_order_seq_cst);
+}
+
+static inline void
+atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order)
+{
+ __atomic_clear(object, order);
+}
+
+static inline void
+atomic_flag_clear(volatile atomic_flag *object)
+{
+ atomic_flag_clear_explicit(object, memory_order_seq_cst);
+}
(*(ORIG) = __atomic_fetch_xor(RMW, OPERAND, ORDER), (void) 0)
#define atomic_and_explicit(RMW, OPERAND, ORIG, ORDER) \
(*(ORIG) = __atomic_fetch_and(RMW, OPERAND, ORDER), (void) 0)
-\f
-/* atomic_flag */
-
-typedef struct {
- unsigned char b;
-} atomic_flag;
-#define ATOMIC_FLAG_INIT { .b = false }
-
-static inline bool
-atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
- memory_order order)
-{
- return __atomic_test_and_set(&object->b, order);
-}
-
-static inline bool
-atomic_flag_test_and_set(volatile atomic_flag *object)
-{
- return atomic_flag_test_and_set_explicit(object, memory_order_seq_cst);
-}
-
-static inline void
-atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order)
-{
- __atomic_clear(object, order);
-}
-
-static inline void
-atomic_flag_clear(volatile atomic_flag *object)
-{
- atomic_flag_clear_explicit(object, memory_order_seq_cst);
-}
+
+#include "ovs-atomic-flag-gcc4.7+.h"
#include "ovs-atomic-pthreads.h"
#elif HAVE_STDATOMIC_H
#include "ovs-atomic-c11.h"
+ #elif __has_extension(c_atomic)
+ #include "ovs-atomic-clang.h"
#elif __GNUC__ >= 4 && __GNUC_MINOR__ >= 7
#include "ovs-atomic-gcc4.7+.h"
#elif HAVE_GCC4_ATOMICS
#include "dynamic-string.h"
#include "ofpbuf.h"
#include "ovs-thread.h"
+#include "unaligned.h"
const struct in6_addr in6addr_exact = IN6ADDR_EXACT_INIT;
struct arp_eth_header *arp;
ofpbuf_clear(b);
- ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + VLAN_HEADER_LEN
+ ofpbuf_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN
+ ARP_ETH_HEADER_LEN);
- ofpbuf_reserve(b, VLAN_HEADER_LEN);
+ ofpbuf_reserve(b, 2 + VLAN_HEADER_LEN);
eth = ofpbuf_put_uninit(b, sizeof *eth);
memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
memcpy(eth->eth_src, eth_src, ETH_ADDR_LEN);
arp->ar_pln = sizeof arp->ar_spa;
arp->ar_op = htons(ARP_OP_RARP);
memcpy(arp->ar_sha, eth_src, ETH_ADDR_LEN);
- arp->ar_spa = htonl(0);
+ put_16aligned_be32(&arp->ar_spa, htonl(0));
memcpy(arp->ar_tha, eth_src, ETH_ADDR_LEN);
- arp->ar_tpa = htonl(0);
+ put_16aligned_be32(&arp->ar_tpa, htonl(0));
}
/* Insert VLAN header according to given TCI. Packet passed must be Ethernet
/* Converts hex digits in 'hex' to an Ethernet packet in '*packetp'. The
* caller must free '*packetp'. On success, returns NULL. On failure, returns
- * an error message and stores NULL in '*packetp'. */
+ * an error message and stores NULL in '*packetp'.
+ *
+ * Aligns the L3 header of '*packetp' on a 32-bit boundary. */
const char *
eth_from_hex(const char *hex, struct ofpbuf **packetp)
{
struct ofpbuf *packet;
- packet = *packetp = ofpbuf_new(strlen(hex) / 2);
+ /* Use 2 bytes of headroom to 32-bit align the L3 header. */
+ packet = *packetp = ofpbuf_new_with_headroom(strlen(hex) / 2, 2);
if (ofpbuf_put_hex(packet, hex, NULL)[0] != '\0') {
ofpbuf_delete(packet);
* 'eth_src' and 'eth_type' parameters. A payload of 'size' bytes is allocated
* in 'b' and returned. This payload may be populated with appropriate
* information by the caller. Sets 'b''s 'l2' and 'l3' pointers to the
- * Ethernet header and payload respectively.
+ * Ethernet header and payload respectively. Aligns b->l3 on a 32-bit
+ * boundary.
*
* The returned packet has enough headroom to insert an 802.1Q VLAN header if
* desired. */
ofpbuf_clear(b);
- ofpbuf_prealloc_tailroom(b, ETH_HEADER_LEN + VLAN_HEADER_LEN + size);
- ofpbuf_reserve(b, VLAN_HEADER_LEN);
+ /* The magic 2 here ensures that the L3 header (when it is added later)
+ * will be 32-bit aligned. */
+ ofpbuf_prealloc_tailroom(b, 2 + ETH_HEADER_LEN + VLAN_HEADER_LEN + size);
+ ofpbuf_reserve(b, 2 + VLAN_HEADER_LEN);
eth = ofpbuf_put_uninit(b, ETH_HEADER_LEN);
data = ofpbuf_put_uninit(b, size);
}
static void
-packet_set_ipv4_addr(struct ofpbuf *packet, ovs_be32 *addr, ovs_be32 new_addr)
+packet_set_ipv4_addr(struct ofpbuf *packet,
+ ovs_16aligned_be32 *addr, ovs_be32 new_addr)
{
struct ip_header *nh = packet->l3;
+ ovs_be32 old_addr = get_16aligned_be32(addr);
if (nh->ip_proto == IPPROTO_TCP && packet->l7) {
struct tcp_header *th = packet->l4;
- th->tcp_csum = recalc_csum32(th->tcp_csum, *addr, new_addr);
+ th->tcp_csum = recalc_csum32(th->tcp_csum, old_addr, new_addr);
} else if (nh->ip_proto == IPPROTO_UDP && packet->l7) {
struct udp_header *uh = packet->l4;
if (uh->udp_csum) {
- uh->udp_csum = recalc_csum32(uh->udp_csum, *addr, new_addr);
+ uh->udp_csum = recalc_csum32(uh->udp_csum, old_addr, new_addr);
if (!uh->udp_csum) {
uh->udp_csum = htons(0xffff);
}
}
}
- nh->ip_csum = recalc_csum32(nh->ip_csum, *addr, new_addr);
- *addr = new_addr;
+ nh->ip_csum = recalc_csum32(nh->ip_csum, old_addr, new_addr);
+ put_16aligned_be32(addr, new_addr);
}
/* Returns true, if packet contains at least one routing header where
static bool
packet_rh_present(struct ofpbuf *packet)
{
- const struct ip6_hdr *nh;
+ const struct ovs_16aligned_ip6_hdr *nh;
int nexthdr;
size_t len;
size_t remaining;
if (remaining < sizeof *nh) {
return false;
}
- nh = ALIGNED_CAST(struct ip6_hdr *, data);
+ nh = ALIGNED_CAST(struct ovs_16aligned_ip6_hdr *, data);
data += sizeof *nh;
remaining -= sizeof *nh;
nexthdr = nh->ip6_nxt;
nexthdr = ext_hdr->ip6e_nxt;
len = (ext_hdr->ip6e_len + 2) * 4;
} else if (nexthdr == IPPROTO_FRAGMENT) {
- const struct ip6_frag *frag_hdr = ALIGNED_CAST(struct ip6_frag *,
- data);
+ const struct ovs_16aligned_ip6_frag *frag_hdr
+ = ALIGNED_CAST(struct ovs_16aligned_ip6_frag *, data);
nexthdr = frag_hdr->ip6f_nxt;
len = sizeof *frag_hdr;
static void
packet_update_csum128(struct ofpbuf *packet, uint8_t proto,
- ovs_be32 addr[4], const ovs_be32 new_addr[4])
+ ovs_16aligned_be32 addr[4], const ovs_be32 new_addr[4])
{
if (proto == IPPROTO_TCP && packet->l7) {
struct tcp_header *th = packet->l4;
static void
packet_set_ipv6_addr(struct ofpbuf *packet, uint8_t proto,
- struct in6_addr *addr, const ovs_be32 new_addr[4],
+ ovs_16aligned_be32 *addr, const ovs_be32 new_addr[4],
bool recalculate_csum)
{
if (recalculate_csum) {
- packet_update_csum128(packet, proto, (ovs_be32 *)addr, new_addr);
+ packet_update_csum128(packet, proto, addr, new_addr);
}
memcpy(addr, new_addr, sizeof(*addr));
}
static void
-packet_set_ipv6_flow_label(ovs_be32 *flow_label, ovs_be32 flow_key)
+packet_set_ipv6_flow_label(ovs_16aligned_be32 *flow_label, ovs_be32 flow_key)
{
- *flow_label = (*flow_label & htonl(~IPV6_LABEL_MASK)) | flow_key;
+ ovs_be32 old_label = get_16aligned_be32(flow_label);
+ ovs_be32 new_label = (old_label & htonl(~IPV6_LABEL_MASK)) | flow_key;
+ put_16aligned_be32(flow_label, new_label);
}
static void
-packet_set_ipv6_tc(ovs_be32 *flow_label, uint8_t tc)
+packet_set_ipv6_tc(ovs_16aligned_be32 *flow_label, uint8_t tc)
{
- *flow_label = (*flow_label & htonl(0xF00FFFFF)) | htonl(tc << 20);
+ ovs_be32 old_label = get_16aligned_be32(flow_label);
+ ovs_be32 new_label = (old_label & htonl(0xF00FFFFF)) | htonl(tc << 20);
+ put_16aligned_be32(flow_label, new_label);
}
/* Modifies the IPv4 header fields of 'packet' to be consistent with 'src',
{
struct ip_header *nh = packet->l3;
- if (nh->ip_src != src) {
+ if (get_16aligned_be32(&nh->ip_src) != src) {
packet_set_ipv4_addr(packet, &nh->ip_src, src);
}
- if (nh->ip_dst != dst) {
+ if (get_16aligned_be32(&nh->ip_dst) != dst) {
packet_set_ipv4_addr(packet, &nh->ip_dst, dst);
}
const ovs_be32 dst[4], uint8_t key_tc, ovs_be32 key_fl,
uint8_t key_hl)
{
- struct ip6_hdr *nh = packet->l3;
+ struct ovs_16aligned_ip6_hdr *nh = packet->l3;
if (memcmp(&nh->ip6_src, src, sizeof(ovs_be32[4]))) {
- packet_set_ipv6_addr(packet, proto, &nh->ip6_src, src, true);
+ packet_set_ipv6_addr(packet, proto, nh->ip6_src.be32, src, true);
}
if (memcmp(&nh->ip6_dst, dst, sizeof(ovs_be32[4]))) {
- packet_set_ipv6_addr(packet, proto, &nh->ip6_dst, dst,
+ packet_set_ipv6_addr(packet, proto, nh->ip6_dst.be32, dst,
!packet_rh_present(packet));
}
uint8_t ip_ttl;
uint8_t ip_proto;
ovs_be16 ip_csum;
- ovs_be32 ip_src;
- ovs_be32 ip_dst;
+ ovs_16aligned_be32 ip_src;
+ ovs_16aligned_be32 ip_dst;
};
BUILD_ASSERT_DECL(IP_HEADER_LEN == sizeof(struct ip_header));
ovs_be16 empty;
ovs_be16 mtu;
} frag;
- ovs_be32 gateway;
+ ovs_16aligned_be32 gateway;
} icmp_fields;
uint8_t icmp_data[0];
};
struct tcp_header {
ovs_be16 tcp_src;
ovs_be16 tcp_dst;
- ovs_be32 tcp_seq;
- ovs_be32 tcp_ack;
+ ovs_16aligned_be32 tcp_seq;
+ ovs_16aligned_be32 tcp_ack;
ovs_be16 tcp_ctl;
ovs_be16 tcp_winsz;
ovs_be16 tcp_csum;
#define ARP_OP_RARP 3
#define ARP_ETH_HEADER_LEN 28
-OVS_PACKED(
struct arp_eth_header {
/* Generic members. */
ovs_be16 ar_hrd; /* Hardware type. */
/* Ethernet+IPv4 specific members. */
uint8_t ar_sha[ETH_ADDR_LEN]; /* Sender hardware address. */
- ovs_be32 ar_spa; /* Sender protocol address. */
+ ovs_16aligned_be32 ar_spa; /* Sender protocol address. */
uint8_t ar_tha[ETH_ADDR_LEN]; /* Target hardware address. */
- ovs_be32 ar_tpa; /* Target protocol address. */
-});
+ ovs_16aligned_be32 ar_tpa; /* Target protocol address. */
+};
BUILD_ASSERT_DECL(ARP_ETH_HEADER_LEN == sizeof(struct arp_eth_header));
+/* Like struct in6_addr, but whereas that struct requires 32-bit alignment on
+ * most implementations, this one only requires 16-bit alignment. */
+union ovs_16aligned_in6_addr {
+ ovs_be16 be16[8];
+ ovs_16aligned_be32 be32[4];
+};
+
+/* Like struct in6_hdr, but whereas that struct requires 32-bit alignment, this
+ * one only requires 16-bit alignment. */
+struct ovs_16aligned_ip6_hdr {
+ union {
+ struct ovs_16aligned_ip6_hdrctl {
+ ovs_16aligned_be32 ip6_un1_flow;
+ ovs_be16 ip6_un1_plen;
+ uint8_t ip6_un1_nxt;
+ uint8_t ip6_un1_hlim;
+ } ip6_un1;
+ uint8_t ip6_un2_vfc;
+ } ip6_ctlun;
+ union ovs_16aligned_in6_addr ip6_src;
+ union ovs_16aligned_in6_addr ip6_dst;
+};
+
+/* Like struct in6_frag, but whereas that struct requires 32-bit alignment,
+ * this one only requires 16-bit alignment. */
+struct ovs_16aligned_ip6_frag {
+ uint8_t ip6f_nxt;
+ uint8_t ip6f_reserved;
+ ovs_be16 ip6f_offlg;
+ ovs_16aligned_be32 ip6f_ident;
+};
+
/* The IPv6 flow label is in the lower 20 bits of the first 32-bit word. */
#define IPV6_LABEL_MASK 0x000fffff
put_unaligned_u64__(p, x);
}
\f
+/* Returns the value in 'x'. */
+static inline uint32_t
+get_16aligned_u32(const ovs_16aligned_u32 *x)
+{
+ return ((uint32_t) x->hi << 16) | x->lo;
+}
+
+/* Stores 'value' in 'x'. */
+static inline void
+put_16aligned_u32(ovs_16aligned_u32 *x, uint32_t value)
+{
+ x->hi = value >> 16;
+ x->lo = value;
+}
+
/* Returns the value in 'x'. */
static inline uint64_t
get_32aligned_u64(const ovs_32aligned_u64 *x)
}
#ifndef __CHECKER__
+/* Returns the value of 'x'. */
+static inline ovs_be32
+get_16aligned_be32(const ovs_16aligned_be32 *x)
+{
+#ifdef WORDS_BIGENDIAN
+ return ((ovs_be32) x->hi << 16) | x->lo;
+#else
+ return ((ovs_be32) x->lo << 16) | x->hi;
+#endif
+}
+
+/* Stores network byte order 'value' into 'x'. */
+static inline void
+put_16aligned_be32(ovs_16aligned_be32 *x, ovs_be32 value)
+{
+#if WORDS_BIGENDIAN
+ x->hi = value >> 16;
+ x->lo = value;
+#else
+ x->hi = value;
+ x->lo = value >> 16;
+#endif
+}
+
/* Returns the value of 'x'. */
static inline ovs_be64
get_32aligned_be64(const ovs_32aligned_be64 *x)
#else /* __CHECKER__ */
/* Making sparse happy with these functions also makes them unreadable, so
* don't bother to show it their implementations. */
+ovs_be32 get_16aligned_be32(const ovs_16aligned_be32 *);
+void put_16aligned_be32(ovs_16aligned_be32 *, ovs_be32);
ovs_be64 get_32aligned_be64(const ovs_32aligned_be64 *);
void put_32aligned_be64(ovs_32aligned_be64 *, ovs_be64);
#endif
ofproto_dpif_flow_mod(ctx->xbridge->ofproto, fm);
}
-/* Reduces '*timeout' to no more than 'max'. A value of zero in either case
- * means "infinite". */
-static void
-reduce_timeout(uint16_t max, uint16_t *timeout)
-{
- if (max && (!*timeout || *timeout > max)) {
- *timeout = max;
- }
-}
-
static void
xlate_fin_timeout(struct xlate_ctx *ctx,
const struct ofpact_fin_timeout *oft)
{
if (ctx->xin->tcp_flags & (TCP_FIN | TCP_RST) && ctx->rule) {
- struct rule_dpif *rule = ctx->rule;
-
- ovs_mutex_lock(&rule->up.ofproto->expirable_mutex);
- if (list_is_empty(&rule->up.expirable)) {
- list_insert(&rule->up.ofproto->expirable, &rule->up.expirable);
- }
- ovs_mutex_unlock(&rule->up.ofproto->expirable_mutex);
-
- ovs_mutex_lock(&rule->up.timeout_mutex);
- reduce_timeout(oft->fin_idle_timeout, &rule->up.idle_timeout);
- reduce_timeout(oft->fin_hard_timeout, &rule->up.hard_timeout);
- ovs_mutex_unlock(&rule->up.timeout_mutex);
+ ofproto_rule_reduce_timeouts(&ctx->rule->up, oft->fin_idle_timeout,
+ oft->fin_hard_timeout);
}
}
ovs_rwlock_wrlock(&table->cls.rwlock);
cls_cursor_init(&cursor, &table->cls, NULL);
CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
- ofproto_rule_destroy(&ofproto->up, &table->cls, &rule->up);
+ ofproto_rule_delete(&ofproto->up, &table->cls, &rule->up);
}
ovs_rwlock_unlock(&table->cls.rwlock);
}
+ complete_operations(ofproto);
ovs_mutex_lock(&ofproto->flow_mod_mutex);
LIST_FOR_EACH_SAFE (fm, next_fm, list_node, &ofproto->flow_mods) {
return;
}
- if (!ovs_rwlock_trywrlock(&rule->up.evict)) {
- COVERAGE_INC(ofproto_dpif_expired);
-
- /* Get rid of the rule. */
- ofproto_rule_expire(&rule->up, reason);
- }
+ COVERAGE_INC(ofproto_dpif_expired);
+ ofproto_rule_expire(&rule->up, reason);
}
\f
/* Facets. */
rule->packet_count = 0;
rule->byte_count = 0;
ovs_mutex_unlock(&rule->stats_mutex);
- complete_operation(rule);
return 0;
}
static void
-rule_destruct(struct rule *rule_)
+rule_insert(struct rule *rule_)
{
struct rule_dpif *rule = rule_dpif_cast(rule_);
complete_operation(rule);
+}
+
+static void
+rule_delete(struct rule *rule_)
+{
+ struct rule_dpif *rule = rule_dpif_cast(rule_);
+ complete_operation(rule);
+}
+
+static void
+rule_destruct(struct rule *rule_)
+{
+ struct rule_dpif *rule = rule_dpif_cast(rule_);
ovs_mutex_destroy(&rule->stats_mutex);
}
}
static void
-rule_modify_actions(struct rule *rule_)
+rule_modify_actions(struct rule *rule_, bool reset_counters)
{
struct rule_dpif *rule = rule_dpif_cast(rule_);
+ if (reset_counters) {
+ ovs_mutex_lock(&rule->stats_mutex);
+ rule->packet_count = 0;
+ rule->byte_count = 0;
+ ovs_mutex_unlock(&rule->stats_mutex);
+ }
+
complete_operation(rule);
}
\f
NULL, /* rule_choose_table */
rule_alloc,
rule_construct,
+ rule_insert,
+ rule_delete,
rule_destruct,
rule_dealloc,
rule_get_stats,
}
void ofproto_rule_update_used(struct rule *, long long int used);
-void ofproto_rule_expire(struct rule *rule, uint8_t reason)
- OVS_RELEASES(rule->evict);
-void ofproto_rule_destroy(struct ofproto *, struct classifier *cls,
- struct rule *) OVS_REQ_WRLOCK(cls->rwlock);
+void ofproto_rule_expire(struct rule *rule, uint8_t reason);
+void ofproto_rule_delete(struct ofproto *, struct classifier *cls,
+ struct rule *) OVS_REQ_WRLOCK(cls->rwlock);
+void ofproto_rule_reduce_timeouts(struct rule *rule, uint16_t idle_timeout,
+ uint16_t hard_timeout)
+ OVS_EXCLUDED(rule->ofproto->expirable_mutex, rule->timeout_mutex);
bool ofproto_rule_has_out_port(const struct rule *, ofp_port_t out_port);
void ofoperation_complete(struct ofoperation *, enum ofperr);
-struct rule *ofoperation_get_victim(struct ofoperation *);
bool ofoperation_has_out_port(const struct ofoperation *, ofp_port_t out_port);
* ofport ->port_alloc ->port_construct ->port_destruct ->port_dealloc
* rule ->rule_alloc ->rule_construct ->rule_destruct ->rule_dealloc
*
+ * "ofproto" and "ofport" have this exact life cycle. The "rule" data
+ * structure also follow this life cycle with some additional elaborations
+ * described under "Rule Life Cycle" below.
+ *
* Any instance of a given data structure goes through the following life
* cycle:
*
* must complete all of them by calling ofoperation_complete().
*
* ->destruct() must also destroy all remaining rules in the ofproto's
- * tables, by passing each remaining rule to ofproto_rule_destroy(). The
- * client will destroy the flow tables themselves after ->destruct()
+ * tables, by passing each remaining rule to ofproto_rule_delete(), and
+ * then complete each of those deletions in turn by calling
+ * ofoperation_complete().
+ *
+ * (Thus, there is a multi-step process for any rule currently being
+ * inserted or modified at the beginning of destruction: first
+ * ofoperation_complete() that operation, then ofproto_rule_delete() the
+ * rule, then ofoperation_complete() the deletion operation.)
+ *
+ * The client will destroy the flow tables themselves after ->destruct()
* returns.
*/
struct ofproto *(*alloc)(void);
const struct match *match,
uint8_t *table_idp);
- /* Life-cycle functions for a "struct rule" (see "Life Cycle" above).
+ /* Life-cycle functions for a "struct rule".
+ *
+ *
+ * Rule Life Cycle
+ * ===============
+ *
+ * The life cycle of a struct rule is an elaboration of the basic life
+ * cycle described above under "Life Cycle".
+ *
+ * After a rule is successfully constructed, it is then inserted. If
+ * insertion completes successfully, then before it is later destructed, it
+ * is deleted.
+ *
+ * You can think of a rule as having the following extra steps inserted
+ * between "Life Cycle" steps 4 and 5:
+ *
+ * 4.1. The client inserts the rule into the flow table, making it
+ * visible in flow table lookups.
+ *
+ * 4.2. The client calls "rule_insert". Immediately or eventually, the
+ * implementation calls ofoperation_complete() to indicate that the
+ * insertion completed. If the operation failed, skip to step 5.
+ *
+ * 4.3. The rule is now installed in the flow table. Eventually it will
+ * be deleted.
+ *
+ * 4.4. The client removes the rule from the flow table. It is no longer
+ * visible in flow table lookups.
+ *
+ * 4.5. The client calls "rule_delete". Immediately or eventually, the
+ * implementation calls ofoperation_complete() to indicate that the
+ * deletion completed. Deletion is not allowed to fail, so it must
+ * be successful.
*
*
* Asynchronous Operation Support
* ==============================
*
- * The life-cycle operations on rules can operate asynchronously, meaning
- * that ->rule_construct() and ->rule_destruct() only need to initiate
- * their respective operations and do not need to wait for them to complete
- * before they return. ->rule_modify_actions() also operates
- * asynchronously.
+ * The "insert" and "delete" life-cycle operations on rules can operate
+ * asynchronously, meaning that ->rule_insert() and ->rule_delete() only
+ * need to initiate their respective operations and do not need to wait for
+ * them to complete before they return. ->rule_modify_actions() also
+ * operates asynchronously.
*
* An ofproto implementation reports the success or failure of an
* asynchronous operation on a rule using the rule's 'pending' member,
* which points to a opaque "struct ofoperation" that represents the
- * ongoing opreation. When the operation completes, the ofproto
+ * ongoing operation. When the operation completes, the ofproto
* implementation calls ofoperation_complete(), passing the ofoperation and
* an error indication.
*
* Only the following contexts may call ofoperation_complete():
*
- * - The function called to initiate the operation,
- * e.g. ->rule_construct() or ->rule_destruct(). This is the best
- * choice if the operation completes quickly.
+ * - The function called to initiate the operation, e.g. ->rule_insert()
+ * or ->rule_delete(). This is the best choice if the operation
+ * completes quickly.
*
* - The implementation's ->run() function.
*
* The ofproto base code updates the flow table optimistically, assuming
* that the operation will probably succeed:
*
- * - ofproto adds or replaces the rule in the flow table before calling
- * ->rule_construct().
+ * - ofproto adds the rule in the flow table before calling
+ * ->rule_insert().
*
- * - ofproto updates the rule's actions before calling
- * ->rule_modify_actions().
+ * - ofproto updates the rule's actions and other properties before
+ * calling ->rule_modify_actions().
*
- * - ofproto removes the rule before calling ->rule_destruct().
+ * - ofproto removes the rule before calling ->rule_delete().
*
* With one exception, when an asynchronous operation completes with an
* error, ofoperation_complete() backs out the already applied changes:
*
- * - If adding or replacing a rule in the flow table fails, ofproto
- * removes the new rule or restores the original rule.
+ * - If adding a rule in the flow table fails, ofproto removes the new
+ * rule.
*
- * - If modifying a rule's actions fails, ofproto restores the original
- * actions.
+ * - If modifying a rule fails, ofproto restores the original actions
+ * (and other properties).
*
* - Removing a rule is not allowed to fail. It must always succeed.
*
* Construction
* ============
*
- * When ->rule_construct() is called, the caller has already inserted
- * 'rule' into 'rule->ofproto''s flow table numbered 'rule->table_id'.
- * There are two cases:
+ * When ->rule_construct() is called, 'rule' is a new rule that is not yet
+ * inserted into a flow table. ->rule_construct() should initialize enough
+ * of the rule's derived state for 'rule' to be suitable for inserting into
+ * a flow table. ->rule_construct() should not modify any base members of
+ * struct rule.
*
- * - 'rule' is a new rule in its flow table. In this case,
- * ofoperation_get_victim(rule) returns NULL.
+ * If ->rule_construct() fails (as indicated by returning a nonzero
+ * OpenFlow error code), the ofproto base code will uninitialize and
+ * deallocate 'rule'. See "Rule Life Cycle" above for more details.
*
- * - 'rule' is replacing an existing rule in its flow table that had the
- * same matching criteria and priority. In this case,
- * ofoperation_get_victim(rule) returns the rule being replaced (the
- * "victim" rule).
+ * ->rule_construct() may also:
*
- * ->rule_construct() should set the following in motion:
- *
- * - Validate that the matching rule in 'rule->cr' is supported by the
+ * - Validate that the datapath supports the matching rule in 'rule->cr'
* datapath. For example, if the rule's table does not support
* registers, then it is an error if 'rule->cr' does not wildcard all
* registers.
*
* - Validate that the datapath can correctly implement 'rule->ofpacts'.
*
- * - If the rule is valid, update the datapath flow table, adding the new
- * rule or replacing the existing one.
+ * Some implementations might need to defer these tasks to ->rule_insert(),
+ * which is also acceptable.
+ *
*
- * - If 'rule' is replacing an existing rule, uninitialize any derived
- * state for the victim rule, as in step 5 in the "Life Cycle"
- * described above.
+ * Insertion
+ * =========
*
- * (On failure, the ofproto code will roll back the insertion from the flow
- * table, either removing 'rule' or replacing it by the victim rule if
- * there is one.)
+ * Following successful construction, the ofproto base case inserts 'rule'
+ * into its flow table, then it calls ->rule_insert(). ->rule_insert()
+ * should set in motion adding the new rule to the datapath flow table. It
+ * must act as follows:
*
- * ->rule_construct() must act in one of the following ways:
+ * - If it completes insertion, either by succeeding or failing, it must
+ * call ofoperation_complete()
*
- * - If it succeeds, it must call ofoperation_complete() and return 0.
+ * - If insertion is only partially complete, then it must return without
+ * calling ofoperation_complete(). Later, when the insertion is
+ * complete, the ->run() or ->destruct() function must call
+ * ofoperation_complete() to report success or failure.
*
- * - If it fails, it must act in one of the following ways:
+ * If ->rule_insert() fails, the ofproto base code will remove 'rule' from
+ * the flow table, destruct, uninitialize, and deallocate 'rule'. See
+ * "Rule Life Cycle" above for more details.
*
- * * Call ofoperation_complete() and return 0.
*
- * * Return an OpenFlow error code. (Do not call
- * ofoperation_complete() in this case.)
+ * Deletion
+ * ========
*
- * Either way, ->rule_destruct() will not be called for 'rule', but
- * ->rule_dealloc() will be.
+ * The ofproto base code removes 'rule' from its flow table before it calls
+ * ->rule_delete(). ->rule_delete() should set in motion removing 'rule'
+ * from the datapath flow table. It must act as follows:
*
- * - If the operation is only partially complete, then it must return 0.
- * Later, when the operation is complete, the ->run() or ->destruct()
- * function must call ofoperation_complete() to report success or
- * failure.
+ * - If it completes deletion, it must call ofoperation_complete().
*
- * ->rule_construct() should not modify any base members of struct rule.
+ * - If deletion is only partially complete, then it must return without
+ * calling ofoperation_complete(). Later, when the deletion is
+ * complete, the ->run() or ->destruct() function must call
+ * ofoperation_complete().
+ *
+ * Rule deletion must not fail.
*
*
* Destruction
* ===========
*
- * When ->rule_destruct() is called, the caller has already removed 'rule'
- * from 'rule->ofproto''s flow table. ->rule_destruct() should set in
- * motion removing 'rule' from the datapath flow table. If removal
- * completes synchronously, it should call ofoperation_complete().
- * Otherwise, the ->run() or ->destruct() function must later call
- * ofoperation_complete() after the operation completes.
+ * ->rule_destruct() must uninitialize derived state.
*
* Rule destruction must not fail. */
struct rule *(*rule_alloc)(void);
enum ofperr (*rule_construct)(struct rule *rule);
+ void (*rule_insert)(struct rule *rule);
+ void (*rule_delete)(struct rule *rule);
void (*rule_destruct)(struct rule *rule);
void (*rule_dealloc)(struct rule *rule);
* flow->tunnel and flow->in_port, which are assigned the correct values
* for the incoming packet. The register values are zeroed. 'packet''s
* header pointers (e.g. packet->l3) are appropriately initialized.
+ * packet->l3 is aligned on a 32-bit boundary.
*
* The implementation should add the statistics for 'packet' into 'rule'.
*
*
* - Update the datapath flow table with the new actions.
*
+ * - Only if 'reset_counters' is true, reset any packet or byte counters
+ * associated with the rule to zero, so that rule_get_stats() will not
+ * longer count those packets or bytes.
+ *
* If the operation synchronously completes, ->rule_modify_actions() may
* call ofoperation_complete() before it returns. Otherwise, ->run()
* should call ofoperation_complete() later, after the operation does
*
* ->rule_modify_actions() should not modify any base members of struct
* rule. */
- void (*rule_modify_actions)(struct rule *rule);
+ void (*rule_modify_actions)(struct rule *rule, bool reset_counters);
/* Changes the OpenFlow IP fragment handling policy to 'frag_handling',
* which takes one of the following values, with the corresponding
enum ofoperation_type {
OFOPERATION_ADD,
OFOPERATION_DELETE,
- OFOPERATION_MODIFY
+ OFOPERATION_MODIFY,
+ OFOPERATION_REPLACE
};
/* A single OpenFlow request can execute any number of operations. The
struct rule *rule; /* Rule being operated upon. */
enum ofoperation_type type; /* Type of operation. */
- /* OFOPERATION_ADD. */
- struct rule *victim; /* Rule being replaced, if any.. */
-
- /* OFOPERATION_MODIFY: The old actions, if the actions are changing. */
+ /* OFOPERATION_MODIFY, OFOPERATION_REPLACE: The old actions, if the actions
+ * are changing. */
struct ofpact *ofpacts;
size_t ofpacts_len;
uint32_t meter_id;
enum ofp_flow_removed_reason reason; /* Reason flow was removed. */
ovs_be64 flow_cookie; /* Rule's old flow cookie. */
+ uint16_t idle_timeout; /* Rule's old idle timeout. */
+ uint16_t hard_timeout; /* Rule's old hard timeout. */
+ bool send_flow_removed; /* Rule's old 'send_flow_removed'. */
enum ofperr error; /* 0 if no error. */
};
static void oftable_remove_rule__(struct ofproto *ofproto,
struct classifier *cls, struct rule *rule)
OVS_REQ_WRLOCK(cls->rwlock) OVS_RELEASES(rule->evict);
-static struct rule *oftable_replace_rule(struct rule *);
-static void oftable_substitute_rule(struct rule *old, struct rule *new);
+static void oftable_insert_rule(struct rule *);
/* A set of rules within a single OpenFlow table (oftable) that have the same
* values for the oftable's eviction_fields. A rule to be evicted, when one is
OVS_TRY_WRLOCK(true, (*rulep)->evict);
static void ofproto_evict(struct ofproto *);
static uint32_t rule_eviction_priority(struct rule *);
+static void eviction_group_add_rule(struct rule *);
+static void eviction_group_remove_rule(struct rule *);
/* ofport. */
static void ofport_destroy__(struct ofport *);
static enum ofperr add_flow(struct ofproto *, struct ofconn *,
struct ofputil_flow_mod *,
const struct ofp_header *);
+static enum ofperr modify_flows__(struct ofproto *, struct ofconn *,
+ struct ofputil_flow_mod *,
+ const struct ofp_header *, struct list *);
static void delete_flow__(struct rule *rule, struct ofopgroup *,
enum ofp_flow_removed_reason)
OVS_RELEASES(rule->evict);
connmgr_get_snoops(ofproto->connmgr, snoops);
}
+/* Deletes 'rule' from 'cls' within 'ofproto'.
+ *
+ * The 'cls' argument is redundant (it is &ofproto->tables[rule->table_id].cls)
+ * but it allows Clang to do better checking. */
static void
-ofproto_flush__(struct ofproto *ofproto)
+ofproto_delete_rule(struct ofproto *ofproto, struct classifier *cls,
+ struct rule *rule)
+ OVS_REQ_WRLOCK(cls->rwlock)
{
struct ofopgroup *group;
+
+ ovs_assert(!rule->pending);
+ ovs_assert(cls == &ofproto->tables[rule->table_id].cls);
+
+ group = ofopgroup_create_unattached(ofproto);
+ ofoperation_create(group, rule, OFOPERATION_DELETE, OFPRR_DELETE);
+ ovs_rwlock_wrlock(&rule->evict);
+ oftable_remove_rule__(ofproto, cls, rule);
+ ofproto->ofproto_class->rule_delete(rule);
+ ofopgroup_submit(group);
+}
+
+static void
+ofproto_flush__(struct ofproto *ofproto)
+{
struct oftable *table;
if (ofproto->ofproto_class->flush) {
ofproto->ofproto_class->flush(ofproto);
}
- group = ofopgroup_create_unattached(ofproto);
OFPROTO_FOR_EACH_TABLE (table, ofproto) {
struct rule *rule, *next_rule;
struct cls_cursor cursor;
cls_cursor_init(&cursor, &table->cls, NULL);
CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, cr, &cursor) {
if (!rule->pending) {
- ofoperation_create(group, rule, OFOPERATION_DELETE,
- OFPRR_DELETE);
- ovs_rwlock_wrlock(&rule->evict);
- oftable_remove_rule__(ofproto, &table->cls, rule);
- ofproto->ofproto_class->rule_destruct(rule);
+ ofproto_delete_rule(ofproto, &table->cls, rule);
}
}
ovs_rwlock_unlock(&table->cls.rwlock);
}
- ofopgroup_submit(group);
}
static void
ofproto_delete_flow(struct ofproto *ofproto,
const struct match *target, unsigned int priority)
{
+ struct classifier *cls = &ofproto->tables[0].cls;
struct rule *rule;
- ovs_rwlock_rdlock(&ofproto->tables[0].cls.rwlock);
- rule = rule_from_cls_rule(classifier_find_match_exactly(
- &ofproto->tables[0].cls, target, priority));
- ovs_rwlock_unlock(&ofproto->tables[0].cls.rwlock);
+ ovs_rwlock_rdlock(&cls->rwlock);
+ rule = rule_from_cls_rule(classifier_find_match_exactly(cls, target,
+ priority));
+ ovs_rwlock_unlock(&cls->rwlock);
if (!rule) {
/* No such rule -> success. */
return true;
return false;
} else {
/* Initiate deletion -> success. */
- struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
- ofoperation_create(group, rule, OFOPERATION_DELETE, OFPRR_DELETE);
- ovs_rwlock_wrlock(&rule->evict);
- oftable_remove_rule(rule);
- ofproto->ofproto_class->rule_destruct(rule);
- ofopgroup_submit(group);
+ ovs_rwlock_wrlock(&cls->rwlock);
+ ofproto_delete_rule(ofproto, cls, rule);
+ ovs_rwlock_unlock(&cls->rwlock);
+
return true;
}
ofproto_rule_destroy__(struct rule *rule)
{
if (rule) {
+ rule->ofproto->ofproto_class->rule_destruct(rule);
cls_rule_destroy(&rule->cr);
free(rule->ofpacts);
ovs_mutex_destroy(&rule->timeout_mutex);
}
/* This function allows an ofproto implementation to destroy any rules that
- * remain when its ->destruct() function is called. The caller must have
- * already uninitialized any derived members of 'rule' (step 5 described in the
- * large comment in ofproto/ofproto-provider.h titled "Life Cycle").
- * This function implements steps 6 and 7.
+ * remain when its ->destruct() function is called.. This function implements
+ * steps 4.4 and 4.5 in the section titled "Rule Life Cycle" in
+ * ofproto-provider.h.
*
* This function should only be called from an ofproto implementation's
* ->destruct() function. It is not suitable elsewhere. */
void
-ofproto_rule_destroy(struct ofproto *ofproto, struct classifier *cls,
- struct rule *rule) OVS_REQ_WRLOCK(cls->rwlock)
+ofproto_rule_delete(struct ofproto *ofproto, struct classifier *cls,
+ struct rule *rule)
+ OVS_REQ_WRLOCK(cls->rwlock)
{
- ovs_assert(!rule->pending);
- if (!ovs_rwlock_trywrlock(&rule->evict)) {
- oftable_remove_rule__(ofproto, cls, rule);
- } else {
- NOT_REACHED();
- }
- ofproto_rule_destroy__(rule);
+ ofproto_delete_rule(ofproto, cls, rule);
}
/* Returns true if 'rule' has an OpenFlow OFPAT_OUTPUT or OFPAT_ENQUEUE action
switch (op->type) {
case OFOPERATION_ADD:
- return op->victim && ofproto_rule_has_out_port(op->victim, out_port);
-
case OFOPERATION_DELETE:
return false;
case OFOPERATION_MODIFY:
+ case OFOPERATION_REPLACE:
return ofpacts_output_to_port(op->ofpacts, op->ofpacts_len, out_port);
}
}
/* Executes the actions indicated by 'rule' on 'packet' and credits 'rule''s
- * statistics appropriately. 'packet' must have at least sizeof(struct
- * ofp10_packet_in) bytes of headroom.
+ * statistics appropriately.
*
* 'packet' doesn't necessarily have to match 'rule'. 'rule' will be credited
* with statistics for 'packet' either way.
struct flow flow;
union flow_in_port in_port_;
- ovs_assert(ofpbuf_headroom(packet) >= sizeof(struct ofp10_packet_in));
-
in_port_.ofp_port = in_port;
flow_extract(packet, 0, 0, NULL, &in_port_, &flow);
return rule->ofproto->ofproto_class->rule_execute(rule, &flow, packet);
goto exit_free_ofpacts;
}
} else {
- payload = xmalloc(sizeof *payload);
- ofpbuf_use_const(payload, po.packet, po.packet_len);
+ /* Ensure that the L3 header is 32-bit aligned. */
+ payload = ofpbuf_clone_data_with_headroom(po.packet, po.packet_len, 2);
}
/* Verify actions against packet, then send packet if successful. */
&fs.byte_count);
fs.ofpacts = rule->ofpacts;
fs.ofpacts_len = rule->ofpacts_len;
- fs.flags = 0;
ovs_mutex_lock(&rule->timeout_mutex);
fs.idle_timeout = rule->idle_timeout;
fs.hard_timeout = rule->hard_timeout;
ovs_mutex_unlock(&rule->timeout_mutex);
+ fs.flags = 0;
if (rule->send_flow_removed) {
- fs.flags |= OFPFF_SEND_FLOW_REM;
- /* FIXME: Implement OF 1.3 flags OFPFF13_NO_PKT_COUNTS
- and OFPFF13_NO_BYT_COUNTS */
+ fs.flags |= OFPUTIL_FF_SEND_FLOW_REM;
+ /* FIXME: Implement OFPUTIL_FF_NO_PKT_COUNTS and
+ OFPUTIL_FF_NO_BYT_COUNTS. */
}
ofputil_append_flow_stats_reply(&fs, &replies);
}
return false;
}
+static enum ofperr
+evict_rule_from_table(struct ofproto *ofproto, struct oftable *table)
+{
+ struct rule *rule;
+ size_t n_rules;
+
+ ovs_rwlock_rdlock(&table->cls.rwlock);
+ n_rules = classifier_count(&table->cls);
+ ovs_rwlock_unlock(&table->cls.rwlock);
+
+ if (n_rules < table->max_flows) {
+ return 0;
+ } else if (!choose_rule_to_evict(table, &rule)) {
+ return OFPERR_OFPFMFC_TABLE_FULL;
+ } else if (rule->pending) {
+ ovs_rwlock_unlock(&rule->evict);
+ return OFPROTO_POSTPONE;
+ } else {
+ struct ofopgroup *group;
+
+ group = ofopgroup_create_unattached(ofproto);
+ delete_flow__(rule, group, OFPRR_EVICTION);
+ ofopgroup_submit(group);
+
+ return 0;
+ }
+}
+
/* Implements OFPFC_ADD and the cases for OFPFC_MODIFY and OFPFC_MODIFY_STRICT
* in which no matching flow already exists in the flow table.
*
{
struct oftable *table;
struct ofopgroup *group;
- struct rule *victim;
+ struct cls_rule cr;
struct rule *rule;
uint8_t table_id;
int error;
return OFPERR_OFPBRC_EPERM;
}
+ cls_rule_init(&cr, &fm->match, fm->priority);
+
+ /* Transform "add" into "modify" if there's an existing identical flow. */
+ ovs_rwlock_rdlock(&table->cls.rwlock);
+ rule = rule_from_cls_rule(classifier_find_rule_exactly(&table->cls, &cr));
+ ovs_rwlock_unlock(&table->cls.rwlock);
+ if (rule) {
+ cls_rule_destroy(&cr);
+ if (!rule_is_modifiable(rule)) {
+ return OFPERR_OFPBRC_EPERM;
+ } else if (rule->pending) {
+ return OFPROTO_POSTPONE;
+ } else {
+ struct list rules;
+
+ list_init(&rules);
+ list_push_back(&rules, &rule->ofproto_node);
+ fm->modify_cookie = true;
+ return modify_flows__(ofproto, ofconn, fm, request, &rules);
+ }
+ }
+
/* Verify actions. */
error = ofproto_check_ofpacts(ofproto, fm->ofpacts, fm->ofpacts_len,
&fm->match.flow, table_id);
return error;
}
- /* Allocate new rule and initialize classifier rule. */
- rule = ofproto->ofproto_class->rule_alloc();
- if (!rule) {
- VLOG_WARN_RL(&rl, "%s: failed to create rule (%s)",
- ofproto->name, ovs_strerror(error));
- return ENOMEM;
- }
- cls_rule_init(&rule->cr, &fm->match, fm->priority);
-
/* Serialize against pending deletion. */
- if (is_flow_deletion_pending(ofproto, &rule->cr, table_id)) {
- cls_rule_destroy(&rule->cr);
- ofproto->ofproto_class->rule_dealloc(rule);
+ if (is_flow_deletion_pending(ofproto, &cr, table_id)) {
+ cls_rule_destroy(&cr);
return OFPROTO_POSTPONE;
}
/* Check for overlap, if requested. */
- if (fm->flags & OFPFF_CHECK_OVERLAP) {
+ if (fm->flags & OFPUTIL_FF_CHECK_OVERLAP) {
bool overlaps;
ovs_rwlock_rdlock(&table->cls.rwlock);
- overlaps = classifier_rule_overlaps(&table->cls, &rule->cr);
+ overlaps = classifier_rule_overlaps(&table->cls, &cr);
ovs_rwlock_unlock(&table->cls.rwlock);
if (overlaps) {
- cls_rule_destroy(&rule->cr);
- ofproto->ofproto_class->rule_dealloc(rule);
+ cls_rule_destroy(&cr);
return OFPERR_OFPFMFC_OVERLAP;
}
}
- /* FIXME: Implement OFPFF12_RESET_COUNTS */
+ /* If necessary, evict an existing rule to clear out space. */
+ error = evict_rule_from_table(ofproto, table);
+ if (error) {
+ cls_rule_destroy(&cr);
+ return error;
+ }
+ /* Allocate new rule. */
+ rule = ofproto->ofproto_class->rule_alloc();
+ if (!rule) {
+ cls_rule_destroy(&cr);
+ VLOG_WARN_RL(&rl, "%s: failed to create rule (%s)",
+ ofproto->name, ovs_strerror(error));
+ return ENOMEM;
+ }
+
+ /* Initialize base state. */
rule->ofproto = ofproto;
+ cls_rule_move(&rule->cr, &cr);
rule->pending = NULL;
rule->flow_cookie = fm->new_cookie;
rule->created = rule->modified = rule->used = time_msec();
ovs_mutex_unlock(&rule->timeout_mutex);
rule->table_id = table - ofproto->tables;
- rule->send_flow_removed = (fm->flags & OFPFF_SEND_FLOW_REM) != 0;
- /* FIXME: Implement OF 1.3 flags OFPFF13_NO_PKT_COUNTS
- and OFPFF13_NO_BYT_COUNTS */
+ rule->send_flow_removed = (fm->flags & OFPUTIL_FF_SEND_FLOW_REM) != 0;
rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len);
rule->ofpacts_len = fm->ofpacts_len;
rule->meter_id = find_meter(rule->ofpacts, rule->ofpacts_len);
rule->modify_seqno = 0;
ovs_rwlock_init(&rule->evict);
- /* Insert new rule. */
- victim = oftable_replace_rule(rule);
- if (victim && !rule_is_modifiable(victim)) {
- error = OFPERR_OFPBRC_EPERM;
- } else if (victim && victim->pending) {
- error = OFPROTO_POSTPONE;
- } else {
- struct ofoperation *op;
- struct rule *evict;
- size_t n_rules;
-
- ovs_rwlock_rdlock(&table->cls.rwlock);
- n_rules = classifier_count(&table->cls);
- ovs_rwlock_unlock(&table->cls.rwlock);
- if (n_rules > table->max_flows) {
- ovs_rwlock_rdlock(&rule->evict);
- if (choose_rule_to_evict(table, &evict)) {
- ovs_rwlock_unlock(&rule->evict);
- ovs_rwlock_unlock(&evict->evict);
- if (evict->pending) {
- error = OFPROTO_POSTPONE;
- goto exit;
- }
- } else {
- ovs_rwlock_unlock(&rule->evict);
- error = OFPERR_OFPFMFC_TABLE_FULL;
- goto exit;
- }
- } else {
- evict = NULL;
- }
-
- group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
- op = ofoperation_create(group, rule, OFOPERATION_ADD, 0);
- op->victim = victim;
-
- error = ofproto->ofproto_class->rule_construct(rule);
- if (error) {
- op->group->n_running--;
- ofoperation_destroy(rule->pending);
- } else if (evict) {
- /* It would be better if we maintained the lock we took in
- * choose_rule_to_evict() earlier, but that confuses the thread
- * safety analysis, and this code is fragile enough that we really
- * need it. In the worst case, we'll have to block a little while
- * before we perform the eviction, which doesn't seem like a big
- * problem. */
- ovs_rwlock_wrlock(&evict->evict);
- delete_flow__(evict, group, OFPRR_EVICTION);
- }
- ofopgroup_submit(group);
- }
-
-exit:
- /* Back out if an error occurred. */
+ /* Construct rule, initializing derived state. */
+ error = ofproto->ofproto_class->rule_construct(rule);
if (error) {
- oftable_substitute_rule(rule, victim);
ofproto_rule_destroy__(rule);
+ return error;
}
+
+ /* Insert rule. */
+ oftable_insert_rule(rule);
+
+ group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
+ ofoperation_create(group, rule, OFOPERATION_ADD, 0);
+ ofproto->ofproto_class->rule_insert(rule);
+ ofopgroup_submit(group);
+
return error;
}
\f
struct ofputil_flow_mod *fm, const struct ofp_header *request,
struct list *rules)
{
+ enum ofoperation_type type;
struct ofopgroup *group;
struct rule *rule;
enum ofperr error;
+ type = fm->command == OFPFC_ADD ? OFOPERATION_REPLACE : OFOPERATION_MODIFY;
group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
error = OFPERR_OFPBRC_EPERM;
LIST_FOR_EACH (rule, ofproto_node, rules) {
struct ofoperation *op;
bool actions_changed;
+ bool reset_counters;
- /* FIXME: Implement OFPFF12_RESET_COUNTS */
+ /* FIXME: Implement OFPFUTIL_FF_RESET_COUNTS */
if (rule_is_modifiable(rule)) {
/* At least one rule is modifiable, don't report EPERM error. */
actions_changed = !ofpacts_equal(fm->ofpacts, fm->ofpacts_len,
rule->ofpacts, rule->ofpacts_len);
- op = ofoperation_create(group, rule, OFOPERATION_MODIFY, 0);
+ op = ofoperation_create(group, rule, type, 0);
if (fm->modify_cookie && fm->new_cookie != htonll(UINT64_MAX)) {
ofproto_rule_change_cookie(ofproto, rule, fm->new_cookie);
}
- if (actions_changed) {
+ if (type == OFOPERATION_REPLACE) {
+ ovs_mutex_lock(&rule->timeout_mutex);
+ rule->idle_timeout = fm->idle_timeout;
+ rule->hard_timeout = fm->hard_timeout;
+ ovs_mutex_unlock(&rule->timeout_mutex);
+
+ rule->send_flow_removed = (fm->flags
+ & OFPUTIL_FF_SEND_FLOW_REM) != 0;
+
+ if (fm->idle_timeout || fm->hard_timeout) {
+ if (!rule->eviction_group) {
+ eviction_group_add_rule(rule);
+ }
+ } else {
+ eviction_group_remove_rule(rule);
+ }
+ }
+
+ reset_counters = (fm->flags & OFPUTIL_FF_RESET_COUNTS) != 0;
+ if (actions_changed || reset_counters) {
op->ofpacts = rule->ofpacts;
op->ofpacts_len = rule->ofpacts_len;
op->meter_id = rule->meter_id;
rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len);
rule->ofpacts_len = fm->ofpacts_len;
rule->meter_id = find_meter(rule->ofpacts, rule->ofpacts_len);
- rule->ofproto->ofproto_class->rule_modify_actions(rule);
+ rule->ofproto->ofproto_class->rule_modify_actions(rule,
+ reset_counters);
} else {
ofoperation_complete(op, 0);
}
ofoperation_create(group, rule, OFOPERATION_DELETE, reason);
oftable_remove_rule(rule);
- ofproto->ofproto_class->rule_destruct(rule);
+ ofproto->ofproto_class->rule_delete(rule);
}
/* Deletes the rules listed in 'rules'.
ofproto_rule_expire(struct rule *rule, uint8_t reason)
{
struct ofproto *ofproto = rule->ofproto;
- struct ofopgroup *group;
+ struct classifier *cls = &ofproto->tables[rule->table_id].cls;
ovs_assert(reason == OFPRR_HARD_TIMEOUT || reason == OFPRR_IDLE_TIMEOUT);
-
ofproto_rule_send_removed(rule, reason);
- group = ofopgroup_create_unattached(ofproto);
- ofoperation_create(group, rule, OFOPERATION_DELETE, reason);
- oftable_remove_rule(rule);
- ofproto->ofproto_class->rule_destruct(rule);
- ofopgroup_submit(group);
+ ovs_rwlock_wrlock(&cls->rwlock);
+ ofproto_delete_rule(ofproto, cls, rule);
+ ovs_rwlock_unlock(&cls->rwlock);
+}
+
+/* Reduces '*timeout' to no more than 'max'. A value of zero in either case
+ * means "infinite". */
+static void
+reduce_timeout(uint16_t max, uint16_t *timeout)
+{
+ if (max && (!*timeout || *timeout > max)) {
+ *timeout = max;
+ }
+}
+
+/* If 'idle_timeout' is nonzero, and 'rule' has no idle timeout or an idle
+ * timeout greater than 'idle_timeout', lowers 'rule''s idle timeout to
+ * 'idle_timeout' seconds. Similarly for 'hard_timeout'.
+ *
+ * Suitable for implementing OFPACT_FIN_TIMEOUT. */
+void
+ofproto_rule_reduce_timeouts(struct rule *rule,
+ uint16_t idle_timeout, uint16_t hard_timeout)
+ OVS_EXCLUDED(rule->ofproto->expirable_mutex, rule->timeout_mutex)
+{
+ if (!idle_timeout && !hard_timeout) {
+ return;
+ }
+
+ ovs_mutex_lock(&rule->ofproto->expirable_mutex);
+ if (list_is_empty(&rule->expirable)) {
+ list_insert(&rule->ofproto->expirable, &rule->expirable);
+ }
+ ovs_mutex_unlock(&rule->ofproto->expirable_mutex);
+
+ ovs_mutex_lock(&rule->timeout_mutex);
+ reduce_timeout(idle_timeout, &rule->idle_timeout);
+ reduce_timeout(hard_timeout, &rule->hard_timeout);
+ ovs_mutex_unlock(&rule->timeout_mutex);
+
+ if (!rule->eviction_group) {
+ eviction_group_add_rule(rule);
+ }
}
\f
static enum ofperr
struct ofputil_flow_update fu;
struct match match;
- if (op && op->type == OFOPERATION_ADD && !op->victim) {
+ if (op && op->type == OFOPERATION_ADD) {
/* We'll report the final flow when the operation completes. Reporting
* it now would cause a duplicate report later. */
return;
* actions, so that when the operation commits we report the change. */
switch (op->type) {
case OFOPERATION_ADD:
- /* We already verified that there was a victim. */
- fu.ofpacts = op->victim->ofpacts;
- fu.ofpacts_len = op->victim->ofpacts_len;
- break;
+ NOT_REACHED();
case OFOPERATION_MODIFY:
+ case OFOPERATION_REPLACE:
if (op->ofpacts) {
fu.ofpacts = op->ofpacts;
fu.ofpacts_len = op->ofpacts_len;
&& rule->flow_cookie == op->flow_cookie))) {
/* Check that we can just cast from ofoperation_type to
* nx_flow_update_event. */
- BUILD_ASSERT_DECL((enum nx_flow_update_event) OFOPERATION_ADD
- == NXFME_ADDED);
- BUILD_ASSERT_DECL((enum nx_flow_update_event) OFOPERATION_DELETE
- == NXFME_DELETED);
- BUILD_ASSERT_DECL((enum nx_flow_update_event) OFOPERATION_MODIFY
- == NXFME_MODIFIED);
-
- ofmonitor_report(ofproto->connmgr, rule,
- (enum nx_flow_update_event) op->type,
+ enum nx_flow_update_event event_type;
+
+ switch (op->type) {
+ case OFOPERATION_ADD:
+ case OFOPERATION_REPLACE:
+ event_type = NXFME_ADDED;
+ break;
+
+ case OFOPERATION_DELETE:
+ event_type = NXFME_DELETED;
+ break;
+
+ case OFOPERATION_MODIFY:
+ event_type = NXFME_MODIFIED;
+ break;
+
+ default:
+ NOT_REACHED();
+ }
+
+ ofmonitor_report(ofproto->connmgr, rule, event_type,
op->reason, abbrev_ofconn, abbrev_xid);
}
if (!op->error) {
uint16_t vid_mask;
- ofproto_rule_destroy__(op->victim);
vid_mask = minimask_get_vid_mask(&rule->cr.match.mask);
if (vid_mask == VLAN_VID_MASK) {
if (ofproto->vlan_bitmap) {
}
}
} else {
- oftable_substitute_rule(rule, op->victim);
+ ovs_rwlock_wrlock(&rule->evict);
+ oftable_remove_rule(rule);
ofproto_rule_destroy__(rule);
}
break;
break;
case OFOPERATION_MODIFY:
+ case OFOPERATION_REPLACE:
if (!op->error) {
- rule->modified = time_msec();
+ long long int now = time_msec();
+
+ rule->modified = now;
+ if (op->type == OFOPERATION_REPLACE) {
+ rule->created = rule->used = now;
+ }
} else {
ofproto_rule_change_cookie(ofproto, rule, op->flow_cookie);
+ ovs_mutex_lock(&rule->timeout_mutex);
+ rule->idle_timeout = op->idle_timeout;
+ rule->hard_timeout = op->hard_timeout;
+ ovs_mutex_unlock(&rule->timeout_mutex);
if (op->ofpacts) {
free(rule->ofpacts);
rule->ofpacts = op->ofpacts;
op->ofpacts = NULL;
op->ofpacts_len = 0;
}
+ rule->send_flow_removed = op->send_flow_removed;
}
break;
op->type = type;
op->reason = reason;
op->flow_cookie = rule->flow_cookie;
+ ovs_mutex_lock(&rule->timeout_mutex);
+ op->idle_timeout = rule->idle_timeout;
+ op->hard_timeout = rule->hard_timeout;
+ ovs_mutex_unlock(&rule->timeout_mutex);
+ op->send_flow_removed = rule->send_flow_removed;
group->n_running++;
* indicate success or an OpenFlow error code on failure.
*
* If 'error' is 0, indicating success, the operation will be committed
- * permanently to the flow table. There is one interesting subcase:
- *
- * - If 'op' is an "add flow" operation that is replacing an existing rule in
- * the flow table (the "victim" rule) by a new one, then the caller must
- * have uninitialized any derived state in the victim rule, as in step 5 in
- * the "Life Cycle" in ofproto/ofproto-provider.h. ofoperation_complete()
- * performs steps 6 and 7 for the victim rule, most notably by calling its
- * ->rule_dealloc() function.
+ * permanently to the flow table.
*
* If 'error' is nonzero, then generally the operation will be rolled back:
*
ofopgroup_complete(group);
}
}
-
-struct rule *
-ofoperation_get_victim(struct ofoperation *op)
-{
- ovs_assert(op->type == OFOPERATION_ADD);
- return op->victim;
-}
\f
static uint64_t
pick_datapath_id(const struct ofproto *ofproto)
ofoperation_create(group, rule,
OFOPERATION_DELETE, OFPRR_EVICTION);
oftable_remove_rule(rule);
- ofproto->ofproto_class->rule_destruct(rule);
+ ofproto->ofproto_class->rule_delete(rule);
}
}
ofopgroup_submit(group);
ovs_rwlock_unlock(&table->cls.rwlock);
}
-/* Inserts 'rule' into its oftable. Removes any existing rule from 'rule''s
- * oftable that has an identical cls_rule. Returns the rule that was removed,
- * if any, and otherwise NULL. */
-static struct rule *
-oftable_replace_rule(struct rule *rule)
+/* Inserts 'rule' into its oftable, which must not already contain any rule for
+ * the same cls_rule. */
+static void
+oftable_insert_rule(struct rule *rule)
{
struct ofproto *ofproto = rule->ofproto;
struct oftable *table = &ofproto->tables[rule->table_id];
- struct rule *victim;
bool may_expire;
ovs_mutex_lock(&rule->timeout_mutex);
list_insert(&meter->rules, &rule->meter_list_node);
}
ovs_rwlock_wrlock(&table->cls.rwlock);
- victim = rule_from_cls_rule(classifier_replace(&table->cls, &rule->cr));
+ classifier_insert(&table->cls, &rule->cr);
ovs_rwlock_unlock(&table->cls.rwlock);
- if (victim) {
- if (victim->meter_id) {
- list_remove(&victim->meter_list_node);
- }
- cookies_remove(ofproto, victim);
-
- ovs_mutex_lock(&ofproto->expirable_mutex);
- if (!list_is_empty(&victim->expirable)) {
- list_remove(&victim->expirable);
- }
- ovs_mutex_unlock(&ofproto->expirable_mutex);
- eviction_group_remove_rule(victim);
- }
eviction_group_add_rule(rule);
- return victim;
-}
-
-/* Removes 'old' from its oftable then, if 'new' is nonnull, inserts 'new'. */
-static void
-oftable_substitute_rule(struct rule *old, struct rule *new)
-{
- if (new) {
- oftable_replace_rule(new);
- } else {
- ovs_rwlock_wrlock(&old->evict);
- oftable_remove_rule(old);
- }
}
\f
/* unixctl commands. */
/*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
if (++p->cookie >= COOKIE_MAX) {
p->cookie = 0;
}
- p->buffer = ofpbuf_clone_data_with_headroom(buffer, buffer_size,
- sizeof(struct ofp10_packet_in));
+ /* Use 2 bytes of headroom to 32-bit align the L3 header. */
+ p->buffer = ofpbuf_clone_data_with_headroom(buffer, buffer_size, 2);
p->timeout = time_msec() + OVERWRITE_MSECS;
p->in_port = in_port;
*
* 'in_port' may be NULL if the input port is not of interest.
*
- * A returned packet will have at least sizeof(struct ofp10_packet_in) bytes of
- * headroom.
+ * The L3 header of a returned packet will be 32-bit aligned.
*
* On failure, stores NULL in in '*bufferp' and UINT16_MAX in '*in_port'. */
enum ofperr
actions=learn(output:OXM_OF_IN_PORT[])
actions=learn(table=1, in_port=1, load:OXM_OF_IN_PORT[]->NXM_NX_REG1[], load:0xfffffffe->OXM_OF_IN_PORT[])
]])
-AT_CHECK([ovs-ofctl parse-flows flows.txt], [0],
+AT_CHECK([ovs-ofctl -O OpenFlow12 parse-flows flows.txt], [0],
[[usable protocols: any
-chosen protocol: OpenFlow10-table_id
-OFPT_FLOW_MOD (xid=0x1): ADD actions=learn(table=1,output:OXM_OF_IN_PORT[])
-OFPT_FLOW_MOD (xid=0x2): ADD actions=learn(table=1,in_port=1,load:OXM_OF_IN_PORT[]->NXM_NX_REG1[],load:0xfffffffe->OXM_OF_IN_PORT[])
+chosen protocol: OXM-OpenFlow12
+OFPT_FLOW_MOD (OF1.2) (xid=0x1): ADD table:255 actions=learn(table=1,output:OXM_OF_IN_PORT[])
+OFPT_FLOW_MOD (OF1.2) (xid=0x2): ADD table:255 actions=learn(table=1,in_port=1,load:OXM_OF_IN_PORT[]->NXM_NX_REG1[],load:0xfffffffe->OXM_OF_IN_PORT[])
]])
AT_CLEANUP
cookie=0x7 table=5 in_port=84 actions=load:5->NXM_NX_REG4[[]],load:6->NXM_NX_TUN_ID[[]],mod_nw_dst:84.84.84.84,controller,resubmit(85,6)
cookie=0x8 table=6 in_port=85 actions=mod_tp_src:85,controller,resubmit(86,7)
cookie=0x9 table=7 in_port=86 actions=mod_tp_dst:86,controller,controller
-cookie=0xa dl_src=40:44:44:44:44:41 actions=push_vlan:0x8100,mod_vlan_vid:99,mod_vlan_pcp:1,controller
+cookie=0xa dl_src=40:44:44:44:44:41 actions=mod_vlan_vid:99,mod_vlan_pcp:1,controller
cookie=0xa dl_src=40:44:44:44:44:42 actions=push_mpls:0x8847,load:10->OXM_OF_MPLS_LABEL[[]],load:3->OXM_OF_MPLS_TC[[]],controller
cookie=0xa dl_src=40:44:44:44:44:43 actions=push_mpls:0x8847,load:10->OXM_OF_MPLS_LABEL[[]],load:3->OXM_OF_MPLS_TC[[]],controller
cookie=0xa dl_src=40:44:44:44:44:44 actions=push_mpls:0x8847,load:10->OXM_OF_MPLS_LABEL[[]],load:3->OXM_OF_MPLS_TC[[]],controller
'tun_flags=0 none' \
'tun_tos=0 none' \
'tun_ttl=0 none' \
- 'metadata=0 NXM,OXM' \
+ 'metadata=0 NXM,OXM,OpenFlow11' \
'in_port=1 any' \
'skb_priority=0 none' \
'pkt_mark=1 NXM,OXM' \
'reg6=6 NXM,OXM' \
'reg7=7 NXM,OXM' \
'dl_src=00:11:22:33:44:55 any' \
- 'dl_src=00:11:22:33:44:55/00:ff:ff:ff:ff:ff NXM,OXM' \
+ 'dl_src=00:11:22:33:44:55/00:ff:ff:ff:ff:ff NXM,OXM,OpenFlow11' \
'dl_dst=00:11:22:33:44:55 any' \
- 'dl_dst=00:11:22:33:44:55/00:ff:ff:ff:ff:ff NXM,OXM' \
+ 'dl_dst=00:11:22:33:44:55/00:ff:ff:ff:ff:ff NXM,OXM,OpenFlow11' \
'dl_type=0x1234 any' \
'dl_type=0x0800 any' \
'dl_type=0x0806 any' \
'vlan_vid=11 any' \
'dl_vlan_pcp=6 any' \
'vlan_pcp=5 any' \
- 'mpls,mpls_label=5 NXM,OXM' \
- 'mpls,mpls_tc=1 NXM,OXM' \
+ 'mpls,mpls_label=5 NXM,OXM,OpenFlow11' \
+ 'mpls,mpls_tc=1 NXM,OXM,OpenFlow11' \
'mpls,mpls_bos=0 NXM,OXM' \
'ip,ip_src=1.2.3.4 any' \
'ip,ip_src=192.168.0.0/24 any' \
- 'ip,ip_src=192.0.168.0/255.0.255.0 NXM,OXM' \
+ 'ip,ip_src=192.0.168.0/255.0.255.0 NXM,OXM,OpenFlow11' \
'ip,ip_dst=1.2.3.4 any' \
'ip,ip_dst=192.168.0.0/24 any' \
- 'ip,ip_dst=192.0.168.0/255.0.255.0 NXM,OXM' \
+ 'ip,ip_dst=192.0.168.0/255.0.255.0 NXM,OXM,OpenFlow11' \
'ipv6,ipv6_src=::1 NXM,OXM' \
'ipv6,ipv6_dst=::1 NXM,OXM' \
'ipv6,ipv6_label=5 NXM,OXM' \
cookie=0x123456789abcdef hard_timeout=10 priority=60000 actions=controller
actions=note:41.42.43,note:00.01.02.03.04.05.06.07,note
ip,actions=set_field:10.4.3.77->ip_src
-sctp actions=set_field:3334->sctp_src
-sctp actions=set_field:4445->sctp_dst
+sctp actions=drop
+sctp actions=drop
in_port=0 actions=resubmit:0
actions=sample(probability=12345,collector_set_id=23456,obs_domain_id=34567,obs_point_id=45678)
]])
OFPT_FLOW_MOD: ADD priority=60000 cookie:0x123456789abcdef hard:10 actions=CONTROLLER:65535
OFPT_FLOW_MOD: ADD actions=note:41.42.43.00.00.00,note:00.01.02.03.04.05.06.07.00.00.00.00.00.00,note:00.00.00.00.00.00
OFPT_FLOW_MOD: ADD ip actions=load:0xa04034d->NXM_OF_IP_SRC[]
-OFPT_FLOW_MOD: ADD sctp actions=load:0xd06->OXM_OF_SCTP_SRC[]
-OFPT_FLOW_MOD: ADD sctp actions=load:0x115d->OXM_OF_SCTP_DST[]
+OFPT_FLOW_MOD: ADD sctp actions=drop
+OFPT_FLOW_MOD: ADD sctp actions=drop
OFPT_FLOW_MOD: ADD in_port=0 actions=resubmit:0
OFPT_FLOW_MOD: ADD actions=sample(probability=12345,collector_set_id=23456,obs_domain_id=34567,obs_point_id=45678)
]])
AT_CHECK([ovs-ofctl --protocols OpenFlow12 parse-flows flows.txt
], [0], [stdout])
AT_CHECK([[sed 's/ (xid=0x[0-9a-fA-F]*)//' stdout]], [0],
-[[usable protocols: any
+[[usable protocols: NXM,OXM
chosen protocol: OXM-OpenFlow12
OFPT_FLOW_MOD (OF1.2): ADD table:255 tcp,tp_src=123 actions=FLOOD
OFPT_FLOW_MOD (OF1.2): ADD table:255 in_port=LOCAL,dl_vlan=9,dl_src=00:0a:e4:25:6b:b0 actions=drop
[1], [], [ovs-ofctl: none of the usable flow formats (NXM,OXM) is among the allowed flow formats (OpenFlow10)
])
AT_CHECK([ovs-ofctl -F openflow10 add-flow dummy metadata=123,actions=drop],
- [1], [], [ovs-ofctl: none of the usable flow formats (NXM,OXM) is among the allowed flow formats (OpenFlow10)
+ [1], [], [ovs-ofctl: none of the usable flow formats (NXM,OXM,OpenFlow11) is among the allowed flow formats (OpenFlow10)
])
AT_CLEANUP
/* --with-flows: Flows to send to switch. */
static struct ofputil_flow_mod *default_flows;
static size_t n_default_flows;
+static enum ofputil_protocol usable_protocols;
/* --unixctl: Name of unixctl socket, or null to use the default. */
static char *unixctl_path = NULL;
cfg.max_idle = set_up_flows ? max_idle : -1;
cfg.default_flows = default_flows;
cfg.n_default_flows = n_default_flows;
+ cfg.usable_protocols = usable_protocols;
cfg.default_queue = default_queue;
cfg.port_queues = &port_queues;
cfg.mute = mute;
case OPT_WITH_FLOWS:
error = parse_ofp_flow_mod_file(optarg, OFPFC_ADD, &default_flows,
- &n_default_flows);
+ &n_default_flows,
+ &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
char *error;
error = parse_ofp_flow_stats_request_str(&fsr, aggregate,
- argc > 2 ? argv[2] : "");
+ argc > 2 ? argv[2] : "",
+ &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
- usable_protocols = ofputil_flow_stats_request_usable_protocols(&fsr);
-
protocol = open_vconn(argv[1], &vconn);
protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols);
*requestp = ofputil_encode_flow_stats_request(&fsr, protocol);
}
static enum ofputil_protocol
-open_vconn_for_flow_mod(const char *remote,
- const struct ofputil_flow_mod *fms, size_t n_fms,
- struct vconn **vconnp)
+open_vconn_for_flow_mod(const char *remote, struct vconn **vconnp,
+ enum ofputil_protocol usable_protocols)
{
- enum ofputil_protocol usable_protocols;
enum ofputil_protocol cur_protocol;
char *usable_s;
int i;
- /* Figure out what flow formats will work. */
- usable_protocols = ofputil_flow_mod_usable_protocols(fms, n_fms);
if (!(usable_protocols & allowed_protocols)) {
char *allowed_s = ofputil_protocols_to_string(allowed_protocols);
usable_s = ofputil_protocols_to_string(usable_protocols);
static void
ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms,
- size_t n_fms)
+ size_t n_fms, enum ofputil_protocol usable_protocols)
{
enum ofputil_protocol protocol;
struct vconn *vconn;
size_t i;
- protocol = open_vconn_for_flow_mod(remote, fms, n_fms, &vconn);
+ protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols);
for (i = 0; i < n_fms; i++) {
struct ofputil_flow_mod *fm = &fms[i];
static void
ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], uint16_t command)
{
+ enum ofputil_protocol usable_protocols;
struct ofputil_flow_mod *fms = NULL;
size_t n_fms = 0;
char *error;
- error = parse_ofp_flow_mod_file(argv[2], command, &fms, &n_fms);
+ error = parse_ofp_flow_mod_file(argv[2], command, &fms, &n_fms,
+ &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
- ofctl_flow_mod__(argv[1], fms, n_fms);
+ ofctl_flow_mod__(argv[1], fms, n_fms, usable_protocols);
free(fms);
}
static void
ofctl_flow_mod(int argc, char *argv[], uint16_t command)
{
+ enum ofputil_protocol usable_protocols;
+
if (argc > 2 && !strcmp(argv[2], "-")) {
ofctl_flow_mod_file(argc, argv, command);
} else {
struct ofputil_flow_mod fm;
char *error;
- error = parse_ofp_flow_mod_str(&fm, argc > 2 ? argv[2] : "", command);
+ error = parse_ofp_flow_mod_str(&fm, argc > 2 ? argv[2] : "", command,
+ &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
- ofctl_flow_mod__(argv[1], &fm, 1);
+ ofctl_flow_mod__(argv[1], &fm, 1, usable_protocols);
}
}
{
struct vconn *vconn;
int i;
+ enum ofputil_protocol usable_protocols;
open_vconn(argv[1], &vconn);
for (i = 2; i < argc; i++) {
struct ofpbuf *msg;
char *error;
- error = parse_flow_monitor_request(&fmr, arg + 6);
+ error = parse_flow_monitor_request(&fmr, arg + 6,
+ &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
struct vconn *vconn;
char *error;
int i;
+ enum ofputil_protocol usable_protocols; /* TODO: Use in proto selection */
ofpbuf_init(&ofpacts, 64);
- error = parse_ofpacts(argv[3], &ofpacts);
+ error = parse_ofpacts(argv[3], &ofpacts, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
struct fte_version *version;
struct ofputil_flow_mod fm;
char *error;
+ enum ofputil_protocol usable;
- error = parse_ofp_str(&fm, OFPFC_ADD, ds_cstr(&s));
+ error = parse_ofp_str(&fm, OFPFC_ADD, ds_cstr(&s), &usable);
if (error) {
ovs_fatal(0, "%s:%d: %s", filename, line_number, error);
}
+ usable_protocols &= usable;
version = xmalloc(sizeof *version);
version->cookie = fm.new_cookie;
version->idle_timeout = fm.idle_timeout;
version->hard_timeout = fm.hard_timeout;
- version->flags = fm.flags & (OFPFF_SEND_FLOW_REM | OFPFF10_EMERG);
+ version->flags = fm.flags & (OFPUTIL_FF_SEND_FLOW_REM
+ | OFPUTIL_FF_EMERG);
version->ofpacts = fm.ofpacts;
version->ofpacts_len = fm.ofpacts_len;
- usable_protocols &= ofputil_usable_protocols(&fm.match);
-
fte_insert(cls, &fm.match, fm.priority, version, index);
}
ds_destroy(&s);
/* Undocumented commands for unit testing. */
static void
-ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms)
+ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms,
+ enum ofputil_protocol usable_protocols)
{
- enum ofputil_protocol usable_protocols;
enum ofputil_protocol protocol = 0;
char *usable_s;
size_t i;
- usable_protocols = ofputil_flow_mod_usable_protocols(fms, n_fms);
usable_s = ofputil_protocols_to_string(usable_protocols);
printf("usable protocols: %s\n", usable_s);
free(usable_s);
static void
ofctl_parse_flow(int argc OVS_UNUSED, char *argv[])
{
+ enum ofputil_protocol usable_protocols;
struct ofputil_flow_mod fm;
char *error;
- error = parse_ofp_flow_mod_str(&fm, argv[1], OFPFC_ADD);
+ error = parse_ofp_flow_mod_str(&fm, argv[1], OFPFC_ADD, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
- ofctl_parse_flows__(&fm, 1);
+ ofctl_parse_flows__(&fm, 1, usable_protocols);
}
/* "parse-flows FILENAME": reads the named file as a sequence of flows (like
static void
ofctl_parse_flows(int argc OVS_UNUSED, char *argv[])
{
+ enum ofputil_protocol usable_protocols;
struct ofputil_flow_mod *fms = NULL;
size_t n_fms = 0;
char *error;
- error = parse_ofp_flow_mod_file(argv[1], OFPFC_ADD, &fms, &n_fms);
+ error = parse_ofp_flow_mod_file(argv[1], OFPFC_ADD, &fms, &n_fms,
+ &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
- ofctl_parse_flows__(fms, n_fms);
+ ofctl_parse_flows__(fms, n_fms, usable_protocols);
free(fms);
}
enum ofperr error;
char *error_s;
+ enum ofputil_protocol usable_protocols; /* Unused for now. */
+
match_init_catchall(&match);
match.flow.vlan_tci = htons(strtoul(argv[1], NULL, 16));
match.wc.masks.vlan_tci = htons(strtoul(argv[2], NULL, 16));
string_s = match_to_string(&match, OFP_DEFAULT_PRIORITY);
printf("%s -> ", string_s);
fflush(stdout);
- error_s = parse_ofp_str(&fm, -1, string_s);
+ error_s = parse_ofp_str(&fm, -1, string_s, &usable_protocols);
if (error_s) {
ovs_fatal(0, "%s", error_s);
}
EOF
}
-PATH=/sbin:/bin:/usr/sbin:/usr/bin
-
-missing_program () {
- save_IFS=$IFS
- IFS=:
- for dir in $PATH; do
- IFS=$save_IFS
- if test -x $dir/$1; then
- return 1
- fi
- done
- IFS=$save_IFS
- return 0
-}
-
save_interfaces () {
- if missing_program ip; then
+ if (ip -V) > /dev/null 2>&1; then :; else
echo "$0: ip not found in $PATH" >&2
exit 1
fi
echo
done
- if missing_program iptables-save; then
- echo "# iptables-save not found in $PATH, not saving iptables state"
- else
+ if (iptables-save) > /dev/null 2>&1; then
echo "# global"
echo "iptables-restore <<'EOF'"
iptables-save
echo "EOF"
+ else
+ echo "# iptables-save not found in $PATH, not saving iptables state"
fi
}
save_flows () {
- if missing_program ovs-ofctl; then
+ if (ovs-ofctl --version) > /dev/null 2>&1; then :; else
echo "$0: ovs-ofctl not found in $PATH" >&2
exit 1
fi
save_ofports ()
{
- if missing_program ovs-vsctl; then
+ if (ovs-vsctl --version) > /dev/null 2>&1; then :; else
echo "$0: ovs-vsctl not found in $PATH" >&2
exit 1
fi
};
static void
-qos_unixctl_show_cb(unsigned int queue_id,
- const struct smap *details,
- void *aux)
+qos_unixctl_show_queue(unsigned int queue_id,
+ const struct smap *details,
+ struct iface *iface,
+ struct ds *ds)
{
- struct qos_unixctl_show_cbdata *data = aux;
- struct ds *ds = data->ds;
- struct iface *iface = data->iface;
struct netdev_queue_stats stats;
struct smap_node *node;
int error;
struct iface *iface;
const char *type;
struct smap_node *node;
- struct qos_unixctl_show_cbdata data;
- int error;
iface = iface_find(argv[1]);
if (!iface) {
netdev_get_qos(iface->netdev, &type, &smap);
if (*type != '\0') {
+ struct netdev_queue_dump dump;
+ struct smap details;
+ unsigned int queue_id;
+
ds_put_format(&ds, "QoS: %s %s\n", iface->name, type);
SMAP_FOR_EACH (node, &smap) {
ds_put_format(&ds, "%s: %s\n", node->key, node->value);
}
- data.ds = &ds;
- data.iface = iface;
- error = netdev_dump_queues(iface->netdev, qos_unixctl_show_cb, &data);
-
- if (error) {
- ds_put_format(&ds, "failed to dump queues: %s",
- ovs_strerror(error));
+ smap_init(&details);
+ NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) {
+ qos_unixctl_show_queue(queue_id, &details, iface, &ds);
}
+ smap_destroy(&details);
+
unixctl_command_reply(conn, ds_cstr(&ds));
} else {
ds_put_format(&ds, "QoS not configured on %s\n", iface->name);
}
}
-struct iface_delete_queues_cbdata {
- struct netdev *netdev;
- const struct ovsdb_datum *queues;
-};
-
static bool
queue_ids_include(const struct ovsdb_datum *queues, int64_t target)
{
return ovsdb_datum_find_key(queues, &atom, OVSDB_TYPE_INTEGER) != UINT_MAX;
}
-static void
-iface_delete_queues(unsigned int queue_id,
- const struct smap *details OVS_UNUSED, void *cbdata_)
-{
- struct iface_delete_queues_cbdata *cbdata = cbdata_;
-
- if (!queue_ids_include(cbdata->queues, queue_id)) {
- netdev_delete_queue(cbdata->netdev, queue_id);
- }
-}
-
static void
iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos)
{
if (!qos || qos->type[0] == '\0' || qos->n_queues < 1) {
netdev_set_qos(iface->netdev, NULL, NULL);
} else {
- struct iface_delete_queues_cbdata cbdata;
+ const struct ovsdb_datum *queues;
+ struct netdev_queue_dump dump;
+ unsigned int queue_id;
+ struct smap details;
bool queue_zero;
size_t i;
netdev_set_qos(iface->netdev, qos->type, &qos->other_config);
/* Deconfigure queues that were deleted. */
- cbdata.netdev = iface->netdev;
- cbdata.queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER,
- OVSDB_TYPE_UUID);
- netdev_dump_queues(iface->netdev, iface_delete_queues, &cbdata);
+ queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER,
+ OVSDB_TYPE_UUID);
+ smap_init(&details);
+ NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &dump, iface->netdev) {
+ if (!queue_ids_include(queues, queue_id)) {
+ netdev_delete_queue(iface->netdev, queue_id);
+ }
+ }
+ smap_destroy(&details);
/* Configure queues for 'iface'. */
queue_zero = false;
git://git.onelab.eu / sliver-openvswitch.git / commitdiff