/*
- * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "openvswitch/dynamic-string.h"
#include "flow.h"
#include "netlink.h"
-#include "ofpbuf.h"
+#include "openvswitch/ofpbuf.h"
#include "packets.h"
#include "simap.h"
#include "timeval.h"
#include "util.h"
#include "uuid.h"
#include "openvswitch/vlog.h"
+#include "openvswitch/match.h"
VLOG_DEFINE_THIS_MODULE(odp_util);
static struct nlattr *generate_all_wildcard_mask(const struct attr_len_tbl tbl[],
int max, struct ofpbuf *,
const struct nlattr *key);
-static void format_u128(struct ds *ds, const ovs_u128 *value,
- const ovs_u128 *mask, bool verbose);
+static void format_u128(struct ds *d, const ovs_32aligned_u128 *key,
+ const ovs_32aligned_u128 *mask, bool verbose);
static int scan_u128(const char *s, ovs_u128 *value, ovs_u128 *mask);
+static int parse_odp_action(const char *s, const struct simap *port_names,
+ struct ofpbuf *actions);
+
/* Returns one the following for the action with the given OVS_ACTION_ATTR_*
* 'type':
*
switch ((enum ovs_action_attr) type) {
case OVS_ACTION_ATTR_OUTPUT: return sizeof(uint32_t);
+ case OVS_ACTION_ATTR_TRUNC: return sizeof(struct ovs_action_trunc);
case OVS_ACTION_ATTR_TUNNEL_PUSH: return ATTR_LEN_VARIABLE;
case OVS_ACTION_ATTR_TUNNEL_POP: return sizeof(uint32_t);
+ case OVS_ACTION_ATTR_METER: return sizeof(uint32_t);
case OVS_ACTION_ATTR_USERSPACE: return ATTR_LEN_VARIABLE;
case OVS_ACTION_ATTR_PUSH_VLAN: return sizeof(struct ovs_action_push_vlan);
case OVS_ACTION_ATTR_POP_VLAN: return 0;
case OVS_ACTION_ATTR_SET_MASKED: return ATTR_LEN_VARIABLE;
case OVS_ACTION_ATTR_SAMPLE: return ATTR_LEN_VARIABLE;
case OVS_ACTION_ATTR_CT: return ATTR_LEN_VARIABLE;
+ case OVS_ACTION_ATTR_PUSH_ETH: return sizeof(struct ovs_action_push_eth);
+ case OVS_ACTION_ATTR_POP_ETH: return 0;
+ case OVS_ACTION_ATTR_CLONE: return ATTR_LEN_VARIABLE;
+ case OVS_ACTION_ATTR_ENCAP_NSH: return ATTR_LEN_VARIABLE;
+ case OVS_ACTION_ATTR_DECAP_NSH: return 0;
case OVS_ACTION_ATTR_UNSPEC:
case __OVS_ACTION_ATTR_MAX:
case OVS_KEY_ATTR_CT_ZONE: return "ct_zone";
case OVS_KEY_ATTR_CT_MARK: return "ct_mark";
case OVS_KEY_ATTR_CT_LABELS: return "ct_label";
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4: return "ct_tuple4";
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6: return "ct_tuple6";
case OVS_KEY_ATTR_TUNNEL: return "tunnel";
case OVS_KEY_ATTR_IN_PORT: return "in_port";
case OVS_KEY_ATTR_ETHERNET: return "eth";
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_PACKET_TYPE: return "packet_type";
+ case OVS_KEY_ATTR_NSH: return "nsh";
case __OVS_KEY_ATTR_MAX:
default:
{
size_t len = nl_attr_get_size(a);
- ds_put_format(ds, "action%"PRId16, nl_attr_type(a));
+ ds_put_format(ds, "action%d", nl_attr_type(a));
if (len) {
const uint8_t *unspec;
unsigned int i;
}
static void
-format_odp_sample_action(struct ds *ds, const struct nlattr *attr)
+format_odp_sample_action(struct ds *ds, const struct nlattr *attr,
+ const struct hmap *portno_names)
{
static const struct nl_policy ovs_sample_policy[] = {
[OVS_SAMPLE_ATTR_PROBABILITY] = { .type = NL_A_U32 },
ds_put_cstr(ds, "actions(");
nla_acts = nl_attr_get(a[OVS_SAMPLE_ATTR_ACTIONS]);
len = nl_attr_get_size(a[OVS_SAMPLE_ATTR_ACTIONS]);
- format_odp_actions(ds, nla_acts, len);
+ format_odp_actions(ds, nla_acts, len, portno_names);
ds_put_format(ds, "))");
}
+static void
+format_odp_clone_action(struct ds *ds, const struct nlattr *attr,
+ const struct hmap *portno_names)
+{
+ const struct nlattr *nla_acts = nl_attr_get(attr);
+ int len = nl_attr_get_size(attr);
+
+ ds_put_cstr(ds, "clone");
+ ds_put_format(ds, "(");
+ format_odp_actions(ds, nla_acts, len, portno_names);
+ ds_put_format(ds, ")");
+}
+
+static void
+format_nsh_key(struct ds *ds, const struct ovs_key_nsh *key)
+{
+ ds_put_format(ds, "flags=%d", key->flags);
+ ds_put_format(ds, ",mdtype=%d", key->mdtype);
+ ds_put_format(ds, ",np=%d", key->np);
+ ds_put_format(ds, ",spi=0x%x",
+ (ntohl(key->path_hdr) & NSH_SPI_MASK) >> NSH_SPI_SHIFT);
+ ds_put_format(ds, ",si=%d",
+ (ntohl(key->path_hdr) & NSH_SI_MASK) >> NSH_SI_SHIFT);
+
+ switch (key->mdtype) {
+ case NSH_M_TYPE1:
+ for (int i = 0; i < 4; i++) {
+ ds_put_format(ds, ",c%d=0x%x", i + 1, ntohl(key->c[i]));
+ }
+ break;
+ case NSH_M_TYPE2:
+ default:
+ /* No support for matching other metadata formats yet. */
+ break;
+ }
+}
+
+static void
+format_uint8_masked(struct ds *s, bool *first, const char *name,
+ uint8_t value, uint8_t mask)
+{
+ if (mask != 0) {
+ if (!*first) {
+ ds_put_char(s, ',');
+ }
+ ds_put_format(s, "%s=", name);
+ if (mask == UINT8_MAX) {
+ ds_put_format(s, "%"PRIu8, value);
+ } else {
+ ds_put_format(s, "0x%02"PRIx8"/0x%02"PRIx8, value, mask);
+ }
+ *first = false;
+ }
+}
+
+static void
+format_be32_masked(struct ds *s, bool *first, const char *name,
+ ovs_be32 value, ovs_be32 mask)
+{
+ if (mask != htonl(0)) {
+ if (!*first) {
+ ds_put_char(s, ',');
+ }
+ ds_put_format(s, "%s=", name);
+ if (mask == OVS_BE32_MAX) {
+ ds_put_format(s, "0x%"PRIx32, ntohl(value));
+ } else {
+ ds_put_format(s, "0x%"PRIx32"/0x%08"PRIx32,
+ ntohl(value), ntohl(mask));
+ }
+ *first = false;
+ }
+}
+
+static void
+format_nsh_key_mask(struct ds *ds, const struct ovs_key_nsh *key,
+ const struct ovs_key_nsh *mask)
+{
+ if (!mask) {
+ format_nsh_key(ds, key);
+ } else {
+ bool first = true;
+ uint32_t spi = (ntohl(key->path_hdr) & NSH_SPI_MASK) >> NSH_SPI_SHIFT;
+ uint32_t spi_mask = (ntohl(mask->path_hdr) & NSH_SPI_MASK) >>
+ NSH_SPI_SHIFT;
+ if (spi_mask == 0x00ffffff) {
+ spi_mask = UINT32_MAX;
+ }
+ uint8_t si = (ntohl(key->path_hdr) & NSH_SI_MASK) >> NSH_SI_SHIFT;
+ uint8_t si_mask = (ntohl(mask->path_hdr) & NSH_SI_MASK) >>
+ NSH_SI_SHIFT;
+
+ format_uint8_masked(ds, &first, "flags", key->flags, mask->flags);
+ format_uint8_masked(ds, &first, "mdtype", key->mdtype, mask->mdtype);
+ format_uint8_masked(ds, &first, "np", key->np, mask->np);
+ format_be32_masked(ds, &first, "spi", htonl(spi), htonl(spi_mask));
+ format_uint8_masked(ds, &first, "si", si, si_mask);
+ format_be32_masked(ds, &first, "c1", key->c[0], mask->c[0]);
+ format_be32_masked(ds, &first, "c2", key->c[1], mask->c[1]);
+ format_be32_masked(ds, &first, "c3", key->c[2], mask->c[2]);
+ format_be32_masked(ds, &first, "c4", key->c[3], mask->c[3]);
+ }
+}
+
+static void
+format_odp_encap_nsh_action(struct ds *ds,
+ const struct ovs_action_encap_nsh *encap_nsh)
+ {
+ uint32_t path_hdr = ntohl(encap_nsh->path_hdr);
+ uint32_t spi = (path_hdr & NSH_SPI_MASK) >> NSH_SPI_SHIFT;
+ uint8_t si = (path_hdr & NSH_SI_MASK) >> NSH_SI_SHIFT;
+
+ ds_put_cstr(ds, "encap_nsh(");
+ ds_put_format(ds, "flags=%d", encap_nsh->flags);
+ ds_put_format(ds, ",mdtype=%d", encap_nsh->mdtype);
+ ds_put_format(ds, ",np=%d", encap_nsh->np);
+ ds_put_format(ds, ",spi=0x%x", spi);
+ ds_put_format(ds, ",si=%d", si);
+ switch (encap_nsh->mdtype) {
+ case NSH_M_TYPE1: {
+ struct nsh_md1_ctx *md1_ctx =
+ ALIGNED_CAST(struct nsh_md1_ctx *, encap_nsh->metadata);
+ for (int i = 0; i < 4; i++) {
+ ds_put_format(ds, ",c%d=0x%x", i + 1,
+ ntohl(get_16aligned_be32(&md1_ctx->c[i])));
+ }
+ break;
+ }
+ case NSH_M_TYPE2:
+ ds_put_cstr(ds, ",md2=");
+ ds_put_hex(ds, encap_nsh->metadata, encap_nsh->mdlen);
+ break;
+ default:
+ OVS_NOT_REACHED();
+ }
+ ds_put_format(ds, ")");
+}
+
static const char *
slow_path_reason_to_string(uint32_t reason)
{
}
static void
-format_odp_userspace_action(struct ds *ds, const struct nlattr *attr)
+format_odp_userspace_action(struct ds *ds, const struct nlattr *attr,
+ const struct hmap *portno_names)
{
static const struct nl_policy ovs_userspace_policy[] = {
[OVS_USERSPACE_ATTR_PID] = { .type = NL_A_U32 },
if (userdata_len == sizeof cookie.sflow
&& cookie.type == USER_ACTION_COOKIE_SFLOW) {
ds_put_format(ds, ",sFlow("
- "vid=%"PRIu16",pcp=%"PRIu8",output=%"PRIu32")",
+ "vid=%"PRIu16",pcp=%d,output=%"PRIu32")",
vlan_tci_to_vid(cookie.sflow.vlan_tci),
vlan_tci_to_pcp(cookie.sflow.vlan_tci),
cookie.sflow.output);
ds_put_format(ds, ",flow_sample(probability=%"PRIu16
",collector_set_id=%"PRIu32
",obs_domain_id=%"PRIu32
- ",obs_point_id=%"PRIu32")",
+ ",obs_point_id=%"PRIu32
+ ",output_port=",
cookie.flow_sample.probability,
cookie.flow_sample.collector_set_id,
cookie.flow_sample.obs_domain_id,
cookie.flow_sample.obs_point_id);
+ odp_portno_name_format(portno_names,
+ cookie.flow_sample.output_odp_port, ds);
+ if (cookie.flow_sample.direction == NX_ACTION_SAMPLE_INGRESS) {
+ ds_put_cstr(ds, ",ingress");
+ } else if (cookie.flow_sample.direction == NX_ACTION_SAMPLE_EGRESS) {
+ ds_put_cstr(ds, ",egress");
+ }
+ ds_put_char(ds, ')');
} else if (userdata_len >= sizeof cookie.ipfix
&& cookie.type == USER_ACTION_COOKIE_IPFIX) {
- ds_put_format(ds, ",ipfix(output_port=%"PRIu32")",
- cookie.ipfix.output_odp_port);
+ ds_put_format(ds, ",ipfix(output_port=");
+ odp_portno_name_format(portno_names,
+ cookie.ipfix.output_odp_port, ds);
+ ds_put_char(ds, ')');
} else {
userdata_unspec = true;
}
tunnel_out_port_attr = a[OVS_USERSPACE_ATTR_EGRESS_TUN_PORT];
if (tunnel_out_port_attr) {
- ds_put_format(ds, ",tunnel_out_port=%"PRIu32,
- nl_attr_get_u32(tunnel_out_port_attr));
+ ds_put_format(ds, ",tunnel_out_port=");
+ odp_portno_name_format(portno_names,
+ nl_attr_get_odp_port(tunnel_out_port_attr), ds);
}
ds_put_char(ds, ')');
l3 = eth + 1;
/* Ethernet */
- ds_put_format(ds, "header(size=%"PRIu8",type=%"PRIu8",eth(dst=",
+ ds_put_format(ds, "header(size=%"PRIu32",type=%"PRIu32",eth(dst=",
data->header_len, data->tnl_type);
ds_put_format(ds, ETH_ADDR_FMT, ETH_ADDR_ARGS(eth->eth_dst));
ds_put_format(ds, ",src=");
if (eth->eth_type == htons(ETH_TYPE_IP)) {
/* IPv4 */
- const struct ip_header *ip;
- ip = (const struct ip_header *) l3;
+ const struct ip_header *ip = l3;
ds_put_format(ds, "ipv4(src="IP_FMT",dst="IP_FMT",proto=%"PRIu8
",tos=%#"PRIx8",ttl=%"PRIu8",frag=0x%"PRIx16"),",
IP_ARGS(get_16aligned_be32(&ip->ip_src)),
ntohs(ip->ip_frag_off));
l4 = (ip + 1);
} else {
- const struct ip6_hdr *ip6;
- ip6 = (const struct ip6_hdr *) l3;
+ const struct ovs_16aligned_ip6_hdr *ip6 = l3;
+ struct in6_addr src, dst;
+ memcpy(&src, &ip6->ip6_src, sizeof src);
+ memcpy(&dst, &ip6->ip6_dst, sizeof dst);
+ uint32_t ipv6_flow = ntohl(get_16aligned_be32(&ip6->ip6_flow));
+
ds_put_format(ds, "ipv6(src=");
- ipv6_format_addr(&ip6->ip6_src, ds);
+ ipv6_format_addr(&src, ds);
ds_put_format(ds, ",dst=");
- ipv6_format_addr(&ip6->ip6_dst, ds);
- ds_put_format(ds, ",label=%i,proto=%"PRIu8",tclass=0x%"PRIx8
+ ipv6_format_addr(&dst, ds);
+ ds_put_format(ds, ",label=%i,proto=%"PRIu8",tclass=0x%"PRIx32
",hlimit=%"PRIu8"),",
- ntohl(ip6->ip6_flow) & IPV6_LABEL_MASK, ip6->ip6_nxt,
- (ntohl(ip6->ip6_flow) >> 20) & 0xff, ip6->ip6_hlim);
+ ipv6_flow & IPV6_LABEL_MASK, ip6->ip6_nxt,
+ (ipv6_flow >> 20) & 0xff, ip6->ip6_hlim);
l4 = (ip6 + 1);
}
gnh->oam ? "oam," : "",
gnh->critical ? "crit," : "",
ntohl(get_16aligned_be32(&gnh->vni)) >> 8);
-
+
if (gnh->opt_len) {
ds_put_cstr(ds, ",options(");
format_geneve_opts(gnh->options, NULL, gnh->opt_len * 4,
}
static void
-format_odp_tnl_push_action(struct ds *ds, const struct nlattr *attr)
+format_odp_tnl_push_action(struct ds *ds, const struct nlattr *attr,
+ const struct hmap *portno_names)
{
struct ovs_action_push_tnl *data;
data = (struct ovs_action_push_tnl *) nl_attr_get(attr);
- ds_put_format(ds, "tnl_push(tnl_port(%"PRIu32"),", data->tnl_port);
+ ds_put_cstr(ds, "tnl_push(tnl_port(");
+ odp_portno_name_format(portno_names, data->tnl_port, ds);
+ ds_put_cstr(ds, "),");
format_odp_tnl_push_header(ds, data);
- ds_put_format(ds, ",out_port(%"PRIu32"))", data->out_port);
+ ds_put_format(ds, ",out_port(");
+ odp_portno_name_format(portno_names, data->out_port, ds);
+ ds_put_cstr(ds, "))");
}
static const struct nl_policy ovs_nat_policy[] = {
static const struct nl_policy ovs_conntrack_policy[] = {
[OVS_CT_ATTR_COMMIT] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_CT_ATTR_FORCE_COMMIT] = { .type = NL_A_FLAG, .optional = true, },
[OVS_CT_ATTR_ZONE] = { .type = NL_A_U16, .optional = true, },
[OVS_CT_ATTR_MARK] = { .type = NL_A_UNSPEC, .optional = true,
.min_len = sizeof(uint32_t) * 2 },
format_odp_conntrack_action(struct ds *ds, const struct nlattr *attr)
{
struct nlattr *a[ARRAY_SIZE(ovs_conntrack_policy)];
- const ovs_u128 *label;
+ const struct {
+ ovs_32aligned_u128 value;
+ ovs_32aligned_u128 mask;
+ } *label;
const uint32_t *mark;
const char *helper;
uint16_t zone;
- bool commit;
+ bool commit, force;
const struct nlattr *nat;
if (!nl_parse_nested(attr, ovs_conntrack_policy, a, ARRAY_SIZE(a))) {
}
commit = a[OVS_CT_ATTR_COMMIT] ? true : false;
+ force = a[OVS_CT_ATTR_FORCE_COMMIT] ? true : false;
zone = a[OVS_CT_ATTR_ZONE] ? nl_attr_get_u16(a[OVS_CT_ATTR_ZONE]) : 0;
mark = a[OVS_CT_ATTR_MARK] ? nl_attr_get(a[OVS_CT_ATTR_MARK]) : NULL;
label = a[OVS_CT_ATTR_LABELS] ? nl_attr_get(a[OVS_CT_ATTR_LABELS]): NULL;
nat = a[OVS_CT_ATTR_NAT];
ds_put_format(ds, "ct");
- if (commit || zone || mark || label || helper || nat) {
+ if (commit || force || zone || mark || label || helper || nat) {
ds_put_cstr(ds, "(");
if (commit) {
ds_put_format(ds, "commit,");
}
+ if (force) {
+ ds_put_format(ds, "force_commit,");
+ }
if (zone) {
ds_put_format(ds, "zone=%"PRIu16",", zone);
}
}
if (label) {
ds_put_format(ds, "label=");
- format_u128(ds, label, label + 1, true);
+ format_u128(ds, &label->value, &label->mask, true);
ds_put_char(ds, ',');
}
if (helper) {
}
static void
-format_odp_action(struct ds *ds, const struct nlattr *a)
+format_odp_action(struct ds *ds, const struct nlattr *a,
+ const struct hmap *portno_names)
{
int expected_len;
enum ovs_action_attr type = nl_attr_type(a);
}
switch (type) {
+ case OVS_ACTION_ATTR_METER:
+ ds_put_format(ds, "meter(%"PRIu32")", nl_attr_get_u32(a));
+ break;
case OVS_ACTION_ATTR_OUTPUT:
- ds_put_format(ds, "%"PRIu32, nl_attr_get_u32(a));
+ odp_portno_name_format(portno_names, nl_attr_get_odp_port(a), ds);
+ break;
+ case OVS_ACTION_ATTR_TRUNC: {
+ const struct ovs_action_trunc *trunc =
+ nl_attr_get_unspec(a, sizeof *trunc);
+
+ ds_put_format(ds, "trunc(%"PRIu32")", trunc->max_len);
break;
+ }
case OVS_ACTION_ATTR_TUNNEL_POP:
- ds_put_format(ds, "tnl_pop(%"PRIu32")", nl_attr_get_u32(a));
+ ds_put_cstr(ds, "tnl_pop(");
+ odp_portno_name_format(portno_names, nl_attr_get_odp_port(a), ds);
+ ds_put_char(ds, ')');
break;
case OVS_ACTION_ATTR_TUNNEL_PUSH:
- format_odp_tnl_push_action(ds, a);
+ format_odp_tnl_push_action(ds, a, portno_names);
break;
case OVS_ACTION_ATTR_USERSPACE:
- format_odp_userspace_action(ds, a);
+ format_odp_userspace_action(ds, a, portno_names);
break;
case OVS_ACTION_ATTR_RECIRC:
format_odp_recirc_action(ds, nl_attr_get_u32(a));
format_odp_key_attr(nl_attr_get(a), NULL, NULL, ds, true);
ds_put_cstr(ds, ")");
break;
+ case OVS_ACTION_ATTR_PUSH_ETH: {
+ const struct ovs_action_push_eth *eth = nl_attr_get(a);
+ ds_put_format(ds, "push_eth(src="ETH_ADDR_FMT",dst="ETH_ADDR_FMT")",
+ ETH_ADDR_ARGS(eth->addresses.eth_src),
+ ETH_ADDR_ARGS(eth->addresses.eth_dst));
+ break;
+ }
+ case OVS_ACTION_ATTR_POP_ETH:
+ ds_put_cstr(ds, "pop_eth");
+ break;
case OVS_ACTION_ATTR_PUSH_VLAN: {
const struct ovs_action_push_vlan *vlan = nl_attr_get(a);
ds_put_cstr(ds, "push_vlan(");
break;
}
case OVS_ACTION_ATTR_SAMPLE:
- format_odp_sample_action(ds, a);
+ format_odp_sample_action(ds, a, portno_names);
break;
case OVS_ACTION_ATTR_CT:
format_odp_conntrack_action(ds, a);
break;
+ case OVS_ACTION_ATTR_CLONE:
+ format_odp_clone_action(ds, a, portno_names);
+ break;
+ case OVS_ACTION_ATTR_ENCAP_NSH:
+ format_odp_encap_nsh_action(ds, nl_attr_get(a));
+ break;
+ case OVS_ACTION_ATTR_DECAP_NSH:
+ ds_put_cstr(ds, "decap_nsh()");
+ break;
case OVS_ACTION_ATTR_UNSPEC:
case __OVS_ACTION_ATTR_MAX:
default:
void
format_odp_actions(struct ds *ds, const struct nlattr *actions,
- size_t actions_len)
+ size_t actions_len, const struct hmap *portno_names)
{
if (actions_len) {
const struct nlattr *a;
if (a != actions) {
ds_put_char(ds, ',');
}
- format_odp_action(ds, a);
+ format_odp_action(ds, a, portno_names);
}
if (left) {
int i;
} else if (ovs_scan(&s[n], ",flow_sample(probability=%"SCNi32","
"collector_set_id=%"SCNi32","
"obs_domain_id=%"SCNi32","
- "obs_point_id=%"SCNi32")%n",
+ "obs_point_id=%"SCNi32","
+ "output_port=%"SCNi32"%n",
&probability, &collector_set_id,
- &obs_domain_id, &obs_point_id, &n1)) {
+ &obs_domain_id, &obs_point_id,
+ &output, &n1)) {
n += n1;
cookie.type = USER_ACTION_COOKIE_FLOW_SAMPLE;
cookie.flow_sample.collector_set_id = collector_set_id;
cookie.flow_sample.obs_domain_id = obs_domain_id;
cookie.flow_sample.obs_point_id = obs_point_id;
+ cookie.flow_sample.output_odp_port = u32_to_odp(output);
user_data = &cookie;
user_data_size = sizeof cookie.flow_sample;
+
+ if (ovs_scan(&s[n], ",ingress%n", &n1)) {
+ cookie.flow_sample.direction = NX_ACTION_SAMPLE_INGRESS;
+ n += n1;
+ } else if (ovs_scan(&s[n], ",egress%n", &n1)) {
+ cookie.flow_sample.direction = NX_ACTION_SAMPLE_EGRESS;
+ n += n1;
+ } else {
+ cookie.flow_sample.direction = NX_ACTION_SAMPLE_DEFAULT;
+ }
+ if (s[n] != ')') {
+ res = -EINVAL;
+ goto out;
+ }
+ n++;
} else if (ovs_scan(&s[n], ",ipfix(output_port=%"SCNi32")%n",
&output, &n1) ) {
n += n1;
odp_put_userspace_action(pid, user_data, user_data_size,
tunnel_out_port, include_actions, actions);
res = n + n1;
+ goto out;
} else if (s[n] == ')') {
odp_put_userspace_action(pid, user_data, user_data_size,
ODPP_NONE, include_actions, actions);
res = n + 1;
- } else {
- res = -EINVAL;
+ goto out;
+ }
+ }
+
+ {
+ struct ovs_action_push_eth push;
+ int eth_type = 0;
+ int n1 = -1;
+
+ if (ovs_scan(&s[n], "push_eth(src="ETH_ADDR_SCAN_FMT","
+ "dst="ETH_ADDR_SCAN_FMT",type=%i)%n",
+ ETH_ADDR_SCAN_ARGS(push.addresses.eth_src),
+ ETH_ADDR_SCAN_ARGS(push.addresses.eth_dst),
+ ð_type, &n1)) {
+
+ nl_msg_put_unspec(actions, OVS_ACTION_ATTR_PUSH_ETH,
+ &push, sizeof push);
+
+ res = n + n1;
+ goto out;
}
}
+
+ if (!strncmp(&s[n], "pop_eth", 7)) {
+ nl_msg_put_flag(actions, OVS_ACTION_ATTR_POP_ETH);
+ res = 7;
+ goto out;
+ }
+
+ res = -EINVAL;
out:
ofpbuf_uninit(&buf);
return res;
return -EINVAL;
}
eth = (struct eth_header *) data->header;
- l3 = (data->header + sizeof *eth);
+ l3 = (struct ip_header *) (eth + 1);
ip = (struct ip_header *) l3;
ip6 = (struct ovs_16aligned_ip6_hdr *) l3;
if (!ovs_scan_len(s, &n, "header(size=%"SCNi32",type=%"SCNi32","
const char *helper = NULL;
size_t helper_len = 0;
bool commit = false;
+ bool force_commit = false;
uint16_t zone = 0;
struct {
uint32_t value;
s += n;
continue;
}
+ if (ovs_scan(s, "force_commit%n", &n)) {
+ force_commit = true;
+ s += n;
+ continue;
+ }
if (ovs_scan(s, "zone=%"SCNu16"%n", &zone, &n)) {
s += n;
continue;
}
s++;
}
+ if (commit && force_commit) {
+ return -EINVAL;
+ }
start = nl_msg_start_nested(actions, OVS_ACTION_ATTR_CT);
if (commit) {
nl_msg_put_flag(actions, OVS_CT_ATTR_COMMIT);
+ } else if (force_commit) {
+ nl_msg_put_flag(actions, OVS_CT_ATTR_FORCE_COMMIT);
}
if (zone) {
nl_msg_put_u16(actions, OVS_CT_ATTR_ZONE, zone);
nl_msg_put_unspec(actions, OVS_CT_ATTR_MARK, &ct_mark,
sizeof(ct_mark));
}
- if (!ovs_u128_is_zero(&ct_label.mask)) {
+ if (!ovs_u128_is_zero(ct_label.mask)) {
nl_msg_put_unspec(actions, OVS_CT_ATTR_LABELS, &ct_label,
sizeof ct_label);
}
return s - s_;
}
+static int
+parse_odp_encap_nsh_action(const char *s, struct ofpbuf *actions)
+{
+ int n = 0;
+ int ret = 0;
+ struct ovs_action_encap_nsh encap_nsh;
+ uint32_t spi;
+ uint8_t si;
+ uint32_t cd;
+
+ if (!ovs_scan_len(s, &n, "encap_nsh(")) {
+ ret = -EINVAL;
+ goto out;
+ }
+
+ /* The default is NSH_M_TYPE1 */
+ encap_nsh.flags = 0;
+ encap_nsh.mdtype = NSH_M_TYPE1;
+ encap_nsh.mdlen = NSH_M_TYPE1_MDLEN;
+ encap_nsh.path_hdr = htonl(255);
+ memset(encap_nsh.metadata, 0, NSH_M_TYPE1_MDLEN);
+
+ for (;;) {
+ n += strspn(s + n, delimiters);
+ if (s[n] == ')') {
+ break;
+ }
+
+ if (ovs_scan_len(s, &n, "flags=%"SCNi8, &encap_nsh.flags)) {
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "mdtype=%"SCNi8, &encap_nsh.mdtype)) {
+ switch (encap_nsh.mdtype) {
+ case NSH_M_TYPE1:
+ /* This is the default format. */;
+ break;
+ case NSH_M_TYPE2:
+ /* Length will be updated later. */
+ encap_nsh.mdlen = 0;
+ break;
+ default:
+ ret = -EINVAL;
+ goto out;
+ }
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "np=%"SCNi8, &encap_nsh.np)) {
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "spi=0x%"SCNx32, &spi)) {
+ encap_nsh.path_hdr =
+ htonl(((spi << NSH_SPI_SHIFT) & NSH_SPI_MASK) |
+ (ntohl(encap_nsh.path_hdr) & ~NSH_SPI_MASK));
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "si=%"SCNi8, &si)) {
+ encap_nsh.path_hdr =
+ htonl((si << NSH_SI_SHIFT) |
+ (ntohl(encap_nsh.path_hdr) & ~NSH_SI_MASK));
+ continue;
+ }
+ if (encap_nsh.mdtype == NSH_M_TYPE1) {
+ struct nsh_md1_ctx *md1 =
+ ALIGNED_CAST(struct nsh_md1_ctx *, encap_nsh.metadata);
+ if (ovs_scan_len(s, &n, "c1=0x%"SCNx32, &cd)) {
+ put_16aligned_be32(&md1->c[0], htonl(cd));
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "c2=0x%"SCNx32, &cd)) {
+ put_16aligned_be32(&md1->c[1], htonl(cd));
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "c3=0x%"SCNx32, &cd)) {
+ put_16aligned_be32(&md1->c[2], htonl(cd));
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "c4=0x%"SCNx32, &cd)) {
+ put_16aligned_be32(&md1->c[3], htonl(cd));
+ continue;
+ }
+ }
+ else if (encap_nsh.mdtype == NSH_M_TYPE2) {
+ struct ofpbuf b;
+ char buf[512];
+ size_t mdlen;
+ if (ovs_scan_len(s, &n, "md2=0x%511[0-9a-fA-F]", buf)) {
+ ofpbuf_use_stub(&b, encap_nsh.metadata,
+ OVS_ENCAP_NSH_MAX_MD_LEN);
+ ofpbuf_put_hex(&b, buf, &mdlen);
+ encap_nsh.mdlen = mdlen;
+ ofpbuf_uninit(&b);
+ }
+ continue;
+ }
+ }
+out:
+ if (ret < 0) {
+ return ret;
+ } else {
+ size_t size = offsetof(struct ovs_action_encap_nsh, metadata)
+ + ROUND_UP(encap_nsh.mdlen, 4);
+ nl_msg_put_unspec(actions, OVS_ACTION_ATTR_ENCAP_NSH,
+ &encap_nsh, size);
+ return n;
+ }
+}
+
+static int
+parse_action_list(const char *s, const struct simap *port_names,
+ struct ofpbuf *actions)
+{
+ int n = 0;
+
+ for (;;) {
+ int retval;
+
+ n += strspn(s + n, delimiters);
+ if (s[n] == ')') {
+ break;
+ }
+ retval = parse_odp_action(s + n, port_names, actions);
+ if (retval < 0) {
+ return retval;
+ }
+ n += retval;
+ }
+
+ return n;
+}
+
static int
parse_odp_action(const char *s, const struct simap *port_names,
struct ofpbuf *actions)
}
}
+ {
+ uint32_t max_len;
+ int n;
+
+ if (ovs_scan(s, "trunc(%"SCNi32")%n", &max_len, &n)) {
+ struct ovs_action_trunc *trunc;
+
+ trunc = nl_msg_put_unspec_uninit(actions,
+ OVS_ACTION_ATTR_TRUNC, sizeof *trunc);
+ trunc->max_len = max_len;
+ return n;
+ }
+ }
+
if (port_names) {
int len = strcspn(s, delimiters);
struct simap_node *node;
return 8;
}
+ {
+ unsigned long long int meter_id;
+ int n = -1;
+
+ if (sscanf(s, "meter(%lli)%n", &meter_id, &n) > 0 && n > 0) {
+ nl_msg_put_u32(actions, OVS_ACTION_ATTR_METER, meter_id);
+ return n;
+ }
+ }
+
{
double percentage;
int n = -1;
actions_ofs = nl_msg_start_nested(actions,
OVS_SAMPLE_ATTR_ACTIONS);
- for (;;) {
- int retval;
-
- n += strspn(s + n, delimiters);
- if (s[n] == ')') {
- break;
- }
+ int retval = parse_action_list(s + n, port_names, actions);
+ if (retval < 0)
+ return retval;
- retval = parse_odp_action(s + n, port_names, actions);
- if (retval < 0) {
- return retval;
- }
- n += retval;
- }
+ n += retval;
nl_msg_end_nested(actions, actions_ofs);
nl_msg_end_nested(actions, sample_ofs);
}
}
+ {
+ if (!strncmp(s, "clone(", 6)) {
+ size_t actions_ofs;
+ int n = 6;
+
+ actions_ofs = nl_msg_start_nested(actions, OVS_ACTION_ATTR_CLONE);
+ int retval = parse_action_list(s + n, port_names, actions);
+ if (retval < 0) {
+ return retval;
+ }
+ n += retval;
+ nl_msg_end_nested(actions, actions_ofs);
+ return n + 1;
+ }
+ }
+
+ {
+ if (!strncmp(s, "encap_nsh(", 10)) {
+ int retval = parse_odp_encap_nsh_action(s, actions);
+ if (retval < 0) {
+ return retval;
+ }
+ return retval + 1;
+ }
+ }
+
+ {
+ int n;
+ if (ovs_scan(s, "decap_nsh()%n", &n)) {
+ nl_msg_put_flag(actions, OVS_ACTION_ATTR_DECAP_NSH);
+ return n;
+ }
+ }
+
{
uint32_t port;
int n;
[OVS_KEY_ATTR_CT_ZONE] = { .len = 2 },
[OVS_KEY_ATTR_CT_MARK] = { .len = 4 },
[OVS_KEY_ATTR_CT_LABELS] = { .len = sizeof(struct ovs_key_ct_labels) },
+ [OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4] = { .len = sizeof(struct ovs_key_ct_tuple_ipv4) },
+ [OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6] = { .len = sizeof(struct ovs_key_ct_tuple_ipv6) },
+ [OVS_KEY_ATTR_PACKET_TYPE] = { .len = 4 },
+ [OVS_KEY_ATTR_NSH] = { .len = sizeof(struct ovs_key_nsh) },
};
/* Returns the correct length of the payload for a flow key attribute of the
* if the attribute's payload is variable length, or ATTR_LEN_NESTED if the
* payload is a nested type. */
static int
-odp_key_attr_len(const struct attr_len_tbl tbl[], int max_len, uint16_t type)
+odp_key_attr_len(const struct attr_len_tbl tbl[], int max_type, uint16_t type)
{
- if (type > max_len) {
+ if (type > max_type) {
return ATTR_LEN_INVALID;
}
}
static enum odp_key_fitness
-odp_tun_key_from_attr__(const struct nlattr *attr,
- const struct nlattr *flow_attrs, size_t flow_attr_len,
- const struct flow_tnl *src_tun, struct flow_tnl *tun,
- bool udpif)
+odp_tun_key_from_attr__(const struct nlattr *attr, bool is_mask,
+ struct flow_tnl *tun)
{
unsigned int left;
const struct nlattr *a;
break;
}
case OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS:
- if (tun_metadata_from_geneve_nlattr(a, flow_attrs, flow_attr_len,
- src_tun, udpif, tun)) {
- return ODP_FIT_ERROR;
- }
+ tun_metadata_from_geneve_nlattr(a, is_mask, tun);
break;
default:
}
enum odp_key_fitness
-odp_tun_key_from_attr(const struct nlattr *attr, bool udpif,
- struct flow_tnl *tun)
+odp_tun_key_from_attr(const struct nlattr *attr, struct flow_tnl *tun)
{
memset(tun, 0, sizeof *tun);
- return odp_tun_key_from_attr__(attr, NULL, 0, NULL, tun, udpif);
+ return odp_tun_key_from_attr__(attr, false, tun);
}
static void
}
static bool
-odp_mask_attr_is_wildcard(const struct nlattr *ma)
+odp_mask_is_constant__(enum ovs_key_attr attr, const void *mask, size_t size,
+ int constant)
{
- return is_all_zeros(nl_attr_get(ma), nl_attr_get_size(ma));
-}
-
-static bool
-odp_mask_is_exact(enum ovs_key_attr attr, const void *mask, size_t size)
-{
- if (attr == OVS_KEY_ATTR_TCP_FLAGS) {
- return TCP_FLAGS(*(ovs_be16 *)mask) == TCP_FLAGS(OVS_BE16_MAX);
- }
- if (attr == OVS_KEY_ATTR_IPV6) {
- const struct ovs_key_ipv6 *ipv6_mask = mask;
+ /* Convert 'constant' to all the widths we need. C conversion rules ensure
+ * that -1 becomes all-1-bits and 0 does not change. */
+ ovs_be16 be16 = (OVS_FORCE ovs_be16) constant;
+ uint32_t u32 = constant;
+ uint8_t u8 = constant;
+ const struct in6_addr *in6 = constant ? &in6addr_exact : &in6addr_any;
- return
- ((ipv6_mask->ipv6_label & htonl(IPV6_LABEL_MASK))
- == htonl(IPV6_LABEL_MASK))
- && ipv6_mask->ipv6_proto == UINT8_MAX
- && ipv6_mask->ipv6_tclass == UINT8_MAX
- && ipv6_mask->ipv6_hlimit == UINT8_MAX
- && ipv6_mask->ipv6_frag == UINT8_MAX
- && ipv6_mask_is_exact((const struct in6_addr *)ipv6_mask->ipv6_src)
- && ipv6_mask_is_exact((const struct in6_addr *)ipv6_mask->ipv6_dst);
- }
- if (attr == OVS_KEY_ATTR_TUNNEL) {
+ switch (attr) {
+ case OVS_KEY_ATTR_UNSPEC:
+ case OVS_KEY_ATTR_ENCAP:
+ case __OVS_KEY_ATTR_MAX:
+ default:
return false;
+
+ case OVS_KEY_ATTR_PRIORITY:
+ case OVS_KEY_ATTR_IN_PORT:
+ case OVS_KEY_ATTR_ETHERNET:
+ case OVS_KEY_ATTR_VLAN:
+ case OVS_KEY_ATTR_ETHERTYPE:
+ case OVS_KEY_ATTR_IPV4:
+ case OVS_KEY_ATTR_TCP:
+ case OVS_KEY_ATTR_UDP:
+ case OVS_KEY_ATTR_ICMP:
+ case OVS_KEY_ATTR_ICMPV6:
+ case OVS_KEY_ATTR_ND:
+ case OVS_KEY_ATTR_SKB_MARK:
+ case OVS_KEY_ATTR_TUNNEL:
+ case OVS_KEY_ATTR_SCTP:
+ case OVS_KEY_ATTR_DP_HASH:
+ case OVS_KEY_ATTR_RECIRC_ID:
+ case OVS_KEY_ATTR_MPLS:
+ case OVS_KEY_ATTR_CT_STATE:
+ case OVS_KEY_ATTR_CT_ZONE:
+ case OVS_KEY_ATTR_CT_MARK:
+ case OVS_KEY_ATTR_CT_LABELS:
+ case OVS_KEY_ATTR_PACKET_TYPE:
+ case OVS_KEY_ATTR_NSH:
+ return is_all_byte(mask, size, u8);
+
+ case OVS_KEY_ATTR_TCP_FLAGS:
+ return TCP_FLAGS(*(ovs_be16 *) mask) == TCP_FLAGS(be16);
+
+ case OVS_KEY_ATTR_IPV6: {
+ const struct ovs_key_ipv6 *ipv6_mask = mask;
+ return ((ipv6_mask->ipv6_label & htonl(IPV6_LABEL_MASK))
+ == htonl(IPV6_LABEL_MASK & u32)
+ && ipv6_mask->ipv6_proto == u8
+ && ipv6_mask->ipv6_tclass == u8
+ && ipv6_mask->ipv6_hlimit == u8
+ && ipv6_mask->ipv6_frag == u8
+ && ipv6_addr_equals(&ipv6_mask->ipv6_src, in6)
+ && ipv6_addr_equals(&ipv6_mask->ipv6_dst, in6));
}
- if (attr == OVS_KEY_ATTR_ARP) {
- /* ARP key has padding, ignore it. */
- BUILD_ASSERT_DECL(sizeof(struct ovs_key_arp) == 24);
- BUILD_ASSERT_DECL(offsetof(struct ovs_key_arp, arp_tha) == 10 + 6);
- size = offsetof(struct ovs_key_arp, arp_tha) + ETH_ADDR_LEN;
- ovs_assert(((uint16_t *)mask)[size/2] == 0);
+ case OVS_KEY_ATTR_ARP:
+ return is_all_byte(mask, OFFSETOFEND(struct ovs_key_arp, arp_tha), u8);
+
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4:
+ return is_all_byte(mask, OFFSETOFEND(struct ovs_key_ct_tuple_ipv4,
+ ipv4_proto), u8);
+
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6:
+ return is_all_byte(mask, OFFSETOFEND(struct ovs_key_ct_tuple_ipv6,
+ ipv6_proto), u8);
}
+}
- return is_all_ones(mask, size);
+/* The caller must already have verified that 'ma' has a correct length.
+ *
+ * The main purpose of this function is formatting, to allow code to figure out
+ * whether the mask can be omitted. It doesn't try hard for attributes that
+ * contain sub-attributes, etc., because normally those would be broken down
+ * further for formatting. */
+static bool
+odp_mask_attr_is_wildcard(const struct nlattr *ma)
+{
+ return odp_mask_is_constant__(nl_attr_type(ma),
+ nl_attr_get(ma), nl_attr_get_size(ma), 0);
}
+/* The caller must already have verified that 'size' is a correct length for
+ * 'attr'.
+ *
+ * The main purpose of this function is formatting, to allow code to figure out
+ * whether the mask can be omitted. It doesn't try hard for attributes that
+ * contain sub-attributes, etc., because normally those would be broken down
+ * further for formatting. */
+static bool
+odp_mask_is_exact(enum ovs_key_attr attr, const void *mask, size_t size)
+{
+ return odp_mask_is_constant__(attr, mask, size, -1);
+}
+
+/* The caller must already have verified that 'ma' has a correct length. */
static bool
odp_mask_attr_is_exact(const struct nlattr *ma)
{
enum ovs_key_attr attr = nl_attr_type(ma);
- const void *mask;
- size_t size;
-
- if (attr == OVS_KEY_ATTR_TUNNEL) {
- return false;
- } else {
- mask = nl_attr_get(ma);
- size = nl_attr_get_size(ma);
- }
-
- return odp_mask_is_exact(attr, mask, size);
+ return odp_mask_is_exact(attr, nl_attr_get(ma), nl_attr_get_size(ma));
}
void
static char *
odp_portno_names_get(const struct hmap *portno_names, odp_port_t port_no)
{
- struct odp_portno_names *odp_portno_names;
+ if (portno_names) {
+ struct odp_portno_names *odp_portno_names;
- HMAP_FOR_EACH_IN_BUCKET (odp_portno_names, hmap_node,
- hash_odp_port(port_no), portno_names) {
- if (odp_portno_names->port_no == port_no) {
- return odp_portno_names->name;
+ HMAP_FOR_EACH_IN_BUCKET (odp_portno_names, hmap_node,
+ hash_odp_port(port_no), portno_names) {
+ if (odp_portno_names->port_no == port_no) {
+ return odp_portno_names->name;
+ }
}
}
return NULL;
void
odp_portno_names_destroy(struct hmap *portno_names)
{
- struct odp_portno_names *odp_portno_names, *odp_portno_names_next;
- HMAP_FOR_EACH_SAFE (odp_portno_names, odp_portno_names_next,
- hmap_node, portno_names) {
- hmap_remove(portno_names, &odp_portno_names->hmap_node);
+ struct odp_portno_names *odp_portno_names;
+
+ HMAP_FOR_EACH_POP (odp_portno_names, hmap_node, portno_names) {
free(odp_portno_names->name);
free(odp_portno_names);
}
}
+void
+odp_portno_name_format(const struct hmap *portno_names, odp_port_t port_no,
+ struct ds *s)
+{
+ const char *name = odp_portno_names_get(portno_names, port_no);
+ if (name) {
+ ds_put_cstr(s, name);
+ } else {
+ ds_put_format(s, "%"PRIu32, port_no);
+ }
+}
+
/* Format helpers. */
static void
}
}
+
static void
format_be64(struct ds *ds, const char *name, ovs_be64 key,
const ovs_be64 *mask, bool verbose)
}
}
-static void
-format_ipv6(struct ds *ds, const char *name, const ovs_be32 key_[4],
- const ovs_be32 (*mask_)[4], bool verbose)
-{
- format_in6_addr(ds, name,
- (const struct in6_addr *)key_,
- mask_ ? (const struct in6_addr *)*mask_ : NULL,
- verbose);
-}
-
static void
format_ipv6_label(struct ds *ds, const char *name, ovs_be32 key,
const ovs_be32 *mask, bool verbose)
static bool
check_attr_len(struct ds *ds, const struct nlattr *a, const struct nlattr *ma,
- const struct attr_len_tbl tbl[], int max_len, bool need_key)
+ const struct attr_len_tbl tbl[], int max_type, bool need_key)
{
int expected_len;
- expected_len = odp_key_attr_len(tbl, max_len, nl_attr_type(a));
+ expected_len = odp_key_attr_len(tbl, max_type, nl_attr_type(a));
if (expected_len != ATTR_LEN_VARIABLE &&
expected_len != ATTR_LEN_NESTED) {
case OVS_VXLAN_EXT_GBP: {
uint32_t key = nl_attr_get_u32(a);
ovs_be16 id, id_mask;
- uint8_t flags, flags_mask;
+ uint8_t flags, flags_mask = 0;
id = htons(key & 0xFFFF);
flags = (key >> 16) & 0xFF;
format_odp_tun_geneve(a, ma, ds, verbose);
ds_put_cstr(ds, "),");
break;
+ case OVS_TUNNEL_KEY_ATTR_PAD:
+ break;
case __OVS_TUNNEL_KEY_ATTR_MAX:
default:
format_unknown_key(ds, a, ma);
static void
format_frag(struct ds *ds, const char *name, uint8_t key,
- const uint8_t *mask, bool verbose)
+ const uint8_t *mask, bool verbose OVS_UNUSED)
{
bool mask_empty = mask && !*mask;
+ bool mask_full = !mask || *mask == UINT8_MAX;
/* ODP frag is an enumeration field; partial masks are not meaningful. */
- if (verbose || !mask_empty) {
- bool mask_full = !mask || *mask == UINT8_MAX;
-
- if (!mask_full) { /* Partially masked. */
- ds_put_format(ds, "error: partial mask not supported for frag (%#"
- PRIx8"),", *mask);
- } else {
- ds_put_format(ds, "%s=%s,", name, ovs_frag_type_to_string(key));
- }
+ if (!mask_empty && !mask_full) {
+ ds_put_format(ds, "error: partial mask not supported for frag (%#"
+ PRIx8"),", *mask);
+ } else if (!mask_empty) {
+ ds_put_format(ds, "%s=%s,", name, ovs_frag_type_to_string(key));
}
}
return is_all_zeros(mask, n);
}
+/* The caller must have already verified that 'a' and 'ma' have correct
+ * lengths. */
static void
-format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma,
- const struct hmap *portno_names, struct ds *ds,
- bool verbose)
+format_odp_key_attr__(const struct nlattr *a, const struct nlattr *ma,
+ const struct hmap *portno_names, struct ds *ds,
+ bool verbose)
{
enum ovs_key_attr attr = nl_attr_type(a);
char namebuf[OVS_KEY_ATTR_BUFSIZE];
ds_put_cstr(ds, ovs_key_attr_to_string(attr, namebuf, sizeof namebuf));
- if (!check_attr_len(ds, a, ma, ovs_flow_key_attr_lens,
- OVS_KEY_ATTR_MAX, false)) {
- return;
- }
-
ds_put_char(ds, '(');
switch (attr) {
case OVS_KEY_ATTR_ENCAP:
break;
case OVS_KEY_ATTR_CT_LABELS: {
- const ovs_u128 *value = nl_attr_get(a);
- const ovs_u128 *mask = ma ? nl_attr_get(ma) : NULL;
+ const ovs_32aligned_u128 *value = nl_attr_get(a);
+ const ovs_32aligned_u128 *mask = ma ? nl_attr_get(ma) : NULL;
format_u128(ds, value, mask, verbose);
break;
}
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4: {
+ const struct ovs_key_ct_tuple_ipv4 *key = nl_attr_get(a);
+ const struct ovs_key_ct_tuple_ipv4 *mask = ma ? nl_attr_get(ma) : NULL;
+
+ format_ipv4(ds, "src", key->ipv4_src, MASK(mask, ipv4_src), verbose);
+ format_ipv4(ds, "dst", key->ipv4_dst, MASK(mask, ipv4_dst), verbose);
+ format_u8u(ds, "proto", key->ipv4_proto, MASK(mask, ipv4_proto),
+ verbose);
+ format_be16(ds, "tp_src", key->src_port, MASK(mask, src_port),
+ verbose);
+ format_be16(ds, "tp_dst", key->dst_port, MASK(mask, dst_port),
+ verbose);
+ ds_chomp(ds, ',');
+ break;
+ }
+
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6: {
+ const struct ovs_key_ct_tuple_ipv6 *key = nl_attr_get(a);
+ const struct ovs_key_ct_tuple_ipv6 *mask = ma ? nl_attr_get(ma) : NULL;
+
+ format_in6_addr(ds, "src", &key->ipv6_src, MASK(mask, ipv6_src),
+ verbose);
+ format_in6_addr(ds, "dst", &key->ipv6_dst, MASK(mask, ipv6_dst),
+ verbose);
+ format_u8u(ds, "proto", key->ipv6_proto, MASK(mask, ipv6_proto),
+ verbose);
+ format_be16(ds, "src_port", key->src_port, MASK(mask, src_port),
+ verbose);
+ format_be16(ds, "dst_port", key->dst_port, MASK(mask, dst_port),
+ verbose);
+ ds_chomp(ds, ',');
+ break;
+ }
+
case OVS_KEY_ATTR_TUNNEL:
format_odp_tun_attr(a, ma, ds, verbose);
break;
case OVS_KEY_ATTR_IN_PORT:
- if (portno_names && verbose && is_exact) {
- char *name = odp_portno_names_get(portno_names,
- u32_to_odp(nl_attr_get_u32(a)));
- if (name) {
- ds_put_format(ds, "%s", name);
- } else {
- ds_put_format(ds, "%"PRIu32, nl_attr_get_u32(a));
- }
+ if (is_exact) {
+ odp_portno_name_format(portno_names, nl_attr_get_odp_port(a), ds);
} else {
ds_put_format(ds, "%"PRIu32, nl_attr_get_u32(a));
if (!is_exact) {
}
break;
+ case OVS_KEY_ATTR_PACKET_TYPE: {
+ ovs_be32 value = nl_attr_get_be32(a);
+ ovs_be32 mask = ma ? nl_attr_get_be32(ma) : OVS_BE32_MAX;
+
+ ovs_be16 ns = htons(pt_ns(value));
+ ovs_be16 ns_mask = htons(pt_ns(mask));
+ format_be16(ds, "ns", ns, &ns_mask, verbose);
+
+ ovs_be16 ns_type = pt_ns_type_be(value);
+ ovs_be16 ns_type_mask = pt_ns_type_be(mask);
+ format_be16x(ds, "id", ns_type, &ns_type_mask, verbose);
+
+ ds_chomp(ds, ',');
+ break;
+ }
+
case OVS_KEY_ATTR_ETHERNET: {
const struct ovs_key_ethernet *mask = ma ? nl_attr_get(ma) : NULL;
const struct ovs_key_ethernet *key = nl_attr_get(a);
const struct ovs_key_ipv6 *key = nl_attr_get(a);
const struct ovs_key_ipv6 *mask = ma ? nl_attr_get(ma) : NULL;
- format_ipv6(ds, "src", key->ipv6_src, MASK(mask, ipv6_src), verbose);
- format_ipv6(ds, "dst", key->ipv6_dst, MASK(mask, ipv6_dst), verbose);
+ format_in6_addr(ds, "src", &key->ipv6_src, MASK(mask, ipv6_src),
+ verbose);
+ format_in6_addr(ds, "dst", &key->ipv6_dst, MASK(mask, ipv6_dst),
+ verbose);
format_ipv6_label(ds, "label", key->ipv6_label, MASK(mask, ipv6_label),
verbose);
format_u8u(ds, "proto", key->ipv6_proto, MASK(mask, ipv6_proto),
- verbose);
+ verbose);
format_u8x(ds, "tclass", key->ipv6_tclass, MASK(mask, ipv6_tclass),
- verbose);
+ verbose);
format_u8u(ds, "hlimit", key->ipv6_hlimit, MASK(mask, ipv6_hlimit),
- verbose);
+ verbose);
format_frag(ds, "frag", key->ipv6_frag, MASK(mask, ipv6_frag),
verbose);
ds_chomp(ds, ',');
const struct ovs_key_nd *mask = ma ? nl_attr_get(ma) : NULL;
const struct ovs_key_nd *key = nl_attr_get(a);
- format_ipv6(ds, "target", key->nd_target, MASK(mask, nd_target),
- verbose);
+ format_in6_addr(ds, "target", &key->nd_target, MASK(mask, nd_target),
+ verbose);
format_eth(ds, "sll", key->nd_sll, MASK(mask, nd_sll), verbose);
format_eth(ds, "tll", key->nd_tll, MASK(mask, nd_tll), verbose);
ds_chomp(ds, ',');
break;
}
+ case OVS_KEY_ATTR_NSH: {
+ const struct ovs_key_nsh *mask = ma ? nl_attr_get(ma) : NULL;
+ const struct ovs_key_nsh *key = nl_attr_get(a);
+ format_nsh_key_mask(ds, key, mask);
+ break;
+ }
case OVS_KEY_ATTR_UNSPEC:
case __OVS_KEY_ATTR_MAX:
default:
ds_put_char(ds, ')');
}
+static void
+format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma,
+ const struct hmap *portno_names, struct ds *ds,
+ bool verbose)
+{
+ if (check_attr_len(ds, a, ma, ovs_flow_key_attr_lens,
+ OVS_KEY_ATTR_MAX, false)) {
+ format_odp_key_attr__(a, ma, portno_names, ds, verbose);
+ }
+}
+
static struct nlattr *
generate_all_wildcard_mask(const struct attr_len_tbl tbl[], int max,
struct ofpbuf *ofp, const struct nlattr *key)
}
static void
-format_u128(struct ds *ds, const ovs_u128 *key, const ovs_u128 *mask,
- bool verbose)
+format_u128(struct ds *ds, const ovs_32aligned_u128 *key,
+ const ovs_32aligned_u128 *mask, bool verbose)
{
- if (verbose || (mask && !ovs_u128_is_zero(mask))) {
- ovs_be128 value;
-
- value = hton128(*key);
+ if (verbose || (mask && !ovs_u128_is_zero(get_32aligned_u128(mask)))) {
+ ovs_be128 value = hton128(get_32aligned_u128(key));
ds_put_hex(ds, &value, sizeof value);
- if (mask && !(ovs_u128_is_ones(mask))) {
- value = hton128(*mask);
+ if (mask && !(ovs_u128_is_ones(get_32aligned_u128(mask)))) {
+ value = hton128(get_32aligned_u128(mask));
ds_put_char(ds, '/');
ds_put_hex(ds, &value, sizeof value);
}
}
}
+/* Read the string from 's_' as a 128-bit value. If the string contains
+ * a "/", the rest of the string will be treated as a 128-bit mask.
+ *
+ * If either the value or mask is larger than 64 bits, the string must
+ * be in hexadecimal.
+ */
static int
scan_u128(const char *s_, ovs_u128 *value, ovs_u128 *mask)
{
/* Appends to 'ds' a string representation of the 'key_len' bytes of
* OVS_KEY_ATTR_* attributes in 'key'. If non-null, additionally formats the
* 'mask_len' bytes of 'mask' which apply to 'key'. If 'portno_names' is
- * non-null and 'verbose' is true, translates odp port number to its name. */
+ * non-null, translates odp port number to its name. */
void
odp_flow_format(const struct nlattr *key, size_t key_len,
const struct nlattr *mask, size_t mask_len,
const struct nlattr *a;
unsigned int left;
bool has_ethtype_key = false;
- const struct nlattr *ma = NULL;
struct ofpbuf ofp;
bool first_field = true;
ofpbuf_init(&ofp, 100);
NL_ATTR_FOR_EACH (a, left, key, key_len) {
+ int attr_type = nl_attr_type(a);
+ const struct nlattr *ma = (mask && mask_len
+ ? nl_attr_find__(mask, mask_len,
+ attr_type)
+ : NULL);
+ if (!check_attr_len(ds, a, ma, ovs_flow_key_attr_lens,
+ OVS_KEY_ATTR_MAX, false)) {
+ continue;
+ }
+
bool is_nested_attr;
bool is_wildcard = false;
- int attr_type = nl_attr_type(a);
if (attr_type == OVS_KEY_ATTR_ETHERTYPE) {
has_ethtype_key = true;
if (!first_field) {
ds_put_char(ds, ',');
}
- format_odp_key_attr(a, ma, portno_names, ds, verbose);
+ format_odp_key_attr__(a, ma, portno_names, ds, verbose);
first_field = false;
}
ofpbuf_clear(&ofp);
ds_put_char(ds, ')');
}
if (!has_ethtype_key) {
- ma = nl_attr_find__(mask, mask_len, OVS_KEY_ATTR_ETHERTYPE);
+ const struct nlattr *ma = nl_attr_find__(mask, mask_len,
+ OVS_KEY_ATTR_ETHERTYPE);
if (ma) {
ds_put_format(ds, ",eth_type(0/0x%04"PRIx16")",
ntohs(nl_attr_get_be16(ma)));
return 0;
}
-static int
-scan_ipv6(const char *s, ovs_be32 (*key)[4], ovs_be32 (*mask)[4])
-{
- return scan_in6_addr(s, key ? (struct in6_addr *) *key : NULL,
- mask ? (struct in6_addr *) *mask : NULL);
-}
-
static int
scan_ipv6_label(const char *s, ovs_be32 *key, ovs_be32 *mask)
{
if (ovs_scan(s, "%"SCNi16"%n", &key_, &n)) {
int len = n;
- *key = htons(key_);
+ *key = htons(key_);
+ if (mask) {
+ if (ovs_scan(s + len, "/%"SCNi16"%n", &mask_, &n)) {
+ len += n;
+ *mask = htons(mask_);
+ } else {
+ *mask = OVS_BE16_MAX;
+ }
+ }
+ return len;
+ }
+ return 0;
+}
+
+static int
+scan_be32(const char *s, ovs_be32 *key, ovs_be32 *mask)
+{
+ uint32_t key_, mask_;
+ int n;
+
+ if (ovs_scan(s, "%"SCNi32"%n", &key_, &n)) {
+ int len = n;
+
+ *key = htonl(key_);
if (mask) {
- if (ovs_scan(s + len, "/%"SCNi16"%n", &mask_, &n)) {
+ if (ovs_scan(s + len, "/%"SCNi32"%n", &mask_, &n)) {
len += n;
- *mask = htons(mask_);
+ *mask = htonl(mask_);
} else {
- *mask = OVS_BE16_MAX;
+ *mask = OVS_BE32_MAX;
}
}
return len;
{
uint32_t odp = 0;
- if (state & CS_NEW) {
- odp |= OVS_CS_F_NEW;
- }
- if (state & CS_ESTABLISHED) {
- odp |= OVS_CS_F_ESTABLISHED;
- }
- if (state & CS_RELATED) {
- odp |= OVS_CS_F_RELATED;
- }
- if (state & CS_INVALID) {
- odp |= OVS_CS_F_INVALID;
- }
- if (state & CS_REPLY_DIR) {
- odp |= OVS_CS_F_REPLY_DIR;
- }
- if (state & CS_TRACKED) {
- odp |= OVS_CS_F_TRACKED;
- }
- if (state & CS_SRC_NAT) {
- odp |= OVS_CS_F_SRC_NAT;
- }
- if (state & CS_DST_NAT) {
- odp |= OVS_CS_F_DST_NAT;
+#define CS_STATE(ENUM, INDEX, NAME) \
+ if (state & CS_##ENUM) { \
+ odp |= OVS_CS_F_##ENUM; \
}
+ CS_STATES
+#undef CS_STATE
return odp;
}
{
uint32_t state = 0;
- if (flags & OVS_CS_F_NEW) {
- state |= CS_NEW;
- }
- if (flags & OVS_CS_F_ESTABLISHED) {
- state |= CS_ESTABLISHED;
- }
- if (flags & OVS_CS_F_RELATED) {
- state |= CS_RELATED;
- }
- if (flags & OVS_CS_F_INVALID) {
- state |= CS_INVALID;
- }
- if (flags & OVS_CS_F_REPLY_DIR) {
- state |= CS_REPLY_DIR;
- }
- if (flags & OVS_CS_F_TRACKED) {
- state |= CS_TRACKED;
- }
- if (flags & OVS_CS_F_SRC_NAT) {
- state |= CS_SRC_NAT;
- }
- if (flags & OVS_CS_F_DST_NAT) {
- state |= CS_DST_NAT;
+#define CS_STATE(ENUM, INDEX, NAME) \
+ if (flags & OVS_CS_F_##ENUM) { \
+ state |= CS_##ENUM; \
}
+ CS_STATES
+#undef CS_STATE
return state;
}
parse_odp_key_mask_attr(const char *s, const struct simap *port_names,
struct ofpbuf *key, struct ofpbuf *mask)
{
- ovs_u128 ufid;
- int len;
-
/* Skip UFID. */
- len = odp_ufid_from_string(s, &ufid);
- if (len) {
- return len;
+ ovs_u128 ufid;
+ int ufid_len = odp_ufid_from_string(s, &ufid);
+ if (ufid_len) {
+ return ufid_len;
}
SCAN_SINGLE("skb_priority(", uint32_t, u32, OVS_KEY_ATTR_PRIORITY);
SCAN_SINGLE("ct_mark(", uint32_t, u32, OVS_KEY_ATTR_CT_MARK);
SCAN_SINGLE("ct_label(", ovs_u128, u128, OVS_KEY_ATTR_CT_LABELS);
+ SCAN_BEGIN("ct_tuple4(", struct ovs_key_ct_tuple_ipv4) {
+ SCAN_FIELD("src=", ipv4, ipv4_src);
+ SCAN_FIELD("dst=", ipv4, ipv4_dst);
+ SCAN_FIELD("proto=", u8, ipv4_proto);
+ SCAN_FIELD("tp_src=", be16, src_port);
+ SCAN_FIELD("tp_dst=", be16, dst_port);
+ } SCAN_END(OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4);
+
+ SCAN_BEGIN("ct_tuple6(", struct ovs_key_ct_tuple_ipv6) {
+ SCAN_FIELD("src=", in6_addr, ipv6_src);
+ SCAN_FIELD("dst=", in6_addr, ipv6_dst);
+ SCAN_FIELD("proto=", u8, ipv6_proto);
+ SCAN_FIELD("tp_src=", be16, src_port);
+ SCAN_FIELD("tp_dst=", be16, dst_port);
+ } SCAN_END(OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6);
+
SCAN_BEGIN_NESTED("tunnel(", OVS_KEY_ATTR_TUNNEL) {
SCAN_FIELD_NESTED("tun_id=", ovs_be64, be64, OVS_TUNNEL_KEY_ATTR_ID);
SCAN_FIELD_NESTED("src=", ovs_be32, ipv4, OVS_TUNNEL_KEY_ATTR_IPV4_SRC);
} SCAN_END(OVS_KEY_ATTR_IPV4);
SCAN_BEGIN("ipv6(", struct ovs_key_ipv6) {
- SCAN_FIELD("src=", ipv6, ipv6_src);
- SCAN_FIELD("dst=", ipv6, ipv6_dst);
+ SCAN_FIELD("src=", in6_addr, ipv6_src);
+ SCAN_FIELD("dst=", in6_addr, ipv6_dst);
SCAN_FIELD("label=", ipv6_label, ipv6_label);
SCAN_FIELD("proto=", u8, ipv6_proto);
SCAN_FIELD("tclass=", u8, ipv6_tclass);
} SCAN_END(OVS_KEY_ATTR_ARP);
SCAN_BEGIN("nd(", struct ovs_key_nd) {
- SCAN_FIELD("target=", ipv6, nd_target);
+ SCAN_FIELD("target=", in6_addr, nd_target);
SCAN_FIELD("sll=", eth, nd_sll);
SCAN_FIELD("tll=", eth, nd_tll);
} SCAN_END(OVS_KEY_ATTR_ND);
+ struct packet_type {
+ ovs_be16 ns;
+ ovs_be16 id;
+ };
+ SCAN_BEGIN("packet_type(", struct packet_type) {
+ SCAN_FIELD("ns=", be16, ns);
+ SCAN_FIELD("id=", be16, id);
+ } SCAN_END(OVS_KEY_ATTR_PACKET_TYPE);
+
+ SCAN_BEGIN("nsh(", struct ovs_key_nsh) {
+ SCAN_FIELD("flags=", u8, flags);
+ SCAN_FIELD("mdtype=", u8, mdtype);
+ SCAN_FIELD("np=", u8, np);
+ SCAN_FIELD("path_hdr=", be32, path_hdr);
+ SCAN_FIELD("c1=", be32, c[0]);
+ SCAN_FIELD("c2=", be32, c[1]);
+ SCAN_FIELD("c3=", be32, c[2]);
+ SCAN_FIELD("c4=", be32, c[2]);
+ } SCAN_END(OVS_KEY_ATTR_NSH);
+
/* Encap open-coded. */
if (!strncmp(s, "encap(", 6)) {
const char *start = s;
static void put_arp_key(const struct ovs_key_arp *, struct flow *);
static void get_nd_key(const struct flow *, struct ovs_key_nd *);
static void put_nd_key(const struct ovs_key_nd *, struct flow *);
+static void get_nsh_key(const struct flow *flow, struct ovs_key_nsh *nsh,
+ bool is_mask);
+static void put_nsh_key(const struct ovs_key_nsh *nsh, struct flow *flow,
+ bool is_mask);
/* These share the same layout. */
union ovs_key_tp {
bool export_mask, struct ofpbuf *buf)
{
struct ovs_key_ethernet *eth_key;
- size_t encap;
+ size_t encap[FLOW_MAX_VLAN_HEADERS] = {0};
+ size_t max_vlans;
const struct flow *flow = parms->flow;
- const struct flow *data = export_mask ? parms->mask : parms->flow;
+ const struct flow *mask = parms->mask;
+ const struct flow *data = export_mask ? mask : flow;
nl_msg_put_u32(buf, OVS_KEY_ATTR_PRIORITY, data->skb_priority);
nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_LABELS, &data->ct_label,
sizeof(data->ct_label));
}
+ if (flow->ct_nw_proto) {
+ if (parms->support.ct_orig_tuple
+ && flow->dl_type == htons(ETH_TYPE_IP)) {
+ struct ovs_key_ct_tuple_ipv4 ct = {
+ data->ct_nw_src,
+ data->ct_nw_dst,
+ data->ct_tp_src,
+ data->ct_tp_dst,
+ data->ct_nw_proto,
+ };
+ nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4, &ct,
+ sizeof ct);
+ } else if (parms->support.ct_orig_tuple6
+ && flow->dl_type == htons(ETH_TYPE_IPV6)) {
+ struct ovs_key_ct_tuple_ipv6 ct = {
+ data->ct_ipv6_src,
+ data->ct_ipv6_dst,
+ data->ct_tp_src,
+ data->ct_tp_dst,
+ data->ct_nw_proto,
+ };
+ nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6, &ct,
+ sizeof ct);
+ }
+ }
if (parms->support.recirc) {
nl_msg_put_u32(buf, OVS_KEY_ATTR_RECIRC_ID, data->recirc_id);
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'
+ /* Add an ingress port attribute if this is a mask or 'in_port.odp_port'
* is not the magical value "ODPP_NONE". */
- if (export_mask || parms->odp_in_port != ODPP_NONE) {
- nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, parms->odp_in_port);
+ if (export_mask || flow->in_port.odp_port != ODPP_NONE) {
+ nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, data->in_port.odp_port);
}
- eth_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ETHERNET,
- sizeof *eth_key);
- get_ethernet_key(data, eth_key);
+ nl_msg_put_be32(buf, OVS_KEY_ATTR_PACKET_TYPE, data->packet_type);
- if (flow->vlan_tci != htons(0) || flow->dl_type == htons(ETH_TYPE_VLAN)) {
- 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));
- }
- nl_msg_put_be16(buf, OVS_KEY_ATTR_VLAN, data->vlan_tci);
- encap = nl_msg_start_nested(buf, OVS_KEY_ATTR_ENCAP);
- if (flow->vlan_tci == htons(0)) {
- goto unencap;
- }
+ if (OVS_UNLIKELY(parms->probe)) {
+ max_vlans = FLOW_MAX_VLAN_HEADERS;
} else {
- encap = 0;
+ max_vlans = MIN(parms->support.max_vlan_headers, flow_vlan_limit);
+ }
+
+ /* Conditionally add L2 attributes for Ethernet packets */
+ if (flow->packet_type == htonl(PT_ETH)) {
+ eth_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ETHERNET,
+ sizeof *eth_key);
+ get_ethernet_key(data, eth_key);
+
+ for (int encaps = 0; encaps < max_vlans; encaps++) {
+ ovs_be16 tpid = flow->vlans[encaps].tpid;
+
+ if (flow->vlans[encaps].tci == htons(0)) {
+ if (eth_type_vlan(flow->dl_type)) {
+ /* If VLAN was truncated the tpid is in dl_type */
+ tpid = flow->dl_type;
+ } else {
+ break;
+ }
+ }
+
+ 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, tpid);
+ }
+ nl_msg_put_be16(buf, OVS_KEY_ATTR_VLAN, data->vlans[encaps].tci);
+ encap[encaps] = nl_msg_start_nested(buf, OVS_KEY_ATTR_ENCAP);
+ if (flow->vlans[encaps].tci == htons(0)) {
+ goto unencap;
+ }
+ }
}
if (ntohs(flow->dl_type) < ETH_TYPE_MIN) {
nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, data->dl_type);
+ if (eth_type_vlan(flow->dl_type)) {
+ goto unencap;
+ }
+
if (flow->dl_type == htons(ETH_TYPE_IP)) {
struct ovs_key_ipv4 *ipv4_key;
for (i = 0; i < n; i++) {
mpls_key[i].mpls_lse = data->mpls_lse[i];
}
+ } else if (flow->dl_type == htons(ETH_TYPE_NSH)) {
+ struct ovs_key_nsh *nsh_key;
+
+ nsh_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_NSH,
+ sizeof *nsh_key);
+ get_nsh_key(data, nsh_key, export_mask);
}
if (is_ip_any(flow) && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) {
tcp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_TCP,
sizeof *tcp_key);
get_tp_key(data, tcp_key);
- if (data->tcp_flags) {
+ if (data->tcp_flags || (mask && mask->tcp_flags)) {
nl_msg_put_be16(buf, OVS_KEY_ATTR_TCP_FLAGS, data->tcp_flags);
}
} else if (flow->nw_proto == IPPROTO_UDP) {
icmpv6_key->icmpv6_type = ntohs(data->tp_src);
icmpv6_key->icmpv6_code = ntohs(data->tp_dst);
- if (flow->tp_dst == htons(0)
- && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)
- || flow->tp_src == htons(ND_NEIGHBOR_ADVERT))
+ if (is_nd(flow, NULL)
/* Even though 'tp_src' and 'tp_dst' are 16 bits wide, ICMP
* type and code are 8 bits wide. Therefore, an exact match
* looks like htons(0xff), not htons(0xffff). See
nd_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ND,
sizeof *nd_key);
- memcpy(nd_key->nd_target, &data->nd_target,
- sizeof nd_key->nd_target);
+ nd_key->nd_target = data->nd_target;
nd_key->nd_sll = data->arp_sha;
nd_key->nd_tll = data->arp_tha;
}
}
unencap:
- if (encap) {
- nl_msg_end_nested(buf, encap);
+ for (int encaps = max_vlans - 1; encaps >= 0; encaps--) {
+ if (encap[encaps]) {
+ nl_msg_end_nested(buf, encap[encaps]);
+ }
}
}
/* Generate ODP flow key from the given packet metadata */
void
-odp_key_from_pkt_metadata(struct ofpbuf *buf, const struct pkt_metadata *md)
+odp_key_from_dp_packet(struct ofpbuf *buf, const struct dp_packet *packet)
{
+ const struct pkt_metadata *md = &packet->md;
+
nl_msg_put_u32(buf, OVS_KEY_ATTR_PRIORITY, md->skb_priority);
if (flow_tnl_dst_is_set(&md->tunnel)) {
if (md->ct_mark) {
nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_MARK, md->ct_mark);
}
- if (!ovs_u128_is_zero(&md->ct_label)) {
+ if (!ovs_u128_is_zero(md->ct_label)) {
nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_LABELS, &md->ct_label,
sizeof(md->ct_label));
}
+ if (md->ct_orig_tuple_ipv6) {
+ if (md->ct_orig_tuple.ipv6.ipv6_proto) {
+ nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6,
+ &md->ct_orig_tuple.ipv6,
+ sizeof md->ct_orig_tuple.ipv6);
+ }
+ } else {
+ if (md->ct_orig_tuple.ipv4.ipv4_proto) {
+ nl_msg_put_unspec(buf, OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4,
+ &md->ct_orig_tuple.ipv4,
+ sizeof md->ct_orig_tuple.ipv4);
+ }
+ }
}
/* Add an ingress port attribute if 'odp_in_port' is not the magical
if (md->in_port.odp_port != ODPP_NONE) {
nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, md->in_port.odp_port);
}
+
+ /* Add OVS_KEY_ATTR_ETHERNET for non-Ethernet packets */
+ if (pt_ns(packet->packet_type) == OFPHTN_ETHERTYPE) {
+ nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE,
+ pt_ns_type_be(packet->packet_type));
+ }
}
/* Generate packet metadata from the given ODP flow key. */
void
-odp_key_to_pkt_metadata(const struct nlattr *key, size_t key_len,
- struct pkt_metadata *md)
+odp_key_to_dp_packet(const struct nlattr *key, size_t key_len,
+ struct dp_packet *packet)
{
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
const struct nlattr *nla;
+ struct pkt_metadata *md = &packet->md;
+ ovs_be32 packet_type = htonl(PT_UNKNOWN);
+ ovs_be16 ethertype = 0;
size_t left;
- uint32_t wanted_attrs = 1u << OVS_KEY_ATTR_PRIORITY |
- 1u << OVS_KEY_ATTR_SKB_MARK | 1u << OVS_KEY_ATTR_TUNNEL |
- 1u << OVS_KEY_ATTR_IN_PORT;
pkt_metadata_init(md, ODPP_NONE);
NL_ATTR_FOR_EACH (nla, left, key, key_len) {
- uint16_t type = nl_attr_type(nla);
+ enum ovs_key_attr type = nl_attr_type(nla);
size_t len = nl_attr_get_size(nla);
int expected_len = odp_key_attr_len(ovs_flow_key_attr_lens,
OVS_KEY_ATTR_MAX, type);
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);
break;
case OVS_KEY_ATTR_SKB_MARK:
md->pkt_mark = nl_attr_get_u32(nla);
- wanted_attrs &= ~(1u << OVS_KEY_ATTR_SKB_MARK);
break;
case OVS_KEY_ATTR_CT_STATE:
md->ct_state = odp_to_ovs_ct_state(nl_attr_get_u32(nla));
- wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_STATE);
break;
case OVS_KEY_ATTR_CT_ZONE:
md->ct_zone = nl_attr_get_u16(nla);
- wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_ZONE);
break;
case OVS_KEY_ATTR_CT_MARK:
md->ct_mark = nl_attr_get_u32(nla);
- wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_MARK);
break;
case OVS_KEY_ATTR_CT_LABELS: {
- const ovs_u128 *cl = nl_attr_get(nla);
+ md->ct_label = nl_attr_get_u128(nla);
+ break;
+ }
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4: {
+ const struct ovs_key_ct_tuple_ipv4 *ct = nl_attr_get(nla);
+ md->ct_orig_tuple.ipv4 = *ct;
+ md->ct_orig_tuple_ipv6 = false;
+ break;
+ }
+ case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6: {
+ const struct ovs_key_ct_tuple_ipv6 *ct = nl_attr_get(nla);
- md->ct_label = *cl;
- wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_LABELS);
+ md->ct_orig_tuple.ipv6 = *ct;
+ md->ct_orig_tuple_ipv6 = true;
break;
}
case OVS_KEY_ATTR_TUNNEL: {
enum odp_key_fitness res;
- res = odp_tun_key_from_attr(nla, true, &md->tunnel);
+ res = odp_tun_key_from_attr(nla, &md->tunnel);
if (res == ODP_FIT_ERROR) {
memset(&md->tunnel, 0, sizeof md->tunnel);
- } else if (res == ODP_FIT_PERFECT) {
- wanted_attrs &= ~(1u << OVS_KEY_ATTR_TUNNEL);
}
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;
+ case OVS_KEY_ATTR_ETHERNET:
+ /* Presence of OVS_KEY_ATTR_ETHERNET indicates Ethernet packet. */
+ packet_type = htonl(PT_ETH);
+ break;
+ case OVS_KEY_ATTR_ETHERTYPE:
+ ethertype = nl_attr_get_be16(nla);
+ break;
+ case OVS_KEY_ATTR_UNSPEC:
+ case OVS_KEY_ATTR_ENCAP:
+ case OVS_KEY_ATTR_VLAN:
+ case OVS_KEY_ATTR_IPV4:
+ case OVS_KEY_ATTR_IPV6:
+ case OVS_KEY_ATTR_TCP:
+ case OVS_KEY_ATTR_UDP:
+ case OVS_KEY_ATTR_ICMP:
+ case OVS_KEY_ATTR_ICMPV6:
+ case OVS_KEY_ATTR_ARP:
+ case OVS_KEY_ATTR_ND:
+ case OVS_KEY_ATTR_SCTP:
+ case OVS_KEY_ATTR_TCP_FLAGS:
+ case OVS_KEY_ATTR_MPLS:
+ case OVS_KEY_ATTR_PACKET_TYPE:
+ case OVS_KEY_ATTR_NSH:
+ case __OVS_KEY_ATTR_MAX:
default:
break;
}
+ }
- if (!wanted_attrs) {
- return; /* Have everything. */
- }
+ if (packet_type == htonl(PT_ETH)) {
+ packet->packet_type = htonl(PT_ETH);
+ } else if (packet_type == htonl(PT_UNKNOWN) && ethertype != 0) {
+ packet->packet_type = PACKET_TYPE_BE(OFPHTN_ETHERTYPE,
+ ntohs(ethertype));
+ } else {
+ VLOG_ERR_RL(&rl, "Packet without ETHERTYPE. Unknown packet_type.");
}
}
*expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERTYPE;
} else {
if (!is_mask) {
- flow->dl_type = htons(FLOW_DL_TYPE_NONE);
+ /* Default ethertype for well-known L3 packets. */
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_IPV4)) {
+ flow->dl_type = htons(ETH_TYPE_IP);
+ } else if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_IPV6)) {
+ flow->dl_type = htons(ETH_TYPE_IPV6);
+ } else if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS)) {
+ flow->dl_type = htons(ETH_TYPE_MPLS);
+ } else {
+ flow->dl_type = htons(FLOW_DL_TYPE_NONE);
+ }
+ } else if (src_flow->packet_type != htonl(PT_ETH)) {
+ /* dl_type is mandatory for non-Ethernet packets */
+ flow->dl_type = htons(0xffff);
} else if (ntohs(src_flow->dl_type) < ETH_TYPE_MIN) {
/* See comments in odp_flow_key_from_flow__(). */
VLOG_ERR_RL(&rl, "mask expected for non-Ethernet II frame");
expected_bit = OVS_KEY_ATTR_ARP;
}
}
+ } else if (src_flow->dl_type == htons(ETH_TYPE_NSH)) {
+ if (!is_mask) {
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_NSH;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_NSH)) {
+ const struct ovs_key_nsh *nsh_key;
+
+ nsh_key = nl_attr_get(attrs[OVS_KEY_ATTR_NSH]);
+ put_nsh_key(nsh_key, flow, false);
+ if (is_mask) {
+ check_start = nsh_key;
+ check_len = sizeof *nsh_key;
+ expected_bit = OVS_KEY_ATTR_NSH;
+ }
+ }
} else {
goto done;
}
flow->tp_src = htons(icmpv6_key->icmpv6_type);
flow->tp_dst = htons(icmpv6_key->icmpv6_code);
expected_bit = OVS_KEY_ATTR_ICMPV6;
- if (src_flow->tp_dst == htons(0) &&
- (src_flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
- src_flow->tp_src == htons(ND_NEIGHBOR_ADVERT))) {
+ if (is_nd(src_flow, NULL)) {
if (!is_mask) {
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ND;
}
const struct ovs_key_nd *nd_key;
nd_key = nl_attr_get(attrs[OVS_KEY_ATTR_ND]);
- memcpy(&flow->nd_target, nd_key->nd_target,
- sizeof flow->nd_target);
+ flow->nd_target = nd_key->nd_target;
flow->arp_sha = nd_key->nd_sll;
flow->arp_tha = nd_key->nd_tll;
if (is_mask) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
bool is_mask = src_flow != flow;
- const struct nlattr *encap
- = (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP)
- ? attrs[OVS_KEY_ATTR_ENCAP] : NULL);
+ const struct nlattr *encap;
enum odp_key_fitness encap_fitness;
- enum odp_key_fitness fitness;
+ enum odp_key_fitness fitness = ODP_FIT_ERROR;
+ int encaps = 0;
- /* Calculate fitness of outer attributes. */
- if (!is_mask) {
- expected_attrs |= ((UINT64_C(1) << OVS_KEY_ATTR_VLAN) |
- (UINT64_C(1) << OVS_KEY_ATTR_ENCAP));
- } else {
- if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN)) {
- expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_VLAN);
+ while (encaps < flow_vlan_limit &&
+ (is_mask
+ ? (src_flow->vlans[encaps].tci & htons(VLAN_CFI)) != 0
+ : eth_type_vlan(flow->dl_type))) {
+
+ encap = (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP)
+ ? attrs[OVS_KEY_ATTR_ENCAP] : NULL);
+
+ /* Calculate fitness of outer attributes. */
+ if (!is_mask) {
+ expected_attrs |= ((UINT64_C(1) << OVS_KEY_ATTR_VLAN) |
+ (UINT64_C(1) << OVS_KEY_ATTR_ENCAP));
+ } else {
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN)) {
+ expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_VLAN);
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP)) {
+ expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_ENCAP);
+ }
}
- if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP)) {
- expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_ENCAP);
- }
- }
- fitness = check_expectations(present_attrs, out_of_range_attr,
- expected_attrs, key, key_len);
-
- /* 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;
+ fitness = check_expectations(present_attrs, out_of_range_attr,
+ expected_attrs, key, key_len);
+
+ /* Set vlan_tci.
+ * Remove the TPID from dl_type since it's not the real Ethertype. */
+ flow->vlans[encaps].tpid = flow->dl_type;
+ flow->dl_type = htons(0);
+ flow->vlans[encaps].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)) ||
+ !(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) {
+ return ODP_FIT_TOO_LITTLE;
+ } else if (flow->vlans[encaps].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->vlans[encaps].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->vlans[encaps].tci));
+ return ODP_FIT_ERROR;
+ }
+ } else {
+ if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) {
+ return fitness;
}
- 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));
+ }
+
+ /* 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)) {
return ODP_FIT_ERROR;
}
- } else {
- if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) {
- return fitness;
+ expected_attrs = 0;
+
+ if (!parse_ethertype(attrs, present_attrs, &expected_attrs,
+ flow, src_flow)) {
+ return ODP_FIT_ERROR;
}
- }
- /* 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)) {
- return ODP_FIT_ERROR;
+ encaps++;
}
- expected_attrs = 0;
- if (!parse_ethertype(attrs, present_attrs, &expected_attrs, flow, src_flow)) {
- return ODP_FIT_ERROR;
- }
encap_fitness = parse_l2_5_onward(attrs, present_attrs, out_of_range_attr,
expected_attrs, flow, key, key_len,
src_flow);
static enum odp_key_fitness
odp_flow_key_to_flow__(const struct nlattr *key, size_t key_len,
- const struct nlattr *src_key, size_t src_key_len,
- struct flow *flow, const struct flow *src_flow,
- bool udpif)
+ struct flow *flow, const struct flow *src_flow)
{
const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1];
uint64_t expected_attrs;
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_MARK;
}
if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_LABELS)) {
- const ovs_u128 *cl = nl_attr_get(attrs[OVS_KEY_ATTR_CT_LABELS]);
-
- flow->ct_label = *cl;
+ flow->ct_label = nl_attr_get_u128(attrs[OVS_KEY_ATTR_CT_LABELS]);
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_LABELS;
}
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4)) {
+ const struct ovs_key_ct_tuple_ipv4 *ct = nl_attr_get(attrs[OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4]);
+ flow->ct_nw_src = ct->ipv4_src;
+ flow->ct_nw_dst = ct->ipv4_dst;
+ flow->ct_nw_proto = ct->ipv4_proto;
+ flow->ct_tp_src = ct->src_port;
+ flow->ct_tp_dst = ct->dst_port;
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6)) {
+ const struct ovs_key_ct_tuple_ipv6 *ct = nl_attr_get(attrs[OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6]);
+
+ flow->ct_ipv6_src = ct->ipv6_src;
+ flow->ct_ipv6_dst = ct->ipv6_dst;
+ flow->ct_nw_proto = ct->ipv6_proto;
+ flow->ct_tp_src = ct->src_port;
+ flow->ct_tp_dst = ct->dst_port;
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6;
+ }
if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_TUNNEL)) {
enum odp_key_fitness res;
- res = odp_tun_key_from_attr__(attrs[OVS_KEY_ATTR_TUNNEL],
- is_mask ? src_key : NULL,
- src_key_len, &src_flow->tunnel,
- &flow->tunnel, udpif);
+ res = odp_tun_key_from_attr__(attrs[OVS_KEY_ATTR_TUNNEL], is_mask,
+ &flow->tunnel);
if (res == ODP_FIT_ERROR) {
return ODP_FIT_ERROR;
} else if (res == ODP_FIT_PERFECT) {
flow->in_port.odp_port = ODPP_NONE;
}
- /* Ethernet header. */
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_PACKET_TYPE)) {
+ flow->packet_type
+ = nl_attr_get_be32(attrs[OVS_KEY_ATTR_PACKET_TYPE]);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_PACKET_TYPE;
+ } else if (!is_mask) {
+ flow->packet_type = htonl(PT_ETH);
+ }
+
+ /* Check for Ethernet header. */
if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ETHERNET)) {
const struct ovs_key_ethernet *eth_key;
eth_key = nl_attr_get(attrs[OVS_KEY_ATTR_ETHERNET]);
put_ethernet_key(eth_key, flow);
- if (is_mask) {
- expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERNET;
+ if (!is_mask) {
+ flow->packet_type = htonl(PT_ETH);
}
- }
- if (!is_mask) {
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERNET;
}
+ else if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ETHERTYPE)) {
+ ovs_be16 ethertype = nl_attr_get_be16(attrs[OVS_KEY_ATTR_ETHERTYPE]);
+ if (!is_mask) {
+ flow->packet_type = PACKET_TYPE_BE(OFPHTN_ETHERTYPE,
+ ntohs(ethertype));
+ }
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERTYPE;
+ }
/* Get Ethertype or 802.1Q TPID or FLOW_DL_TYPE_NONE. */
if (!parse_ethertype(attrs, present_attrs, &expected_attrs, flow,
- src_flow)) {
+ src_flow)) {
return ODP_FIT_ERROR;
}
if (is_mask
- ? (src_flow->vlan_tci & htons(VLAN_CFI)) != 0
- : src_flow->dl_type == htons(ETH_TYPE_VLAN)) {
+ ? (src_flow->vlans[0].tci & htons(VLAN_CFI)) != 0
+ : eth_type_vlan(src_flow->dl_type)) {
return parse_8021q_onward(attrs, present_attrs, out_of_range_attr,
expected_attrs, flow, key, key_len, src_flow);
}
if (is_mask) {
/* A missing VLAN mask means exact match on vlan_tci 0 (== no VLAN). */
- flow->vlan_tci = htons(0xffff);
+ flow->vlans[0].tpid = htons(0xffff);
+ flow->vlans[0].tci = htons(0xffff);
if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN)) {
- flow->vlan_tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]);
+ flow->vlans[0].tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]);
expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_VLAN);
}
}
odp_flow_key_to_flow(const struct nlattr *key, size_t key_len,
struct flow *flow)
{
- return odp_flow_key_to_flow__(key, key_len, NULL, 0, flow, flow, false);
+ return odp_flow_key_to_flow__(key, key_len, flow, flow);
}
-static enum odp_key_fitness
-odp_flow_key_to_mask__(const struct nlattr *mask_key, size_t mask_key_len,
- const struct nlattr *flow_key, size_t flow_key_len,
- struct flow_wildcards *mask,
- const struct flow *src_flow,
- bool udpif)
+/* Converts the 'mask_key_len' bytes of OVS_KEY_ATTR_* attributes in 'mask_key'
+ * to a mask structure in 'mask'. 'flow' must be a previously translated flow
+ * corresponding to 'mask' and similarly flow_key/flow_key_len must be the
+ * attributes from that flow. Returns an ODP_FIT_* value that indicates how
+ * well 'key' fits our expectations for what a flow key should contain. */
+enum odp_key_fitness
+odp_flow_key_to_mask(const struct nlattr *mask_key, size_t mask_key_len,
+ struct flow_wildcards *mask, const struct flow *src_flow)
{
if (mask_key_len) {
return odp_flow_key_to_flow__(mask_key, mask_key_len,
- flow_key, flow_key_len,
- &mask->masks, src_flow, udpif);
+ &mask->masks, src_flow);
} else {
/* A missing mask means that the flow should be exact matched.
return ODP_FIT_PERFECT;
}
}
-/* Converts the 'mask_key_len' bytes of OVS_KEY_ATTR_* attributes in 'mask_key'
- * to a mask structure in 'mask'. 'flow' must be a previously translated flow
- * corresponding to 'mask' and similarly flow_key/flow_key_len must be the
- * attributes from that flow. Returns an ODP_FIT_* value that indicates how
- * well 'key' fits our expectations for what a flow key should contain. */
-enum odp_key_fitness
-odp_flow_key_to_mask(const struct nlattr *mask_key, size_t mask_key_len,
- const struct nlattr *flow_key, size_t flow_key_len,
- struct flow_wildcards *mask, const struct flow *flow)
-{
- return odp_flow_key_to_mask__(mask_key, mask_key_len,
- flow_key, flow_key_len,
- mask, flow, false);
-}
-/* These functions are similar to their non-"_udpif" variants but output a
- * 'flow' that is suitable for fast-path packet processing.
- *
- * Some fields have different representation for flow setup and per-
- * packet processing (i.e. different between ofproto-dpif and userspace
- * datapath). In particular, with the non-"_udpif" functions, struct
- * tun_metadata is in the per-flow format (using 'present.map' and 'opts.u8');
- * with these functions, struct tun_metadata is in the per-packet format
- * (using 'present.len' and 'opts.gnv'). */
-enum odp_key_fitness
-odp_flow_key_to_flow_udpif(const struct nlattr *key, size_t key_len,
- struct flow *flow)
+/* Converts the netlink formated key/mask to match.
+ * Fails if odp_flow_key_from_key/mask and odp_flow_key_key/mask
+ * disagree on the acceptable form of flow */
+int
+parse_key_and_mask_to_match(const struct nlattr *key, size_t key_len,
+ const struct nlattr *mask, size_t mask_len,
+ struct match *match)
{
- return odp_flow_key_to_flow__(key, key_len, NULL, 0, flow, flow, true);
-}
+ enum odp_key_fitness fitness;
-enum odp_key_fitness
-odp_flow_key_to_mask_udpif(const struct nlattr *mask_key, size_t mask_key_len,
- const struct nlattr *flow_key, size_t flow_key_len,
- struct flow_wildcards *mask,
- const struct flow *flow)
-{
- return odp_flow_key_to_mask__(mask_key, mask_key_len,
- flow_key, flow_key_len,
- mask, flow, true);
+ fitness = odp_flow_key_to_flow(key, key_len, &match->flow);
+ if (fitness) {
+ /* This should not happen: it indicates that
+ * odp_flow_key_from_flow() and odp_flow_key_to_flow() disagree on
+ * the acceptable form of a flow. Log the problem as an error,
+ * with enough details to enable debugging. */
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+
+ if (!VLOG_DROP_ERR(&rl)) {
+ struct ds s;
+
+ ds_init(&s);
+ odp_flow_format(key, key_len, NULL, 0, NULL, &s, true);
+ VLOG_ERR("internal error parsing flow key %s", ds_cstr(&s));
+ ds_destroy(&s);
+ }
+
+ return EINVAL;
+ }
+
+ fitness = odp_flow_key_to_mask(mask, mask_len, &match->wc, &match->flow);
+ if (fitness) {
+ /* This should not happen: it indicates that
+ * odp_flow_key_from_mask() and odp_flow_key_to_mask()
+ * disagree on the acceptable form of a mask. Log the problem
+ * as an error, with enough details to enable debugging. */
+ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
+
+ if (!VLOG_DROP_ERR(&rl)) {
+ struct ds s;
+
+ ds_init(&s);
+ odp_flow_format(key, key_len, mask, mask_len, NULL, &s,
+ true);
+ VLOG_ERR("internal error parsing flow mask %s (%s)",
+ ds_cstr(&s), odp_key_fitness_to_string(fitness));
+ ds_destroy(&s);
+ }
+
+ return EINVAL;
+ }
+
+ return 0;
}
/* Returns 'fitness' as a string, for use in debug messages. */
return userdata_ofs;
}
+void
+odp_put_pop_eth_action(struct ofpbuf *odp_actions)
+{
+ nl_msg_put_flag(odp_actions, OVS_ACTION_ATTR_POP_ETH);
+}
+
+void
+odp_put_push_eth_action(struct ofpbuf *odp_actions,
+ const struct eth_addr *eth_src,
+ const struct eth_addr *eth_dst)
+{
+ struct ovs_action_push_eth eth;
+
+ memset(ð, 0, sizeof eth);
+ if (eth_src) {
+ eth.addresses.eth_src = *eth_src;
+ }
+ if (eth_dst) {
+ eth.addresses.eth_dst = *eth_dst;
+ }
+
+ nl_msg_put_unspec(odp_actions, OVS_ACTION_ATTR_PUSH_ETH,
+ ð, sizeof eth);
+}
+
void
odp_put_tunnel_action(const struct flow_tnl *tunnel,
struct ofpbuf *odp_actions)
}
static void
-commit_set_ether_addr_action(const struct flow *flow, struct flow *base_flow,
- struct ofpbuf *odp_actions,
- struct flow_wildcards *wc,
- bool use_masked)
+commit_set_ether_action(const struct flow *flow, struct flow *base_flow,
+ struct ofpbuf *odp_actions,
+ struct flow_wildcards *wc,
+ bool use_masked)
{
struct ovs_key_ethernet key, base, mask;
+ if (flow->packet_type != htonl(PT_ETH)) {
+ return;
+ }
+
get_ethernet_key(flow, &key);
get_ethernet_key(base_flow, &base);
get_ethernet_key(&wc->masks, &mask);
}
static void
-pop_vlan(struct flow *base,
- struct ofpbuf *odp_actions, struct flow_wildcards *wc)
+commit_vlan_action(const struct flow* flow, struct flow *base,
+ struct ofpbuf *odp_actions, struct flow_wildcards *wc)
{
- memset(&wc->masks.vlan_tci, 0xff, sizeof wc->masks.vlan_tci);
+ int base_n = flow_count_vlan_headers(base);
+ int flow_n = flow_count_vlan_headers(flow);
+ flow_skip_common_vlan_headers(base, &base_n, flow, &flow_n);
- if (base->vlan_tci & htons(VLAN_CFI)) {
+ /* Pop all mismatching vlan of base, push those of flow */
+ for (; base_n >= 0; base_n--) {
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;
+ wc->masks.vlans[base_n].qtag = OVS_BE32_MAX;
}
- pop_vlan(base, odp_actions, wc);
- if (vlan_tci & htons(VLAN_CFI)) {
+ for (; flow_n >= 0; flow_n--) {
struct ovs_action_push_vlan vlan;
- vlan.vlan_tpid = htons(ETH_TYPE_VLAN);
- vlan.vlan_tci = vlan_tci;
+ vlan.vlan_tpid = flow->vlans[flow_n].tpid;
+ vlan.vlan_tci = flow->vlans[flow_n].tci;
nl_msg_put_unspec(odp_actions, OVS_ACTION_ATTR_PUSH_VLAN,
&vlan, sizeof vlan);
}
- base->vlan_tci = vlan_tci;
+ memcpy(base->vlans, flow->vlans, sizeof(base->vlans));
}
/* Wildcarding already done at action translation time. */
sizeof *mpls);
mpls->mpls_ethertype = flow->dl_type;
mpls->mpls_lse = flow->mpls_lse[flow_n - base_n - 1];
- flow_push_mpls(base, base_n, mpls->mpls_ethertype, NULL);
+ /* Update base flow's MPLS stack, but do not clear L3. We need the L3
+ * headers if the flow is restored later due to returning from a patch
+ * port or group bucket. */
+ flow_push_mpls(base, base_n, mpls->mpls_ethertype, NULL, false);
flow_set_mpls_lse(base, 0, mpls->mpls_lse);
base_n++;
}
static void
get_ipv6_key(const struct flow *flow, struct ovs_key_ipv6 *ipv6, bool is_mask)
{
- memcpy(ipv6->ipv6_src, &flow->ipv6_src, sizeof ipv6->ipv6_src);
- memcpy(ipv6->ipv6_dst, &flow->ipv6_dst, sizeof ipv6->ipv6_dst);
+ ipv6->ipv6_src = flow->ipv6_src;
+ ipv6->ipv6_dst = flow->ipv6_dst;
ipv6->ipv6_label = flow->ipv6_label;
ipv6->ipv6_proto = flow->nw_proto;
ipv6->ipv6_tclass = flow->nw_tos;
static void
put_ipv6_key(const struct ovs_key_ipv6 *ipv6, struct flow *flow, bool is_mask)
{
- memcpy(&flow->ipv6_src, ipv6->ipv6_src, sizeof flow->ipv6_src);
- memcpy(&flow->ipv6_dst, ipv6->ipv6_dst, sizeof flow->ipv6_dst);
+ flow->ipv6_src = ipv6->ipv6_src;
+ flow->ipv6_dst = ipv6->ipv6_dst;
flow->ipv6_label = ipv6->ipv6_label;
flow->nw_proto = ipv6->ipv6_proto;
flow->nw_tos = ipv6->ipv6_tclass;
struct ovs_key_icmp key, mask, base;
enum ovs_key_attr attr;
- if (is_icmpv4(flow)) {
+ if (is_icmpv4(flow, NULL)) {
attr = OVS_KEY_ATTR_ICMP;
- } else if (is_icmpv6(flow)) {
+ } else if (is_icmpv6(flow, NULL)) {
attr = OVS_KEY_ATTR_ICMPV6;
} else {
return 0;
static void
get_nd_key(const struct flow *flow, struct ovs_key_nd *nd)
{
- memcpy(nd->nd_target, &flow->nd_target, sizeof flow->nd_target);
+ nd->nd_target = flow->nd_target;
/* nd_sll and nd_tll are stored in arp_sha and arp_tha, respectively */
nd->nd_sll = flow->arp_sha;
nd->nd_tll = flow->arp_tha;
static void
put_nd_key(const struct ovs_key_nd *nd, struct flow *flow)
{
- memcpy(&flow->nd_target, nd->nd_target, sizeof flow->nd_target);
+ flow->nd_target = nd->nd_target;
/* nd_sll and nd_tll are stored in arp_sha and arp_tha, respectively */
flow->arp_sha = nd->nd_sll;
flow->arp_tha = nd->nd_tll;
return 0;
}
+static void
+get_nsh_key(const struct flow *flow, struct ovs_key_nsh *nsh, bool is_mask)
+{
+ nsh->flags = flow->nsh.flags;
+ nsh->mdtype = flow->nsh.mdtype;
+ nsh->np = flow->nsh.np;
+ nsh->path_hdr = htonl((ntohl(flow->nsh.spi) << NSH_SPI_SHIFT) |
+ flow->nsh.si);
+ if (is_mask) {
+ for (int i = 0; i < 4; i++) {
+ nsh->c[i] = flow->nsh.c[i];
+ }
+ } else {
+ switch (nsh->mdtype) {
+ case NSH_M_TYPE1:
+ for (int i = 0; i < 4; i++) {
+ nsh->c[i] = flow->nsh.c[i];
+ }
+ break;
+ case NSH_M_TYPE2:
+ default:
+ /* No match support for other MD formats yet. */
+ break;
+ }
+ }
+}
+
+static void
+put_nsh_key(const struct ovs_key_nsh *nsh, struct flow *flow,
+ bool is_mask OVS_UNUSED)
+{
+ flow->nsh.flags = nsh->flags;
+ flow->nsh.mdtype = nsh->mdtype;
+ flow->nsh.np = nsh->np;
+ flow->nsh.spi = htonl((ntohl(nsh->path_hdr) & NSH_SPI_MASK) >>
+ NSH_SPI_SHIFT);
+ flow->nsh.si = (ntohl(nsh->path_hdr) & NSH_SI_MASK) >> NSH_SI_SHIFT;
+ switch (nsh->mdtype) {
+ case NSH_M_TYPE1:
+ for (int i = 0; i < 4; i++) {
+ flow->nsh.c[i] = nsh->c[i];
+ }
+ break;
+ case NSH_M_TYPE2:
+ default:
+ /* No match support for other MD formats yet. */
+ memset(flow->nsh.c, 0, sizeof flow->nsh.c);
+ break;
+ }
+}
+
+static void
+commit_set_nsh_action(const struct flow *flow, struct flow *base_flow,
+ struct ofpbuf *odp_actions,
+ struct flow_wildcards *wc,
+ bool use_masked)
+{
+ struct ovs_key_nsh key, mask, base;
+
+ if (flow->dl_type != htons(ETH_TYPE_NSH) ||
+ !memcmp(&base_flow->nsh, &flow->nsh, sizeof base_flow->nsh)) {
+ return;
+ }
+
+ /* Check that mdtype and np remain unchanged. */
+ ovs_assert(flow->nsh.mdtype == base_flow->nsh.mdtype &&
+ flow->nsh.np == base_flow->nsh.np);
+
+ get_nsh_key(flow, &key, false);
+ get_nsh_key(base_flow, &base, false);
+ get_nsh_key(&wc->masks, &mask, true);
+ mask.mdtype = 0; /* Not writable. */
+ mask.np = 0; /* Not writable. */
+
+ if (commit(OVS_KEY_ATTR_NSH, use_masked, &key, &base, &mask, sizeof key,
+ odp_actions)) {
+ put_nsh_key(&base, base_flow, false);
+ if (mask.mdtype != 0) { /* Mask was changed by commit(). */
+ put_nsh_key(&mask, &wc->masks, true);
+ }
+ }
+}
+
/* TCP, UDP, and SCTP keys have the same layout. */
BUILD_ASSERT_DECL(sizeof(struct ovs_key_tcp) == sizeof(struct ovs_key_udp) &&
sizeof(struct ovs_key_tcp) == sizeof(struct ovs_key_sctp));
}
}
+static void
+odp_put_decap_nsh_action(struct ofpbuf *odp_actions)
+{
+ nl_msg_put_flag(odp_actions, OVS_ACTION_ATTR_DECAP_NSH);
+}
+
+static void
+odp_put_encap_nsh_action(struct ofpbuf *odp_actions,
+ const struct flow *flow,
+ struct ofpbuf *encap_data)
+{
+ struct ovs_action_encap_nsh encap_nsh;
+
+ encap_nsh.flags = flow->nsh.flags;
+ encap_nsh.mdtype = flow->nsh.mdtype;
+ encap_nsh.np = flow->nsh.np;
+ encap_nsh.path_hdr = htonl((ntohl(flow->nsh.spi) << NSH_SPI_SHIFT) |
+ flow->nsh.si);
+
+ switch (encap_nsh.mdtype) {
+ case NSH_M_TYPE1: {
+ struct nsh_md1_ctx *md1 =
+ ALIGNED_CAST(struct nsh_md1_ctx *, encap_nsh.metadata);
+ encap_nsh.mdlen = NSH_M_TYPE1_MDLEN;
+ for (int i = 0; i < 4; i++) {
+ put_16aligned_be32(&md1->c[i], flow->nsh.c[i]);
+ }
+ break;
+ }
+ case NSH_M_TYPE2:
+ if (encap_data) {
+ ovs_assert(encap_data->size < OVS_ENCAP_NSH_MAX_MD_LEN);
+ encap_nsh.mdlen = encap_data->size;
+ memcpy(encap_nsh.metadata, encap_data->data, encap_data->size);
+ } else {
+ encap_nsh.mdlen = 0;
+ }
+ break;
+ default:
+ encap_nsh.mdlen = 0;
+ break;
+ }
+ nl_msg_put_unspec(odp_actions, OVS_ACTION_ATTR_ENCAP_NSH,
+ &encap_nsh, sizeof(encap_nsh));
+}
+
+static void
+commit_packet_type_change(const struct flow *flow,
+ struct flow *base_flow,
+ struct ofpbuf *odp_actions,
+ struct flow_wildcards *wc,
+ bool pending_encap,
+ struct ofpbuf *encap_data)
+{
+ if (flow->packet_type == base_flow->packet_type) {
+ return;
+ }
+
+ if (pending_encap) {
+ switch (ntohl(flow->packet_type)) {
+ case PT_ETH: {
+ /* push_eth */
+ odp_put_push_eth_action(odp_actions, &flow->dl_src,
+ &flow->dl_dst);
+ base_flow->packet_type = flow->packet_type;
+ base_flow->dl_src = flow->dl_src;
+ base_flow->dl_dst = flow->dl_dst;
+ break;
+ }
+ case PT_NSH:
+ /* encap_nsh */
+ odp_put_encap_nsh_action(odp_actions, flow, encap_data);
+ base_flow->packet_type = flow->packet_type;
+ /* Update all packet headers in base_flow. */
+ memcpy(&base_flow->dl_dst, &flow->dl_dst,
+ sizeof(*flow) - offsetof(struct flow, dl_dst));
+ break;
+ default:
+ /* Only the above protocols are supported for encap.
+ * The check is done at action translation. */
+ OVS_NOT_REACHED();
+ }
+ } else {
+ /* This is an explicit or implicit decap case. */
+ if (pt_ns(flow->packet_type) == OFPHTN_ETHERTYPE &&
+ base_flow->packet_type == htonl(PT_ETH)) {
+ /* Generate pop_eth and continue without recirculation. */
+ odp_put_pop_eth_action(odp_actions);
+ base_flow->packet_type = flow->packet_type;
+ base_flow->dl_src = eth_addr_zero;
+ base_flow->dl_dst = eth_addr_zero;
+ } else {
+ /* All other decap cases require recirculation.
+ * No need to update the base flow here. */
+ switch (ntohl(base_flow->packet_type)) {
+ case PT_NSH:
+ /* decap_nsh. */
+ odp_put_decap_nsh_action(odp_actions);
+ break;
+ default:
+ /* Checks are done during translation. */
+ OVS_NOT_REACHED();
+ }
+ }
+ }
+
+ wc->masks.packet_type = OVS_BE32_MAX;
+}
+
/* If any of the flow key data that ODP actions can modify are different in
* 'base' and 'flow', appends ODP actions to 'odp_actions' that change the flow
* key from 'base' into 'flow', and then changes 'base' the same way. Does not
enum slow_path_reason
commit_odp_actions(const struct flow *flow, struct flow *base,
struct ofpbuf *odp_actions, struct flow_wildcards *wc,
- bool use_masked)
+ bool use_masked, bool pending_encap,
+ struct ofpbuf *encap_data)
{
enum slow_path_reason slow1, slow2;
-
- commit_set_ether_addr_action(flow, base, odp_actions, wc, use_masked);
+ bool mpls_done = false;
+
+ commit_packet_type_change(flow, base, odp_actions, wc,
+ pending_encap, encap_data);
+ commit_set_ether_action(flow, base, odp_actions, wc, use_masked);
+ /* Make packet a non-MPLS packet before committing L3/4 actions,
+ * which would otherwise do nothing. */
+ if (eth_type_mpls(base->dl_type) && !eth_type_mpls(flow->dl_type)) {
+ commit_mpls_action(flow, base, odp_actions);
+ mpls_done = true;
+ }
+ commit_set_nsh_action(flow, base, odp_actions, wc, use_masked);
slow1 = commit_set_nw_action(flow, base, odp_actions, wc, use_masked);
commit_set_port_action(flow, base, odp_actions, wc, use_masked);
slow2 = commit_set_icmp_action(flow, base, odp_actions, wc);
- commit_mpls_action(flow, base, odp_actions);
- commit_vlan_action(flow->vlan_tci, base, odp_actions, wc);
+ if (!mpls_done) {
+ commit_mpls_action(flow, base, odp_actions);
+ }
+ commit_vlan_action(flow, base, odp_actions, wc);
commit_set_priority_action(flow, base, odp_actions, wc, use_masked);
commit_set_pkt_mark_action(flow, base, odp_actions, wc, use_masked);
projects / ovs.git / blobdiff