/*
- * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
case OVS_ACTION_ATTR_POP_VLAN: return 0;
case OVS_ACTION_ATTR_PUSH_MPLS: return sizeof(struct ovs_action_push_mpls);
case OVS_ACTION_ATTR_POP_MPLS: return sizeof(ovs_be16);
+ case OVS_ACTION_ATTR_RECIRC: return sizeof(uint32_t);
+ case OVS_ACTION_ATTR_HASH: return sizeof(struct ovs_action_hash);
case OVS_ACTION_ATTR_SET: return -2;
case OVS_ACTION_ATTR_SAMPLE: return -2;
case OVS_KEY_ATTR_ARP: return "arp";
case OVS_KEY_ATTR_ND: return "nd";
case OVS_KEY_ATTR_MPLS: return "mpls";
+ case OVS_KEY_ATTR_DP_HASH: return "dp_hash";
+ case OVS_KEY_ATTR_RECIRC_ID: return "recirc_id";
case __OVS_KEY_ATTR_MAX:
default:
format_odp_sample_action(struct ds *ds, const struct nlattr *attr)
{
static const struct nl_policy ovs_sample_policy[] = {
- { NL_A_NO_ATTR, 0, 0, false }, /* OVS_SAMPLE_ATTR_UNSPEC */
- { NL_A_U32, 0, 0, false }, /* OVS_SAMPLE_ATTR_PROBABILITY */
- { NL_A_NESTED, 0, 0, false }, /* OVS_SAMPLE_ATTR_ACTIONS */
+ [OVS_SAMPLE_ATTR_PROBABILITY] = { .type = NL_A_U32 },
+ [OVS_SAMPLE_ATTR_ACTIONS] = { .type = NL_A_NESTED }
};
struct nlattr *a[ARRAY_SIZE(ovs_sample_policy)];
double percentage;
format_odp_userspace_action(struct ds *ds, const struct nlattr *attr)
{
static const struct nl_policy ovs_userspace_policy[] = {
- { NL_A_NO_ATTR, 0, 0, false }, /* OVS_USERSPACE_ATTR_UNSPEC */
- { NL_A_U32, 0, 0, false }, /* OVS_USERSPACE_ATTR_PID */
- { NL_A_UNSPEC, 0, 0, true }, /* OVS_USERSPACE_ATTR_USERDATA */
+ [OVS_USERSPACE_ATTR_PID] = { .type = NL_A_U32 },
+ [OVS_USERSPACE_ATTR_USERDATA] = { .type = NL_A_UNSPEC,
+ .optional = true },
};
struct nlattr *a[ARRAY_SIZE(ovs_userspace_policy)];
const struct nlattr *userdata_attr;
static void
format_mpls(struct ds *ds, const struct ovs_key_mpls *mpls_key,
- const struct ovs_key_mpls *mpls_mask)
+ const struct ovs_key_mpls *mpls_mask, int n)
{
- ovs_be32 key = mpls_key->mpls_lse;
+ if (n == 1) {
+ ovs_be32 key = mpls_key->mpls_lse;
- if (mpls_mask == NULL) {
- format_mpls_lse(ds, key);
+ if (mpls_mask == NULL) {
+ format_mpls_lse(ds, key);
+ } else {
+ ovs_be32 mask = mpls_mask->mpls_lse;
+
+ ds_put_format(ds, "label=%"PRIu32"/0x%x,tc=%d/%x,ttl=%d/0x%x,bos=%d/%x",
+ mpls_lse_to_label(key), mpls_lse_to_label(mask),
+ mpls_lse_to_tc(key), mpls_lse_to_tc(mask),
+ mpls_lse_to_ttl(key), mpls_lse_to_ttl(mask),
+ mpls_lse_to_bos(key), mpls_lse_to_bos(mask));
+ }
} else {
- ovs_be32 mask = mpls_mask->mpls_lse;
+ int i;
+
+ for (i = 0; i < n; i++) {
+ ds_put_format(ds, "lse%d=%#"PRIx32,
+ i, ntohl(mpls_key[i].mpls_lse));
+ if (mpls_mask) {
+ ds_put_format(ds, "/%#"PRIx32, ntohl(mpls_mask[i].mpls_lse));
+ }
+ ds_put_char(ds, ',');
+ }
+ ds_chomp(ds, ',');
+ }
+}
- ds_put_format(ds, "label=%"PRIu32"/0x%x,tc=%d/%x,ttl=%d/0x%x,bos=%d/%x",
- mpls_lse_to_label(key), mpls_lse_to_label(mask),
- mpls_lse_to_tc(key), mpls_lse_to_tc(mask),
- mpls_lse_to_ttl(key), mpls_lse_to_ttl(mask),
- mpls_lse_to_bos(key), mpls_lse_to_bos(mask));
+static void
+format_odp_recirc_action(struct ds *ds, uint32_t recirc_id)
+{
+ ds_put_format(ds, "recirc(%"PRIu32")", recirc_id);
+}
+
+static void
+format_odp_hash_action(struct ds *ds, const struct ovs_action_hash *hash_act)
+{
+ ds_put_format(ds, "hash(");
+
+ if (hash_act->hash_alg == OVS_HASH_ALG_L4) {
+ ds_put_format(ds, "hash_l4(%"PRIu32")", hash_act->hash_basis);
+ } else {
+ ds_put_format(ds, "Unknown hash algorithm(%"PRIu32")",
+ hash_act->hash_alg);
}
+ ds_put_format(ds, ")");
}
static void
case OVS_ACTION_ATTR_USERSPACE:
format_odp_userspace_action(ds, a);
break;
+ case OVS_ACTION_ATTR_RECIRC:
+ format_odp_recirc_action(ds, nl_attr_get_u32(a));
+ break;
+ case OVS_ACTION_ATTR_HASH:
+ format_odp_hash_action(ds, nl_attr_get(a));
+ break;
case OVS_ACTION_ATTR_SET:
ds_put_cstr(ds, "set(");
format_odp_key_attr(nl_attr_get(a), NULL, NULL, ds, true);
ofpbuf_init(&buf, 16);
end = ofpbuf_put_hex(&buf, &s[n], NULL);
if (end[0] == ')' && end[1] == ')') {
- odp_put_userspace_action(pid, buf.data, buf.size, actions);
+ odp_put_userspace_action(pid, ofpbuf_data(&buf), ofpbuf_size(&buf), actions);
ofpbuf_uninit(&buf);
return (end + 2) - s;
}
return 0;
}
- old_size = actions->size;
+ old_size = ofpbuf_size(actions);
for (;;) {
int retval;
retval = parse_odp_action(s, port_names, actions);
if (retval < 0 || !strchr(delimiters, s[retval])) {
- actions->size = old_size;
+ ofpbuf_set_size(actions, old_size);
return -retval;
}
s += retval;
case OVS_KEY_ATTR_ENCAP: return -2;
case OVS_KEY_ATTR_PRIORITY: return 4;
case OVS_KEY_ATTR_SKB_MARK: return 4;
+ case OVS_KEY_ATTR_DP_HASH: return 4;
+ case OVS_KEY_ATTR_RECIRC_ID: return 4;
case OVS_KEY_ATTR_TUNNEL: return -2;
case OVS_KEY_ATTR_IN_PORT: return 4;
case OVS_KEY_ATTR_ETHERNET: return sizeof(struct ovs_key_ethernet);
case OVS_KEY_ATTR_VLAN: return sizeof(ovs_be16);
case OVS_KEY_ATTR_ETHERTYPE: return 2;
- case OVS_KEY_ATTR_MPLS: return sizeof(struct ovs_key_mpls);
+ case OVS_KEY_ATTR_MPLS: return -2;
case OVS_KEY_ATTR_IPV4: return sizeof(struct ovs_key_ipv4);
case OVS_KEY_ATTR_IPV6: return sizeof(struct ovs_key_ipv6);
case OVS_KEY_ATTR_TCP: return sizeof(struct ovs_key_tcp);
tun_key_ofs = nl_msg_start_nested(a, OVS_KEY_ATTR_TUNNEL);
- if (tun_key->flags & FLOW_TNL_F_KEY) {
+ /* tun_id != 0 without FLOW_TNL_F_KEY is valid if tun_key is a mask. */
+ if (tun_key->tun_id || tun_key->flags & FLOW_TNL_F_KEY) {
nl_msg_put_be64(a, OVS_TUNNEL_KEY_ATTR_ID, tun_key->tun_id);
}
if (tun_key->ip_src) {
expected_len = odp_flow_key_attr_len(nl_attr_type(a));
if (expected_len != -2) {
bool bad_key_len = nl_attr_get_size(a) != expected_len;
- bool bad_mask_len = ma && nl_attr_get_size(a) != expected_len;
+ bool bad_mask_len = ma && nl_attr_get_size(ma) != expected_len;
if (bad_key_len || bad_mask_len) {
if (bad_key_len) {
ds_put_format(ds, "(bad key length %"PRIuSIZE", expected %d)(",
- nl_attr_get_size(a),
- odp_flow_key_attr_len(nl_attr_type(a)));
+ nl_attr_get_size(a), expected_len);
}
format_generic_odp_key(a, ds);
- if (bad_mask_len) {
+ if (ma) {
ds_put_char(ds, '/');
- ds_put_format(ds, "(bad mask length %"PRIuSIZE", expected %d)(",
- nl_attr_get_size(ma),
- odp_flow_key_attr_len(nl_attr_type(ma)));
+ if (bad_mask_len) {
+ ds_put_format(ds, "(bad mask length %"PRIuSIZE", expected %d)(",
+ nl_attr_get_size(ma), expected_len);
+ }
+ format_generic_odp_key(ma, ds);
}
- format_generic_odp_key(ma, ds);
ds_put_char(ds, ')');
return;
}
case OVS_KEY_ATTR_PRIORITY:
case OVS_KEY_ATTR_SKB_MARK:
+ case OVS_KEY_ATTR_DP_HASH:
+ case OVS_KEY_ATTR_RECIRC_ID:
ds_put_format(ds, "%#"PRIx32, nl_attr_get_u32(a));
if (!is_exact) {
ds_put_format(ds, "/%#"PRIx32, nl_attr_get_u32(ma));
case OVS_KEY_ATTR_MPLS: {
const struct ovs_key_mpls *mpls_key = nl_attr_get(a);
const struct ovs_key_mpls *mpls_mask = NULL;
+ size_t size = nl_attr_get_size(a);
+
+ if (!size || size % sizeof *mpls_key) {
+ ds_put_format(ds, "(bad key length %"PRIuSIZE")",
+ nl_attr_get_size(a));
+ return;
+ }
if (!is_exact) {
mpls_mask = nl_attr_get(ma);
+ if (nl_attr_get_size(a) != nl_attr_get_size(ma)) {
+ ds_put_format(ds, "(key length %"PRIuSIZE" != "
+ "mask length %"PRIuSIZE")",
+ nl_attr_get_size(a), nl_attr_get_size(ma));
+ return;
+ }
}
- format_mpls(ds, mpls_key, mpls_mask);
+ format_mpls(ds, mpls_key, mpls_mask, size / sizeof *mpls_key);
break;
}
} else {
const struct ovs_key_sctp *sctp_key = nl_attr_get(a);
- ds_put_format(ds, "(src=%"PRIu16",dst=%"PRIu16")",
+ ds_put_format(ds, "src=%"PRIu16",dst=%"PRIu16,
ntohs(sctp_key->sctp_src), ntohs(sctp_key->sctp_dst));
}
break;
}
break;
}
-
case OVS_KEY_ATTR_UNSPEC:
case __OVS_KEY_ATTR_MAX:
default:
nl_msg_end_nested(ofp, nested_mask);
}
- return ofp->base;
+ return ofpbuf_base(ofp);
}
/* Appends to 'ds' a string representation of the 'key_len' bytes of
}
}
+ {
+ uint32_t recirc_id;
+ int n = -1;
+
+ if (ovs_scan(s, "recirc_id(%"SCNi32")%n", &recirc_id, &n)) {
+ nl_msg_put_u32(key, OVS_KEY_ATTR_RECIRC_ID, recirc_id);
+ nl_msg_put_u32(mask, OVS_KEY_ATTR_RECIRC_ID, UINT32_MAX);
+ return n;
+ }
+ }
+
+ {
+ uint32_t dp_hash;
+ uint32_t dp_hash_mask;
+ int n = -1;
+
+ if (mask && ovs_scan(s, "dp_hash(%"SCNi32"/%"SCNi32")%n", &dp_hash,
+ &dp_hash_mask, &n)) {
+ nl_msg_put_u32(key, OVS_KEY_ATTR_DP_HASH, dp_hash);
+ nl_msg_put_u32(mask, OVS_KEY_ATTR_DP_HASH, dp_hash_mask);
+ return n;
+ } else if (ovs_scan(s, "dp_hash(%"SCNi32")%n", &dp_hash, &n)) {
+ nl_msg_put_u32(key, OVS_KEY_ATTR_DP_HASH, dp_hash);
+ if (mask) {
+ nl_msg_put_u32(mask, OVS_KEY_ATTR_DP_HASH, UINT32_MAX);
+ }
+ return n;
+ }
+ }
+
{
uint64_t tun_id, tun_id_mask;
struct flow_tnl tun_key, tun_key_mask;
odp_flow_from_string(const char *s, const struct simap *port_names,
struct ofpbuf *key, struct ofpbuf *mask)
{
- const size_t old_size = key->size;
+ const size_t old_size = ofpbuf_size(key);
for (;;) {
int retval;
retval = parse_odp_key_mask_attr(s, port_names, key, mask);
if (retval < 0) {
- key->size = old_size;
+ ofpbuf_set_size(key, old_size);
return -retval;
}
s += retval;
}
static void
-odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data,
- const struct flow *flow, odp_port_t odp_in_port)
+odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *flow,
+ const struct flow *mask, odp_port_t odp_in_port,
+ size_t max_mpls_depth, bool export_mask)
{
- bool is_mask;
struct ovs_key_ethernet *eth_key;
size_t encap;
-
- /* We assume that if 'data' and 'flow' are not the same, we should
- * treat 'data' as a mask. */
- is_mask = (data != flow);
+ const struct flow *data = export_mask ? mask : flow;
nl_msg_put_u32(buf, OVS_KEY_ATTR_PRIORITY, data->skb_priority);
- if (flow->tunnel.ip_dst || is_mask) {
+ if (flow->tunnel.ip_dst || export_mask) {
tun_key_to_attr(buf, &data->tunnel);
}
nl_msg_put_u32(buf, OVS_KEY_ATTR_SKB_MARK, data->pkt_mark);
+ if (data->recirc_id || (mask && mask->recirc_id)) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_RECIRC_ID, data->recirc_id);
+ }
+
+ if (data->dp_hash || (mask && mask->dp_hash)) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_DP_HASH, data->dp_hash);
+ }
+
/* Add an ingress port attribute if this is a mask or 'odp_in_port'
* is not the magical value "ODPP_NONE". */
- if (is_mask || odp_in_port != ODPP_NONE) {
+ if (export_mask || odp_in_port != ODPP_NONE) {
nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, odp_in_port);
}
memcpy(eth_key->eth_dst, data->dl_dst, ETH_ADDR_LEN);
if (flow->vlan_tci != htons(0) || flow->dl_type == htons(ETH_TYPE_VLAN)) {
- if (is_mask) {
+ if (export_mask) {
nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, OVS_BE16_MAX);
} else {
nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, htons(ETH_TYPE_VLAN));
* <none> 0xffff Any non-Ethernet II frame (except valid
* 802.3 SNAP packet with valid eth_type).
*/
- if (is_mask) {
+ if (export_mask) {
nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, OVS_BE16_MAX);
}
goto unencap;
ipv4_key->ipv4_proto = data->nw_proto;
ipv4_key->ipv4_tos = data->nw_tos;
ipv4_key->ipv4_ttl = data->nw_ttl;
- ipv4_key->ipv4_frag = is_mask ? ovs_to_odp_frag_mask(data->nw_frag)
+ ipv4_key->ipv4_frag = export_mask ? ovs_to_odp_frag_mask(data->nw_frag)
: ovs_to_odp_frag(data->nw_frag);
} else if (flow->dl_type == htons(ETH_TYPE_IPV6)) {
struct ovs_key_ipv6 *ipv6_key;
ipv6_key->ipv6_proto = data->nw_proto;
ipv6_key->ipv6_tclass = data->nw_tos;
ipv6_key->ipv6_hlimit = data->nw_ttl;
- ipv6_key->ipv6_frag = is_mask ? ovs_to_odp_frag_mask(data->nw_frag)
+ ipv6_key->ipv6_frag = export_mask ? ovs_to_odp_frag_mask(data->nw_frag)
: ovs_to_odp_frag(data->nw_frag);
} else if (flow->dl_type == htons(ETH_TYPE_ARP) ||
flow->dl_type == htons(ETH_TYPE_RARP)) {
memcpy(arp_key->arp_tha, data->arp_tha, ETH_ADDR_LEN);
} else if (eth_type_mpls(flow->dl_type)) {
struct ovs_key_mpls *mpls_key;
+ int i, n;
+ n = flow_count_mpls_labels(flow, NULL);
+ n = MIN(n, max_mpls_depth);
mpls_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_MPLS,
- sizeof *mpls_key);
- mpls_key->mpls_lse = data->mpls_lse;
+ n * sizeof *mpls_key);
+ for (i = 0; i < n; i++) {
+ mpls_key[i].mpls_lse = data->mpls_lse[i];
+ }
}
if (is_ip_any(flow) && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
if (flow->tp_dst == htons(0) &&
(flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) &&
- (!is_mask || (data->tp_src == htons(0xffff) &&
+ (!export_mask || (data->tp_src == htons(0xffff) &&
data->tp_dst == htons(0xffff)))) {
struct ovs_key_nd *nd_key;
* capable of being expanded to allow for that much space. */
void
odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow,
- odp_port_t odp_in_port)
+ const struct flow *mask, odp_port_t odp_in_port)
{
- odp_flow_key_from_flow__(buf, flow, flow, odp_in_port);
+ odp_flow_key_from_flow__(buf, flow, mask, odp_in_port, SIZE_MAX, false);
}
/* Appends a representation of 'mask' as OVS_KEY_ATTR_* attributes to
* capable of being expanded to allow for that much space. */
void
odp_flow_key_from_mask(struct ofpbuf *buf, const struct flow *mask,
- const struct flow *flow, uint32_t odp_in_port_mask)
+ const struct flow *flow, uint32_t odp_in_port_mask,
+ size_t max_mpls_depth)
{
- odp_flow_key_from_flow__(buf, mask, flow, u32_to_odp(odp_in_port_mask));
+ odp_flow_key_from_flow__(buf, flow, mask,
+ u32_to_odp(odp_in_port_mask), max_mpls_depth, true);
}
/* Generate ODP flow key from the given packet metadata */
/* Add an ingress port attribute if 'odp_in_port' is not the magical
* value "ODPP_NONE". */
- if (md->in_port != ODPP_NONE) {
- nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, md->in_port);
+ if (md->in_port.odp_port != ODPP_NONE) {
+ nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, md->in_port.odp_port);
}
}
1u << OVS_KEY_ATTR_SKB_MARK | 1u << OVS_KEY_ATTR_TUNNEL |
1u << OVS_KEY_ATTR_IN_PORT;
- memset(md, 0, sizeof *md);
- md->in_port = ODPP_NONE;
+ *md = PKT_METADATA_INITIALIZER(ODPP_NONE);
NL_ATTR_FOR_EACH (nla, left, key, key_len) {
uint16_t type = nl_attr_type(nla);
continue;
}
- if (type == OVS_KEY_ATTR_PRIORITY) {
+ switch (type) {
+ case OVS_KEY_ATTR_RECIRC_ID:
+ md->recirc_id = nl_attr_get_u32(nla);
+ wanted_attrs &= ~(1u << OVS_KEY_ATTR_RECIRC_ID);
+ break;
+ case OVS_KEY_ATTR_DP_HASH:
+ md->dp_hash = nl_attr_get_u32(nla);
+ wanted_attrs &= ~(1u << OVS_KEY_ATTR_DP_HASH);
+ break;
+ case OVS_KEY_ATTR_PRIORITY:
md->skb_priority = nl_attr_get_u32(nla);
wanted_attrs &= ~(1u << OVS_KEY_ATTR_PRIORITY);
- } else if (type == OVS_KEY_ATTR_SKB_MARK) {
+ break;
+ case OVS_KEY_ATTR_SKB_MARK:
md->pkt_mark = nl_attr_get_u32(nla);
wanted_attrs &= ~(1u << OVS_KEY_ATTR_SKB_MARK);
- } else if (type == OVS_KEY_ATTR_TUNNEL) {
+ break;
+ case OVS_KEY_ATTR_TUNNEL: {
enum odp_key_fitness res;
res = odp_tun_key_from_attr(nla, &md->tunnel);
} else if (res == ODP_FIT_PERFECT) {
wanted_attrs &= ~(1u << OVS_KEY_ATTR_TUNNEL);
}
- } else if (type == OVS_KEY_ATTR_IN_PORT) {
- md->in_port = nl_attr_get_odp_port(nla);
+ break;
+ }
+ case OVS_KEY_ATTR_IN_PORT:
+ md->in_port.odp_port = nl_attr_get_odp_port(nla);
wanted_attrs &= ~(1u << OVS_KEY_ATTR_IN_PORT);
+ break;
+ default:
+ break;
}
if (!wanted_attrs) {
enum ovs_key_attr expected_bit = 0xff;
if (eth_type_mpls(src_flow->dl_type)) {
+ size_t size = nl_attr_get_size(attrs[OVS_KEY_ATTR_MPLS]);
+ const ovs_be32 *mpls_lse = nl_attr_get(attrs[OVS_KEY_ATTR_MPLS]);
+ int n = size / sizeof(ovs_be32);
+ int i;
+
+ if (!size || size % sizeof(ovs_be32)) {
+ return ODP_FIT_ERROR;
+ }
+
if (!is_mask) {
expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS);
if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS))) {
return ODP_FIT_TOO_LITTLE;
}
- flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]);
} else if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS)) {
- flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]);
-
- if (flow->mpls_lse != 0 && flow->dl_type != htons(0xffff)) {
+ if (flow->mpls_lse[0] && flow->dl_type != htons(0xffff)) {
return ODP_FIT_ERROR;
}
expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS);
}
+
+ for (i = 0; i < n && i < FLOW_MAX_MPLS_LABELS; i++) {
+ flow->mpls_lse[i] = mpls_lse[i];
+ }
+ if (n > FLOW_MAX_MPLS_LABELS) {
+ return ODP_FIT_TOO_MUCH;
+ }
+
+ if (!is_mask) {
+ /* BOS may be set only in the innermost label. */
+ for (i = 0; i < n - 1; i++) {
+ if (flow->mpls_lse[i] & htonl(MPLS_BOS_MASK)) {
+ return ODP_FIT_ERROR;
+ }
+ }
+
+ /* BOS must be set in the innermost label. */
+ if (n < FLOW_MAX_MPLS_LABELS
+ && !(flow->mpls_lse[n - 1] & htonl(MPLS_BOS_MASK))) {
+ return ODP_FIT_TOO_LITTLE;
+ }
+ }
+
goto done;
} else if (src_flow->dl_type == htons(ETH_TYPE_IP)) {
if (!is_mask) {
? attrs[OVS_KEY_ATTR_ENCAP] : NULL);
enum odp_key_fitness encap_fitness;
enum odp_key_fitness fitness;
- ovs_be16 tci;
/* Calculate fitness of outer attributes. */
if (!is_mask) {
fitness = check_expectations(present_attrs, out_of_range_attr,
expected_attrs, key, key_len);
- /* Get the VLAN TCI value. */
- if (!is_mask && !(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN))) {
- return ODP_FIT_TOO_LITTLE;
+ /* Set vlan_tci.
+ * Remove the TPID from dl_type since it's not the real Ethertype. */
+ flow->dl_type = htons(0);
+ flow->vlan_tci = (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN)
+ ? nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN])
+ : htons(0));
+ if (!is_mask) {
+ if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN))) {
+ return ODP_FIT_TOO_LITTLE;
+ } else if (flow->vlan_tci == htons(0)) {
+ /* Corner case for a truncated 802.1Q header. */
+ if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap)) {
+ return ODP_FIT_TOO_MUCH;
+ }
+ return fitness;
+ } else if (!(flow->vlan_tci & htons(VLAN_CFI))) {
+ VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is nonzero "
+ "but CFI bit is not set", ntohs(flow->vlan_tci));
+ return ODP_FIT_ERROR;
+ }
} else {
- tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]);
- if (!is_mask) {
- if (tci == htons(0)) {
- /* Corner case for a truncated 802.1Q header. */
- if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap)) {
- return ODP_FIT_TOO_MUCH;
- }
- return fitness;
- } else if (!(tci & htons(VLAN_CFI))) {
- VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is nonzero "
- "but CFI bit is not set", ntohs(tci));
- return ODP_FIT_ERROR;
- }
+ if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) {
+ return fitness;
}
- /* Set vlan_tci.
- * Remove the TPID from dl_type since it's not the real Ethertype. */
- flow->dl_type = htons(0);
- flow->vlan_tci = tci;
}
- if (is_mask && !(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) {
- return fitness;
- }
/* Now parse the encapsulated attributes. */
if (!parse_flow_nlattrs(nl_attr_get(encap), nl_attr_get_size(encap),
attrs, &present_attrs, &out_of_range_attr)) {
expected_attrs = 0;
/* Metadata. */
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_RECIRC_ID)) {
+ flow->recirc_id = nl_attr_get_u32(attrs[OVS_KEY_ATTR_RECIRC_ID]);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_RECIRC_ID;
+ } else if (is_mask) {
+ /* Always exact match recirc_id when datapath does not sepcify it. */
+ flow->recirc_id = UINT32_MAX;
+ }
+
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_DP_HASH)) {
+ flow->dp_hash = nl_attr_get_u32(attrs[OVS_KEY_ATTR_DP_HASH]);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_DP_HASH;
+ }
if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_PRIORITY)) {
flow->skb_priority = nl_attr_get_u32(attrs[OVS_KEY_ATTR_PRIORITY]);
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_PRIORITY;
return ODP_FIT_ERROR;
}
- if ((is_mask && (src_flow->vlan_tci & htons(VLAN_CFI))) ||
- (!is_mask && src_flow->dl_type == htons(ETH_TYPE_VLAN))) {
+ if (is_mask
+ ? (src_flow->vlan_tci & htons(VLAN_CFI)) != 0
+ : src_flow->dl_type == htons(ETH_TYPE_VLAN)) {
return parse_8021q_onward(attrs, present_attrs, out_of_range_attr,
expected_attrs, flow, key, key_len, src_flow);
}
offset = nl_msg_start_nested(odp_actions, OVS_ACTION_ATTR_USERSPACE);
nl_msg_put_u32(odp_actions, OVS_USERSPACE_ATTR_PID, pid);
if (userdata) {
- userdata_ofs = odp_actions->size + NLA_HDRLEN;
+ userdata_ofs = ofpbuf_size(odp_actions) + NLA_HDRLEN;
/* The OVS kernel module before OVS 1.11 and the upstream Linux kernel
* module before Linux 3.10 required the userdata to be exactly 8 bytes
}
static void
-commit_vlan_action(ovs_be16 vlan_tci, struct flow *base,
- struct ofpbuf *odp_actions, struct flow_wildcards *wc)
+pop_vlan(struct flow *base,
+ struct ofpbuf *odp_actions, struct flow_wildcards *wc)
{
- if (base->vlan_tci == vlan_tci) {
- return;
- }
-
memset(&wc->masks.vlan_tci, 0xff, sizeof wc->masks.vlan_tci);
if (base->vlan_tci & htons(VLAN_CFI)) {
nl_msg_put_flag(odp_actions, OVS_ACTION_ATTR_POP_VLAN);
+ base->vlan_tci = 0;
}
+}
+static void
+commit_vlan_action(ovs_be16 vlan_tci, struct flow *base,
+ struct ofpbuf *odp_actions, struct flow_wildcards *wc)
+{
+ if (base->vlan_tci == vlan_tci) {
+ return;
+ }
+
+ pop_vlan(base, odp_actions, wc);
if (vlan_tci & htons(VLAN_CFI)) {
struct ovs_action_push_vlan vlan;
static void
commit_mpls_action(const struct flow *flow, struct flow *base,
- struct ofpbuf *odp_actions, struct flow_wildcards *wc,
- int *mpls_depth_delta)
+ struct ofpbuf *odp_actions, struct flow_wildcards *wc)
{
- if (flow->mpls_lse == base->mpls_lse && !*mpls_depth_delta) {
- return;
+ int base_n = flow_count_mpls_labels(base, wc);
+ int flow_n = flow_count_mpls_labels(flow, wc);
+ int common_n = flow_count_common_mpls_labels(flow, flow_n, base, base_n,
+ wc);
+
+ while (base_n > common_n) {
+ if (base_n - 1 == common_n && flow_n > common_n) {
+ /* If there is only one more LSE in base than there are common
+ * between base and flow; and flow has at least one more LSE than
+ * is common then the topmost LSE of base may be updated using
+ * set */
+ struct ovs_key_mpls mpls_key;
+
+ mpls_key.mpls_lse = flow->mpls_lse[flow_n - base_n];
+ commit_set_action(odp_actions, OVS_KEY_ATTR_MPLS,
+ &mpls_key, sizeof mpls_key);
+ flow_set_mpls_lse(base, 0, mpls_key.mpls_lse);
+ common_n++;
+ } else {
+ /* Otherwise, if there more LSEs in base than are common between
+ * base and flow then pop the topmost one. */
+ ovs_be16 dl_type;
+ bool popped;
+
+ /* If all the LSEs are to be popped and this is not the outermost
+ * LSE then use ETH_TYPE_MPLS as the ethertype parameter of the
+ * POP_MPLS action instead of flow->dl_type.
+ *
+ * This is because the POP_MPLS action requires its ethertype
+ * argument to be an MPLS ethernet type but in this case
+ * flow->dl_type will be a non-MPLS ethernet type.
+ *
+ * When the final POP_MPLS action occurs it use flow->dl_type and
+ * the and the resulting packet will have the desired dl_type. */
+ if ((!eth_type_mpls(flow->dl_type)) && base_n > 1) {
+ dl_type = htons(ETH_TYPE_MPLS);
+ } else {
+ dl_type = flow->dl_type;
+ }
+ nl_msg_put_be16(odp_actions, OVS_ACTION_ATTR_POP_MPLS, dl_type);
+ popped = flow_pop_mpls(base, base_n, flow->dl_type, wc);
+ ovs_assert(popped);
+ base_n--;
+ }
}
- memset(&wc->masks.mpls_lse, 0xff, sizeof wc->masks.mpls_lse);
-
- switch (*mpls_depth_delta) {
- case -1:
- nl_msg_put_be16(odp_actions, OVS_ACTION_ATTR_POP_MPLS, flow->dl_type);
- break;
- case 1: {
+ /* If, after the above popping and setting, there are more LSEs in flow
+ * than base then some LSEs need to be pushed. */
+ while (base_n < flow_n) {
struct ovs_action_push_mpls *mpls;
- mpls = nl_msg_put_unspec_zero(odp_actions, OVS_ACTION_ATTR_PUSH_MPLS,
+ mpls = nl_msg_put_unspec_zero(odp_actions,
+ OVS_ACTION_ATTR_PUSH_MPLS,
sizeof *mpls);
mpls->mpls_ethertype = flow->dl_type;
- mpls->mpls_lse = flow->mpls_lse;
- break;
+ mpls->mpls_lse = flow->mpls_lse[flow_n - base_n - 1];
+ flow_push_mpls(base, base_n, mpls->mpls_ethertype, wc);
+ flow_set_mpls_lse(base, 0, mpls->mpls_lse);
+ base_n++;
}
- case 0: {
- struct ovs_key_mpls mpls_key;
-
- mpls_key.mpls_lse = flow->mpls_lse;
- commit_set_action(odp_actions, OVS_KEY_ATTR_MPLS,
- &mpls_key, sizeof(mpls_key));
- break;
- }
- default:
- OVS_NOT_REACHED();
- }
-
- base->dl_type = flow->dl_type;
- base->mpls_lse = flow->mpls_lse;
- *mpls_depth_delta = 0;
}
static void
* slow path, if there is one, otherwise 0. */
enum slow_path_reason
commit_odp_actions(const struct flow *flow, struct flow *base,
- struct ofpbuf *odp_actions, struct flow_wildcards *wc,
- int *mpls_depth_delta)
+ struct ofpbuf *odp_actions, struct flow_wildcards *wc)
{
enum slow_path_reason slow;
commit_set_ether_addr_action(flow, base, odp_actions, wc);
- commit_vlan_action(flow->vlan_tci, base, odp_actions, wc);
slow = commit_set_nw_action(flow, base, odp_actions, wc);
commit_set_port_action(flow, base, odp_actions, wc);
- /* Committing MPLS actions should occur after committing nw and port
- * actions. This is because committing MPLS actions may alter a packet so
- * that it is no longer IP and thus nw and port actions are no longer valid.
- */
- commit_mpls_action(flow, base, odp_actions, wc, mpls_depth_delta);
+ commit_mpls_action(flow, base, odp_actions, wc);
+ commit_vlan_action(flow->vlan_tci, base, odp_actions, wc);
commit_set_priority_action(flow, base, odp_actions, wc);
commit_set_pkt_mark_action(flow, base, odp_actions, wc);
git://git.onelab.eu / sliver-openvswitch.git / blobdiff