/*
- * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 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 <math.h>
#include <netinet/in.h>
#include <netinet/icmp6.h>
+#include <netinet/ip6.h>
#include <stdlib.h>
#include <string.h>
#include "byte-order.h"
#include "coverage.h"
#include "dpif.h"
-#include "dynamic-string.h"
+#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 "tun-metadata.h"
#include "unaligned.h"
#include "util.h"
+#include "uuid.h"
#include "openvswitch/vlog.h"
+#include "openvswitch/match.h"
VLOG_DEFINE_THIS_MODULE(odp_util);
/* The set of characters that may separate one action or one key attribute
* from another. */
static const char *delimiters = ", \t\r\n";
-
-static const char *hex_chars = "0123456789abcdefABCDEF";
+static const char *delimiters_end = ", \t\r\n)";
struct attr_len_tbl {
int len;
const struct hmap *portno_names, struct ds *ds,
bool verbose);
+struct geneve_scan {
+ struct geneve_opt d[63];
+ int len;
+};
+
+static int scan_geneve(const char *s, struct geneve_scan *key,
+ struct geneve_scan *mask);
+static void format_geneve_opts(const struct geneve_opt *opt,
+ const struct geneve_opt *mask, int opts_len,
+ struct ds *, bool verbose);
+
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 *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: return ATTR_LEN_VARIABLE;
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_ENCAP: return "encap";
case OVS_KEY_ATTR_PRIORITY: return "skb_priority";
case OVS_KEY_ATTR_SKB_MARK: return "skb_mark";
+ case OVS_KEY_ATTR_CT_STATE: return "ct_state";
+ 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 int
-parse_flags(const char *s, const char *(*bit_to_string)(uint32_t),
- uint32_t *res_flags, uint32_t allowed, uint32_t *res_mask)
+parse_odp_flags(const char *s, const char *(*bit_to_string)(uint32_t),
+ uint32_t *res_flags, uint32_t allowed, uint32_t *res_mask)
{
- uint32_t result = 0;
- int n;
-
- /* Parse masked flags in numeric format? */
- if (res_mask && ovs_scan(s, "%"SCNi32"/%"SCNi32"%n",
- res_flags, res_mask, &n) && n > 0) {
- if (*res_flags & ~allowed || *res_mask & ~allowed) {
- return -EINVAL;
- }
- return n;
- }
-
- n = 0;
-
- if (res_mask && (*s == '+' || *s == '-')) {
- uint32_t flags = 0, mask = 0;
-
- /* Parse masked flags. */
- while (s[0] != ')') {
- bool set;
- uint32_t bit;
- int name_len;
-
- if (s[0] == '+') {
- set = true;
- } else if (s[0] == '-') {
- set = false;
- } else {
- return -EINVAL;
- }
- s++;
- n++;
-
- name_len = strcspn(s, "+-)");
-
- for (bit = 1; bit; bit <<= 1) {
- const char *fname = bit_to_string(bit);
- size_t len;
-
- if (!fname) {
- continue;
- }
-
- len = strlen(fname);
- if (len != name_len) {
- continue;
- }
- if (!strncmp(s, fname, len)) {
- if (mask & bit) {
- /* bit already set. */
- return -EINVAL;
- }
- if (!(bit & allowed)) {
- return -EINVAL;
- }
- if (set) {
- flags |= bit;
- }
- mask |= bit;
- break;
- }
- }
-
- if (!bit) {
- return -EINVAL; /* Unknown flag name */
- }
- s += name_len;
- n += name_len;
- }
-
- *res_flags = flags;
- *res_mask = mask;
- return n;
- }
-
- /* Parse unmasked flags. If a flag is present, it is set, otherwise
- * it is not set. */
- while (s[n] != ')') {
- unsigned long long int flags;
- uint32_t bit;
- int n0;
-
- if (ovs_scan(&s[n], "%lli%n", &flags, &n0)) {
- if (flags & ~allowed) {
- return -EINVAL;
- }
- n += n0 + (s[n + n0] == ',');
- result |= flags;
- continue;
- }
-
- for (bit = 1; bit; bit <<= 1) {
- const char *name = bit_to_string(bit);
- size_t len;
-
- if (!name) {
- continue;
- }
-
- len = strlen(name);
- if (!strncmp(s + n, name, len) &&
- (s[n + len] == ',' || s[n + len] == ')')) {
- if (!(bit & allowed)) {
- return -EINVAL;
- }
- result |= bit;
- n += len + (s[n + len] == ',');
- break;
- }
- }
-
- if (!bit) {
- return -EINVAL;
- }
- }
-
- *res_flags = result;
- if (res_mask) {
- *res_mask = UINT32_MAX;
- }
- return n;
+ return parse_flags(s, bit_to_string, ')', NULL, NULL,
+ res_flags, allowed, res_mask);
}
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 },
.optional = true },
[OVS_USERSPACE_ATTR_EGRESS_TUN_PORT] = { .type = NL_A_U32,
.optional = true },
+ [OVS_USERSPACE_ATTR_ACTIONS] = { .type = NL_A_UNSPEC,
+ .optional = true },
};
struct nlattr *a[ARRAY_SIZE(ovs_userspace_policy)];
const struct nlattr *userdata_attr;
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;
}
}
}
+ if (a[OVS_USERSPACE_ATTR_ACTIONS]) {
+ ds_put_cstr(ds, ",actions");
+ }
+
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, ')');
format_mpls(struct ds *ds, const struct ovs_key_mpls *mpls_key,
const struct ovs_key_mpls *mpls_mask, int n)
{
- if (n == 1) {
- ovs_be32 key = mpls_key->mpls_lse;
+ for (int i = 0; i < n; i++) {
+ ovs_be32 key = mpls_key[i].mpls_lse;
if (mpls_mask == NULL) {
format_mpls_lse(ds, key);
} else {
- ovs_be32 mask = mpls_mask->mpls_lse;
+ ovs_be32 mask = mpls_mask[i].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_ttl(key), mpls_lse_to_ttl(mask),
mpls_lse_to_bos(key), mpls_lse_to_bos(mask));
}
- } else {
- 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_char(ds, ',');
}
+ ds_chomp(ds, ',');
}
static void
}
static const void *
-format_udp_tnl_push_header(struct ds *ds, const struct ip_header *ip)
+format_udp_tnl_push_header(struct ds *ds, const struct udp_header *udp)
{
- const struct udp_header *udp;
-
- udp = (const struct udp_header *) (ip + 1);
ds_put_format(ds, "udp(src=%"PRIu16",dst=%"PRIu16",csum=0x%"PRIx16"),",
ntohs(udp->udp_src), ntohs(udp->udp_dst),
ntohs(udp->udp_csum));
format_odp_tnl_push_header(struct ds *ds, struct ovs_action_push_tnl *data)
{
const struct eth_header *eth;
- const struct ip_header *ip;
const void *l3;
+ const void *l4;
+ const struct udp_header *udp;
eth = (const struct eth_header *)data->header;
l3 = eth + 1;
- ip = (const struct ip_header *)l3;
/* 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=");
ds_put_format(ds, ETH_ADDR_FMT, ETH_ADDR_ARGS(eth->eth_src));
ds_put_format(ds, ",dl_type=0x%04"PRIx16"),", ntohs(eth->eth_type));
- /* IPv4 */
- 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)),
- IP_ARGS(get_16aligned_be32(&ip->ip_dst)),
- ip->ip_proto, ip->ip_tos,
- ip->ip_ttl,
- ip->ip_frag_off);
+ if (eth->eth_type == htons(ETH_TYPE_IP)) {
+ /* IPv4 */
+ 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)),
+ IP_ARGS(get_16aligned_be32(&ip->ip_dst)),
+ ip->ip_proto, ip->ip_tos,
+ ip->ip_ttl,
+ ntohs(ip->ip_frag_off));
+ l4 = (ip + 1);
+ } else {
+ 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(&src, ds);
+ ds_put_format(ds, ",dst=");
+ ipv6_format_addr(&dst, ds);
+ ds_put_format(ds, ",label=%i,proto=%"PRIu8",tclass=0x%"PRIx32
+ ",hlimit=%"PRIu8"),",
+ ipv6_flow & IPV6_LABEL_MASK, ip6->ip6_nxt,
+ (ipv6_flow >> 20) & 0xff, ip6->ip6_hlim);
+ l4 = (ip6 + 1);
+ }
+
+ udp = (const struct udp_header *) l4;
if (data->tnl_type == OVS_VPORT_TYPE_VXLAN) {
const struct vxlanhdr *vxh;
- vxh = format_udp_tnl_push_header(ds, ip);
+ vxh = format_udp_tnl_push_header(ds, udp);
ds_put_format(ds, "vxlan(flags=0x%"PRIx32",vni=0x%"PRIx32")",
ntohl(get_16aligned_be32(&vxh->vx_flags)),
} else if (data->tnl_type == OVS_VPORT_TYPE_GENEVE) {
const struct genevehdr *gnh;
- gnh = format_udp_tnl_push_header(ds, ip);
+ gnh = format_udp_tnl_push_header(ds, udp);
- ds_put_format(ds, "geneve(%svni=0x%"PRIx32")",
+ ds_put_format(ds, "geneve(%s%svni=0x%"PRIx32,
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,
+ ds, false);
+ ds_put_char(ds, ')');
+ }
+
+ ds_put_char(ds, ')');
} else if (data->tnl_type == OVS_VPORT_TYPE_GRE) {
const struct gre_base_hdr *greh;
ovs_16aligned_be32 *options;
- void *l4;
- l4 = ((uint8_t *)l3 + sizeof(struct ip_header));
greh = (const struct gre_base_hdr *) l4;
ds_put_format(ds, "gre((flags=0x%"PRIx16",proto=0x%"PRIx16")",
}
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[] = {
+ [OVS_NAT_ATTR_SRC] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_DST] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_IP_MIN] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(struct in_addr),
+ .max_len = sizeof(struct in6_addr)},
+ [OVS_NAT_ATTR_IP_MAX] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(struct in_addr),
+ .max_len = sizeof(struct in6_addr)},
+ [OVS_NAT_ATTR_PROTO_MIN] = { .type = NL_A_U16, .optional = true, },
+ [OVS_NAT_ATTR_PROTO_MAX] = { .type = NL_A_U16, .optional = true, },
+ [OVS_NAT_ATTR_PERSISTENT] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_PROTO_HASH] = { .type = NL_A_FLAG, .optional = true, },
+ [OVS_NAT_ATTR_PROTO_RANDOM] = { .type = NL_A_FLAG, .optional = true, },
+};
+
+static void
+format_odp_ct_nat(struct ds *ds, const struct nlattr *attr)
+{
+ struct nlattr *a[ARRAY_SIZE(ovs_nat_policy)];
+ size_t addr_len;
+ ovs_be32 ip_min, ip_max;
+ struct in6_addr ip6_min, ip6_max;
+ uint16_t proto_min, proto_max;
+
+ if (!nl_parse_nested(attr, ovs_nat_policy, a, ARRAY_SIZE(a))) {
+ ds_put_cstr(ds, "nat(error: nl_parse_nested() failed.)");
+ return;
+ }
+ /* If no type, then nothing else either. */
+ if (!(a[OVS_NAT_ATTR_SRC] || a[OVS_NAT_ATTR_DST])
+ && (a[OVS_NAT_ATTR_IP_MIN] || a[OVS_NAT_ATTR_IP_MAX]
+ || a[OVS_NAT_ATTR_PROTO_MIN] || a[OVS_NAT_ATTR_PROTO_MAX]
+ || a[OVS_NAT_ATTR_PERSISTENT] || a[OVS_NAT_ATTR_PROTO_HASH]
+ || a[OVS_NAT_ATTR_PROTO_RANDOM])) {
+ ds_put_cstr(ds, "nat(error: options allowed only with \"src\" or \"dst\")");
+ return;
+ }
+ /* Both SNAT & DNAT may not be specified. */
+ if (a[OVS_NAT_ATTR_SRC] && a[OVS_NAT_ATTR_DST]) {
+ ds_put_cstr(ds, "nat(error: Only one of \"src\" or \"dst\" may be present.)");
+ return;
+ }
+ /* proto may not appear without ip. */
+ if (!a[OVS_NAT_ATTR_IP_MIN] && a[OVS_NAT_ATTR_PROTO_MIN]) {
+ ds_put_cstr(ds, "nat(error: proto but no IP.)");
+ return;
+ }
+ /* MAX may not appear without MIN. */
+ if ((!a[OVS_NAT_ATTR_IP_MIN] && a[OVS_NAT_ATTR_IP_MAX])
+ || (!a[OVS_NAT_ATTR_PROTO_MIN] && a[OVS_NAT_ATTR_PROTO_MAX])) {
+ ds_put_cstr(ds, "nat(error: range max without min.)");
+ return;
+ }
+ /* Address sizes must match. */
+ if ((a[OVS_NAT_ATTR_IP_MIN]
+ && (nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN]) != sizeof(ovs_be32) &&
+ nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN]) != sizeof(struct in6_addr)))
+ || (a[OVS_NAT_ATTR_IP_MIN] && a[OVS_NAT_ATTR_IP_MAX]
+ && (nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN])
+ != nl_attr_get_size(a[OVS_NAT_ATTR_IP_MAX])))) {
+ ds_put_cstr(ds, "nat(error: IP address sizes do not match)");
+ return;
+ }
+
+ addr_len = a[OVS_NAT_ATTR_IP_MIN]
+ ? nl_attr_get_size(a[OVS_NAT_ATTR_IP_MIN]) : 0;
+ ip_min = addr_len == sizeof(ovs_be32) && a[OVS_NAT_ATTR_IP_MIN]
+ ? nl_attr_get_be32(a[OVS_NAT_ATTR_IP_MIN]) : 0;
+ ip_max = addr_len == sizeof(ovs_be32) && a[OVS_NAT_ATTR_IP_MAX]
+ ? nl_attr_get_be32(a[OVS_NAT_ATTR_IP_MAX]) : 0;
+ if (addr_len == sizeof ip6_min) {
+ ip6_min = a[OVS_NAT_ATTR_IP_MIN]
+ ? *(struct in6_addr *)nl_attr_get(a[OVS_NAT_ATTR_IP_MIN])
+ : in6addr_any;
+ ip6_max = a[OVS_NAT_ATTR_IP_MAX]
+ ? *(struct in6_addr *)nl_attr_get(a[OVS_NAT_ATTR_IP_MAX])
+ : in6addr_any;
+ }
+ proto_min = a[OVS_NAT_ATTR_PROTO_MIN]
+ ? nl_attr_get_u16(a[OVS_NAT_ATTR_PROTO_MIN]) : 0;
+ proto_max = a[OVS_NAT_ATTR_PROTO_MAX]
+ ? nl_attr_get_u16(a[OVS_NAT_ATTR_PROTO_MAX]) : 0;
+
+ if ((addr_len == sizeof(ovs_be32)
+ && ip_max && ntohl(ip_min) > ntohl(ip_max))
+ || (addr_len == sizeof(struct in6_addr)
+ && !ipv6_mask_is_any(&ip6_max)
+ && memcmp(&ip6_min, &ip6_max, sizeof ip6_min) > 0)
+ || (proto_max && proto_min > proto_max)) {
+ ds_put_cstr(ds, "nat(range error)");
+ return;
+ }
+
+ ds_put_cstr(ds, "nat");
+ if (a[OVS_NAT_ATTR_SRC] || a[OVS_NAT_ATTR_DST]) {
+ ds_put_char(ds, '(');
+ if (a[OVS_NAT_ATTR_SRC]) {
+ ds_put_cstr(ds, "src");
+ } else if (a[OVS_NAT_ATTR_DST]) {
+ ds_put_cstr(ds, "dst");
+ }
+
+ if (addr_len > 0) {
+ ds_put_cstr(ds, "=");
+
+ if (addr_len == sizeof ip_min) {
+ ds_put_format(ds, IP_FMT, IP_ARGS(ip_min));
+
+ if (ip_max && ip_max != ip_min) {
+ ds_put_format(ds, "-"IP_FMT, IP_ARGS(ip_max));
+ }
+ } else if (addr_len == sizeof ip6_min) {
+ ipv6_format_addr_bracket(&ip6_min, ds, proto_min);
+
+ if (!ipv6_mask_is_any(&ip6_max) &&
+ memcmp(&ip6_max, &ip6_min, sizeof ip6_max) != 0) {
+ ds_put_char(ds, '-');
+ ipv6_format_addr_bracket(&ip6_max, ds, proto_min);
+ }
+ }
+ if (proto_min) {
+ ds_put_format(ds, ":%"PRIu16, proto_min);
+
+ if (proto_max && proto_max != proto_min) {
+ ds_put_format(ds, "-%"PRIu16, proto_max);
+ }
+ }
+ }
+ ds_put_char(ds, ',');
+ if (a[OVS_NAT_ATTR_PERSISTENT]) {
+ ds_put_cstr(ds, "persistent,");
+ }
+ if (a[OVS_NAT_ATTR_PROTO_HASH]) {
+ ds_put_cstr(ds, "hash,");
+ }
+ if (a[OVS_NAT_ATTR_PROTO_RANDOM]) {
+ ds_put_cstr(ds, "random,");
+ }
+ ds_chomp(ds, ',');
+ ds_put_char(ds, ')');
+ }
}
+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 },
+ [OVS_CT_ATTR_LABELS] = { .type = NL_A_UNSPEC, .optional = true,
+ .min_len = sizeof(struct ovs_key_ct_labels) * 2 },
+ [OVS_CT_ATTR_HELPER] = { .type = NL_A_STRING, .optional = true,
+ .min_len = 1, .max_len = 16 },
+ [OVS_CT_ATTR_NAT] = { .type = NL_A_UNSPEC, .optional = true },
+};
+
static void
-format_odp_action(struct ds *ds, const struct nlattr *a)
+format_odp_conntrack_action(struct ds *ds, const struct nlattr *attr)
+{
+ struct nlattr *a[ARRAY_SIZE(ovs_conntrack_policy)];
+ const struct {
+ ovs_32aligned_u128 value;
+ ovs_32aligned_u128 mask;
+ } *label;
+ const uint32_t *mark;
+ const char *helper;
+ uint16_t zone;
+ bool commit, force;
+ const struct nlattr *nat;
+
+ if (!nl_parse_nested(attr, ovs_conntrack_policy, a, ARRAY_SIZE(a))) {
+ ds_put_cstr(ds, "ct(error)");
+ return;
+ }
+
+ 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;
+ helper = a[OVS_CT_ATTR_HELPER] ? nl_attr_get(a[OVS_CT_ATTR_HELPER]) : NULL;
+ nat = a[OVS_CT_ATTR_NAT];
+
+ ds_put_format(ds, "ct");
+ 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 (mark) {
+ ds_put_format(ds, "mark=%#"PRIx32"/%#"PRIx32",", *mark,
+ *(mark + 1));
+ }
+ if (label) {
+ ds_put_format(ds, "label=");
+ format_u128(ds, &label->value, &label->mask, true);
+ ds_put_char(ds, ',');
+ }
+ if (helper) {
+ ds_put_format(ds, "helper=%s,", helper);
+ }
+ if (nat) {
+ format_odp_ct_nat(ds, nat);
+ }
+ ds_chomp(ds, ',');
+ ds_put_cstr(ds, ")");
+ }
+}
+
+static void
+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);
- const struct ovs_action_push_vlan *vlan;
size_t size;
expected_len = odp_action_len(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_VLAN:
- vlan = nl_attr_get(a);
+ 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(");
if (vlan->vlan_tpid != htons(ETH_TYPE_VLAN)) {
ds_put_format(ds, "tpid=0x%04"PRIx16",", ntohs(vlan->vlan_tpid));
format_vlan_tci(ds, vlan->vlan_tci, OVS_BE16_MAX, false);
ds_put_char(ds, ')');
break;
+ }
case OVS_ACTION_ATTR_POP_VLAN:
ds_put_cstr(ds, "pop_vlan");
break;
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:
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;
int n = -1;
void *user_data = NULL;
size_t user_data_size = 0;
+ bool include_actions = false;
+ int res;
if (!ovs_scan(s, "userspace(pid=%"SCNi32"%n", &pid, &n)) {
return -EINVAL;
}
+ ofpbuf_init(&buf, 16);
+
{
uint32_t output;
uint32_t probability;
user_data_size = sizeof cookie.sflow;
} else if (ovs_scan(&s[n], ",slow_path(%n",
&n1)) {
- int res;
-
n += n1;
cookie.type = USER_ACTION_COOKIE_SLOW_PATH;
cookie.slow_path.unused = 0;
cookie.slow_path.reason = 0;
- res = parse_flags(&s[n], slow_path_reason_to_string,
- &cookie.slow_path.reason,
- SLOW_PATH_REASON_MASK, NULL);
+ res = parse_odp_flags(&s[n], slow_path_reason_to_string,
+ &cookie.slow_path.reason,
+ SLOW_PATH_REASON_MASK, NULL);
if (res < 0 || s[n + res] != ')') {
- return res;
+ goto out;
}
n += res + 1;
} 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;
char *end;
n += n1;
- ofpbuf_init(&buf, 16);
end = ofpbuf_put_hex(&buf, &s[n], NULL);
if (end[0] != ')') {
- return -EINVAL;
+ res = -EINVAL;
+ goto out;
}
user_data = buf.data;
user_data_size = buf.size;
}
}
+ {
+ int n1 = -1;
+ if (ovs_scan(&s[n], ",actions%n", &n1)) {
+ n += n1;
+ include_actions = true;
+ }
+ }
+
{
int n1 = -1;
if (ovs_scan(&s[n], ",tunnel_out_port=%"SCNi32")%n",
&tunnel_out_port, &n1)) {
- odp_put_userspace_action(pid, user_data, user_data_size, tunnel_out_port, actions);
- return 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, actions);
- return n + 1;
+ odp_put_userspace_action(pid, user_data, user_data_size,
+ ODPP_NONE, include_actions, actions);
+ res = n + 1;
+ goto out;
}
}
- return -EINVAL;
+ {
+ 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;
}
static int
{
struct eth_header *eth;
struct ip_header *ip;
+ struct ovs_16aligned_ip6_hdr *ip6;
struct udp_header *udp;
struct gre_base_hdr *greh;
uint16_t gre_proto, gre_flags, dl_type, udp_src, udp_dst, csum;
ovs_be32 sip, dip;
- uint32_t tnl_type = 0, header_len = 0;
+ uint32_t tnl_type = 0, header_len = 0, ip_len = 0;
void *l3, *l4;
int n = 0;
return -EINVAL;
}
eth = (struct eth_header *) data->header;
- l3 = (data->header + sizeof *eth);
- l4 = ((uint8_t *) l3 + sizeof (struct ip_header));
+ 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","
- "eth(dst="ETH_ADDR_SCAN_FMT",",
- &data->header_len,
- &data->tnl_type,
- ETH_ADDR_SCAN_ARGS(eth->eth_dst))) {
+ "eth(dst="ETH_ADDR_SCAN_FMT",",
+ &data->header_len,
+ &data->tnl_type,
+ ETH_ADDR_SCAN_ARGS(eth->eth_dst))) {
return -EINVAL;
}
if (!ovs_scan_len(s, &n, "src="ETH_ADDR_SCAN_FMT",",
- ETH_ADDR_SCAN_ARGS(eth->eth_src))) {
+ ETH_ADDR_SCAN_ARGS(eth->eth_src))) {
return -EINVAL;
}
if (!ovs_scan_len(s, &n, "dl_type=0x%"SCNx16"),", &dl_type)) {
}
eth->eth_type = htons(dl_type);
- /* IPv4 */
- if (!ovs_scan_len(s, &n, "ipv4(src="IP_SCAN_FMT",dst="IP_SCAN_FMT",proto=%"SCNi8
- ",tos=%"SCNi8",ttl=%"SCNi8",frag=0x%"SCNx16"),",
- IP_SCAN_ARGS(&sip),
- IP_SCAN_ARGS(&dip),
- &ip->ip_proto, &ip->ip_tos,
- &ip->ip_ttl, &ip->ip_frag_off)) {
- return -EINVAL;
+ if (eth->eth_type == htons(ETH_TYPE_IP)) {
+ /* IPv4 */
+ uint16_t ip_frag_off;
+ if (!ovs_scan_len(s, &n, "ipv4(src="IP_SCAN_FMT",dst="IP_SCAN_FMT",proto=%"SCNi8
+ ",tos=%"SCNi8",ttl=%"SCNi8",frag=0x%"SCNx16"),",
+ IP_SCAN_ARGS(&sip),
+ IP_SCAN_ARGS(&dip),
+ &ip->ip_proto, &ip->ip_tos,
+ &ip->ip_ttl, &ip_frag_off)) {
+ return -EINVAL;
+ }
+ put_16aligned_be32(&ip->ip_src, sip);
+ put_16aligned_be32(&ip->ip_dst, dip);
+ ip->ip_frag_off = htons(ip_frag_off);
+ ip_len = sizeof *ip;
+ } else {
+ char sip6_s[IPV6_SCAN_LEN + 1];
+ char dip6_s[IPV6_SCAN_LEN + 1];
+ struct in6_addr sip6, dip6;
+ uint8_t tclass;
+ uint32_t label;
+ if (!ovs_scan_len(s, &n, "ipv6(src="IPV6_SCAN_FMT",dst="IPV6_SCAN_FMT
+ ",label=%i,proto=%"SCNi8",tclass=0x%"SCNx8
+ ",hlimit=%"SCNi8"),",
+ sip6_s, dip6_s, &label, &ip6->ip6_nxt,
+ &tclass, &ip6->ip6_hlim)
+ || (label & ~IPV6_LABEL_MASK) != 0
+ || inet_pton(AF_INET6, sip6_s, &sip6) != 1
+ || inet_pton(AF_INET6, dip6_s, &dip6) != 1) {
+ return -EINVAL;
+ }
+ put_16aligned_be32(&ip6->ip6_flow, htonl(6 << 28) |
+ htonl(tclass << 20) | htonl(label));
+ memcpy(&ip6->ip6_src, &sip6, sizeof(ip6->ip6_src));
+ memcpy(&ip6->ip6_dst, &dip6, sizeof(ip6->ip6_dst));
+ ip_len = sizeof *ip6;
}
- put_16aligned_be32(&ip->ip_src, sip);
- put_16aligned_be32(&ip->ip_dst, dip);
/* Tunnel header */
+ l4 = ((uint8_t *) l3 + ip_len);
udp = (struct udp_header *) l4;
greh = (struct gre_base_hdr *) l4;
if (ovs_scan_len(s, &n, "udp(src=%"SCNi16",dst=%"SCNi16",csum=0x%"SCNx16"),",
- &udp_src, &udp_dst, &csum)) {
+ &udp_src, &udp_dst, &csum)) {
uint32_t vx_flags, vni;
udp->udp_src = htons(udp_src);
udp->udp_csum = htons(csum);
if (ovs_scan_len(s, &n, "vxlan(flags=0x%"SCNx32",vni=0x%"SCNx32"))",
- &vx_flags, &vni)) {
+ &vx_flags, &vni)) {
struct vxlanhdr *vxh = (struct vxlanhdr *) (udp + 1);
put_16aligned_be32(&vxh->vx_flags, htonl(vx_flags));
put_16aligned_be32(&vxh->vx_vni, htonl(vni << 8));
tnl_type = OVS_VPORT_TYPE_VXLAN;
- header_len = sizeof *eth + sizeof *ip +
+ header_len = sizeof *eth + ip_len +
sizeof *udp + sizeof *vxh;
} else if (ovs_scan_len(s, &n, "geneve(")) {
struct genevehdr *gnh = (struct genevehdr *) (udp + 1);
memset(gnh, 0, sizeof *gnh);
+ header_len = sizeof *eth + ip_len +
+ sizeof *udp + sizeof *gnh;
+
if (ovs_scan_len(s, &n, "oam,")) {
gnh->oam = 1;
}
- if (!ovs_scan_len(s, &n, "vni=0x%"SCNx32"))", &vni)) {
+ if (ovs_scan_len(s, &n, "crit,")) {
+ gnh->critical = 1;
+ }
+ if (!ovs_scan_len(s, &n, "vni=%"SCNi32, &vni)) {
+ return -EINVAL;
+ }
+ if (ovs_scan_len(s, &n, ",options(")) {
+ struct geneve_scan options;
+ int len;
+
+ memset(&options, 0, sizeof options);
+ len = scan_geneve(s + n, &options, NULL);
+ if (!len) {
+ return -EINVAL;
+ }
+
+ memcpy(gnh->options, options.d, options.len);
+ gnh->opt_len = options.len / 4;
+ header_len += options.len;
+
+ n += len;
+ }
+ if (!ovs_scan_len(s, &n, "))")) {
return -EINVAL;
}
+
gnh->proto_type = htons(ETH_TYPE_TEB);
put_16aligned_be32(&gnh->vni, htonl(vni << 8));
tnl_type = OVS_VPORT_TYPE_GENEVE;
- header_len = sizeof *eth + sizeof *ip +
- sizeof *udp + sizeof *gnh;
} else {
return -EINVAL;
}
} else if (ovs_scan_len(s, &n, "gre((flags=0x%"SCNx16",proto=0x%"SCNx16")",
- &gre_flags, &gre_proto)){
+ &gre_flags, &gre_proto)){
+
+ tnl_type = OVS_VPORT_TYPE_GRE;
+ greh->flags = htons(gre_flags);
+ greh->protocol = htons(gre_proto);
+ ovs_16aligned_be32 *options = (ovs_16aligned_be32 *) (greh + 1);
+
+ if (greh->flags & htons(GRE_CSUM)) {
+ if (!ovs_scan_len(s, &n, ",csum=0x%"SCNx16, &csum)) {
+ return -EINVAL;
+ }
+
+ memset(options, 0, sizeof *options);
+ *((ovs_be16 *)options) = htons(csum);
+ options++;
+ }
+ if (greh->flags & htons(GRE_KEY)) {
+ uint32_t key;
+
+ if (!ovs_scan_len(s, &n, ",key=0x%"SCNx32, &key)) {
+ return -EINVAL;
+ }
+
+ put_16aligned_be32(options, htonl(key));
+ options++;
+ }
+ if (greh->flags & htons(GRE_SEQ)) {
+ uint32_t seq;
+
+ if (!ovs_scan_len(s, &n, ",seq=0x%"SCNx32, &seq)) {
+ return -EINVAL;
+ }
+ put_16aligned_be32(options, htonl(seq));
+ options++;
+ }
+
+ if (!ovs_scan_len(s, &n, "))")) {
+ return -EINVAL;
+ }
+
+ header_len = sizeof *eth + ip_len +
+ ((uint8_t *) options - (uint8_t *) greh);
+ } else {
+ return -EINVAL;
+ }
+
+ /* check tunnel meta data. */
+ if (data->tnl_type != tnl_type) {
+ return -EINVAL;
+ }
+ if (data->header_len != header_len) {
+ return -EINVAL;
+ }
+
+ /* Out port */
+ if (!ovs_scan_len(s, &n, ",out_port(%"SCNi32"))", &data->out_port)) {
+ return -EINVAL;
+ }
+
+ return n;
+}
+
+struct ct_nat_params {
+ bool snat;
+ bool dnat;
+ size_t addr_len;
+ union {
+ ovs_be32 ip;
+ struct in6_addr ip6;
+ } addr_min;
+ union {
+ ovs_be32 ip;
+ struct in6_addr ip6;
+ } addr_max;
+ uint16_t proto_min;
+ uint16_t proto_max;
+ bool persistent;
+ bool proto_hash;
+ bool proto_random;
+};
+
+static int
+scan_ct_nat_range(const char *s, int *n, struct ct_nat_params *p)
+{
+ if (ovs_scan_len(s, n, "=")) {
+ char ipv6_s[IPV6_SCAN_LEN + 1];
+ struct in6_addr ipv6;
+
+ if (ovs_scan_len(s, n, IP_SCAN_FMT, IP_SCAN_ARGS(&p->addr_min.ip))) {
+ p->addr_len = sizeof p->addr_min.ip;
+ if (ovs_scan_len(s, n, "-")) {
+ if (!ovs_scan_len(s, n, IP_SCAN_FMT,
+ IP_SCAN_ARGS(&p->addr_max.ip))) {
+ return -EINVAL;
+ }
+ }
+ } else if ((ovs_scan_len(s, n, IPV6_SCAN_FMT, ipv6_s)
+ || ovs_scan_len(s, n, "["IPV6_SCAN_FMT"]", ipv6_s))
+ && inet_pton(AF_INET6, ipv6_s, &ipv6) == 1) {
+ p->addr_len = sizeof p->addr_min.ip6;
+ p->addr_min.ip6 = ipv6;
+ if (ovs_scan_len(s, n, "-")) {
+ if ((ovs_scan_len(s, n, IPV6_SCAN_FMT, ipv6_s)
+ || ovs_scan_len(s, n, "["IPV6_SCAN_FMT"]", ipv6_s))
+ && inet_pton(AF_INET6, ipv6_s, &ipv6) == 1) {
+ p->addr_max.ip6 = ipv6;
+ } else {
+ return -EINVAL;
+ }
+ }
+ } else {
+ return -EINVAL;
+ }
+ if (ovs_scan_len(s, n, ":%"SCNu16, &p->proto_min)) {
+ if (ovs_scan_len(s, n, "-")) {
+ if (!ovs_scan_len(s, n, "%"SCNu16, &p->proto_max)) {
+ return -EINVAL;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+static int
+scan_ct_nat(const char *s, struct ct_nat_params *p)
+{
+ int n = 0;
+
+ if (ovs_scan_len(s, &n, "nat")) {
+ memset(p, 0, sizeof *p);
+
+ if (ovs_scan_len(s, &n, "(")) {
+ char *end;
+ int end_n;
+
+ end = strchr(s + n, ')');
+ if (!end) {
+ return -EINVAL;
+ }
+ end_n = end - s;
+
+ while (n < end_n) {
+ n += strspn(s + n, delimiters);
+ if (ovs_scan_len(s, &n, "src")) {
+ int err = scan_ct_nat_range(s, &n, p);
+ if (err) {
+ return err;
+ }
+ p->snat = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "dst")) {
+ int err = scan_ct_nat_range(s, &n, p);
+ if (err) {
+ return err;
+ }
+ p->dnat = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "persistent")) {
+ p->persistent = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "hash")) {
+ p->proto_hash = true;
+ continue;
+ }
+ if (ovs_scan_len(s, &n, "random")) {
+ p->proto_random = true;
+ continue;
+ }
+ return -EINVAL;
+ }
+
+ if (p->snat && p->dnat) {
+ return -EINVAL;
+ }
+ if ((p->addr_len != 0 &&
+ memcmp(&p->addr_max, &in6addr_any, p->addr_len) &&
+ memcmp(&p->addr_max, &p->addr_min, p->addr_len) < 0) ||
+ (p->proto_max && p->proto_max < p->proto_min)) {
+ return -EINVAL;
+ }
+ if (p->proto_hash && p->proto_random) {
+ return -EINVAL;
+ }
+ n++;
+ }
+ }
+ return n;
+}
+
+static void
+nl_msg_put_ct_nat(struct ct_nat_params *p, struct ofpbuf *actions)
+{
+ size_t start = nl_msg_start_nested(actions, OVS_CT_ATTR_NAT);
+
+ if (p->snat) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_SRC);
+ } else if (p->dnat) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_DST);
+ } else {
+ goto out;
+ }
+ if (p->addr_len != 0) {
+ nl_msg_put_unspec(actions, OVS_NAT_ATTR_IP_MIN, &p->addr_min,
+ p->addr_len);
+ if (memcmp(&p->addr_max, &p->addr_min, p->addr_len) > 0) {
+ nl_msg_put_unspec(actions, OVS_NAT_ATTR_IP_MAX, &p->addr_max,
+ p->addr_len);
+ }
+ if (p->proto_min) {
+ nl_msg_put_u16(actions, OVS_NAT_ATTR_PROTO_MIN, p->proto_min);
+ if (p->proto_max && p->proto_max > p->proto_min) {
+ nl_msg_put_u16(actions, OVS_NAT_ATTR_PROTO_MAX, p->proto_max);
+ }
+ }
+ if (p->persistent) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_PERSISTENT);
+ }
+ if (p->proto_hash) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_PROTO_HASH);
+ }
+ if (p->proto_random) {
+ nl_msg_put_flag(actions, OVS_NAT_ATTR_PROTO_RANDOM);
+ }
+ }
+out:
+ nl_msg_end_nested(actions, start);
+}
+
+static int
+parse_conntrack_action(const char *s_, struct ofpbuf *actions)
+{
+ const char *s = s_;
+
+ if (ovs_scan(s, "ct")) {
+ const char *helper = NULL;
+ size_t helper_len = 0;
+ bool commit = false;
+ bool force_commit = false;
+ uint16_t zone = 0;
+ struct {
+ uint32_t value;
+ uint32_t mask;
+ } ct_mark = { 0, 0 };
+ struct {
+ ovs_u128 value;
+ ovs_u128 mask;
+ } ct_label;
+ struct ct_nat_params nat_params;
+ bool have_nat = false;
+ size_t start;
+ char *end;
+
+ memset(&ct_label, 0, sizeof(ct_label));
+
+ s += 2;
+ if (ovs_scan(s, "(")) {
+ s++;
+find_end:
+ end = strchr(s, ')');
+ if (!end) {
+ return -EINVAL;
+ }
+
+ while (s != end) {
+ int n;
+
+ s += strspn(s, delimiters);
+ if (ovs_scan(s, "commit%n", &n)) {
+ commit = true;
+ 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;
+ }
+ if (ovs_scan(s, "mark=%"SCNx32"%n", &ct_mark.value, &n)) {
+ s += n;
+ n = -1;
+ if (ovs_scan(s, "/%"SCNx32"%n", &ct_mark.mask, &n)) {
+ s += n;
+ } else {
+ ct_mark.mask = UINT32_MAX;
+ }
+ continue;
+ }
+ if (ovs_scan(s, "label=%n", &n)) {
+ int retval;
+
+ s += n;
+ retval = scan_u128(s, &ct_label.value, &ct_label.mask);
+ if (retval < 0) {
+ return retval;
+ }
+ s += retval;
+ continue;
+ }
+ if (ovs_scan(s, "helper=%n", &n)) {
+ s += n;
+ helper_len = strcspn(s, delimiters_end);
+ if (!helper_len || helper_len > 15) {
+ return -EINVAL;
+ }
+ helper = s;
+ s += helper_len;
+ continue;
+ }
+
+ n = scan_ct_nat(s, &nat_params);
+ if (n > 0) {
+ s += n;
+ have_nat = true;
+
+ /* end points to the end of the nested, nat action.
+ * find the real end. */
+ goto find_end;
+ }
+ /* Nothing matched. */
+ return -EINVAL;
+ }
+ 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);
+ }
+ if (ct_mark.mask) {
+ nl_msg_put_unspec(actions, OVS_CT_ATTR_MARK, &ct_mark,
+ sizeof(ct_mark));
+ }
+ if (!ovs_u128_is_zero(ct_label.mask)) {
+ nl_msg_put_unspec(actions, OVS_CT_ATTR_LABELS, &ct_label,
+ sizeof ct_label);
+ }
+ if (helper) {
+ nl_msg_put_string__(actions, OVS_CT_ATTR_HELPER, helper,
+ helper_len);
+ }
+ if (have_nat) {
+ nl_msg_put_ct_nat(&nat_params, actions);
+ }
+ nl_msg_end_nested(actions, start);
+ }
+
+ 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;
- tnl_type = OVS_VPORT_TYPE_GRE;
- greh->flags = htons(gre_flags);
- greh->protocol = htons(gre_proto);
- ovs_16aligned_be32 *options = (ovs_16aligned_be32 *) (greh + 1);
+ if (!ovs_scan_len(s, &n, "encap_nsh(")) {
+ ret = -EINVAL;
+ goto out;
+ }
- if (greh->flags & htons(GRE_CSUM)) {
- if (!ovs_scan_len(s, &n, ",csum=0x%"SCNx16, &csum)) {
- return -EINVAL;
- }
+ /* 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);
- memset(options, 0, sizeof *options);
- *((ovs_be16 *)options) = htons(csum);
- options++;
+ for (;;) {
+ n += strspn(s + n, delimiters);
+ if (s[n] == ')') {
+ break;
}
- if (greh->flags & htons(GRE_KEY)) {
- uint32_t key;
- if (!ovs_scan_len(s, &n, ",key=0x%"SCNx32, &key)) {
- return -EINVAL;
+ 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;
}
-
- put_16aligned_be32(options, htonl(key));
- options++;
+ continue;
}
- if (greh->flags & htons(GRE_SEQ)) {
- uint32_t seq;
-
- if (!ovs_scan_len(s, &n, ",seq=0x%"SCNx32, &seq)) {
- return -EINVAL;
+ 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;
}
- put_16aligned_be32(options, htonl(seq));
- options++;
}
-
- if (!ovs_scan_len(s, &n, "))")) {
- return -EINVAL;
+ 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;
}
-
- header_len = sizeof *eth + sizeof *ip +
- ((uint8_t *) options - (uint8_t *) greh);
+ }
+out:
+ if (ret < 0) {
+ return ret;
} else {
- return -EINVAL;
+ 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;
}
+}
- /* check tunnel meta data. */
- if (data->tnl_type != tnl_type) {
- return -EINVAL;
- }
- if (data->header_len != header_len) {
- return -EINVAL;
- }
+static int
+parse_action_list(const char *s, const struct simap *port_names,
+ struct ofpbuf *actions)
+{
+ int n = 0;
- /* Out port */
- if (!ovs_scan_len(s, &n, ",out_port(%"SCNi32"))", &data->out_port)) {
- return -EINVAL;
+ 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;
}
}
+ {
+ 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;
}
}
+ {
+ int retval;
+
+ retval = parse_conntrack_action(s, actions);
+ if (retval) {
+ return retval;
+ }
+ }
+
{
struct ovs_action_push_tnl data;
int n;
[OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS] = { .len = ATTR_LEN_NESTED,
.next = ovs_vxlan_ext_attr_lens ,
.next_max = OVS_VXLAN_EXT_MAX},
+ [OVS_TUNNEL_KEY_ATTR_IPV6_SRC] = { .len = 16 },
+ [OVS_TUNNEL_KEY_ATTR_IPV6_DST] = { .len = 16 },
};
static const struct attr_len_tbl ovs_flow_key_attr_lens[OVS_KEY_ATTR_MAX + 1] = {
[OVS_KEY_ATTR_ICMPV6] = { .len = sizeof(struct ovs_key_icmpv6) },
[OVS_KEY_ATTR_ARP] = { .len = sizeof(struct ovs_key_arp) },
[OVS_KEY_ATTR_ND] = { .len = sizeof(struct ovs_key_nd) },
+ [OVS_KEY_ATTR_CT_STATE] = { .len = 4 },
+ [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;
}
}
}
-#define GENEVE_OPT(class, type) ((OVS_FORCE uint32_t)(class) << 8 | (type))
-static int
-parse_geneve_opts(const struct nlattr *attr)
-{
- int opts_len = nl_attr_get_size(attr);
- const struct geneve_opt *opt = nl_attr_get(attr);
-
- while (opts_len > 0) {
- int len;
-
- if (opts_len < sizeof(*opt)) {
- return -EINVAL;
- }
-
- len = sizeof(*opt) + opt->length * 4;
- if (len > opts_len) {
- return -EINVAL;
- }
-
- switch (GENEVE_OPT(opt->opt_class, opt->type)) {
- default:
- if (opt->type & GENEVE_CRIT_OPT_TYPE) {
- return -EINVAL;
- }
- };
-
- opt = opt + len / sizeof(*opt);
- opts_len -= len;
- };
-
- return 0;
-}
-
-enum odp_key_fitness
-odp_tun_key_from_attr(const struct nlattr *attr, struct flow_tnl *tun)
+static enum odp_key_fitness
+odp_tun_key_from_attr__(const struct nlattr *attr, bool is_mask,
+ struct flow_tnl *tun)
{
unsigned int left;
const struct nlattr *a;
case OVS_TUNNEL_KEY_ATTR_IPV4_DST:
tun->ip_dst = nl_attr_get_be32(a);
break;
+ case OVS_TUNNEL_KEY_ATTR_IPV6_SRC:
+ tun->ipv6_src = nl_attr_get_in6_addr(a);
+ break;
+ case OVS_TUNNEL_KEY_ATTR_IPV6_DST:
+ tun->ipv6_dst = nl_attr_get_in6_addr(a);
+ break;
case OVS_TUNNEL_KEY_ATTR_TOS:
tun->ip_tos = nl_attr_get_u8(a);
break;
break;
}
- case OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS: {
- if (parse_geneve_opts(a)) {
- return ODP_FIT_ERROR;
- }
- /* It is necessary to reproduce options exactly (including order)
- * so it's easiest to just echo them back. */
- unknown = true;
+ case OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS:
+ tun_metadata_from_geneve_nlattr(a, is_mask, tun);
break;
- }
+
default:
/* Allow this to show up as unexpected, if there are unknown
* tunnel attribute, eventually resulting in ODP_FIT_TOO_MUCH. */
return ODP_FIT_PERFECT;
}
+enum odp_key_fitness
+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, false, tun);
+}
+
static void
-tun_key_to_attr(struct ofpbuf *a, const struct flow_tnl *tun_key)
+tun_key_to_attr(struct ofpbuf *a, const struct flow_tnl *tun_key,
+ const struct flow_tnl *tun_flow_key,
+ const struct ofpbuf *key_buf)
{
size_t tun_key_ofs;
if (tun_key->ip_dst) {
nl_msg_put_be32(a, OVS_TUNNEL_KEY_ATTR_IPV4_DST, tun_key->ip_dst);
}
+ if (ipv6_addr_is_set(&tun_key->ipv6_src)) {
+ nl_msg_put_in6_addr(a, OVS_TUNNEL_KEY_ATTR_IPV6_SRC, &tun_key->ipv6_src);
+ }
+ if (ipv6_addr_is_set(&tun_key->ipv6_dst)) {
+ nl_msg_put_in6_addr(a, OVS_TUNNEL_KEY_ATTR_IPV6_DST, &tun_key->ipv6_dst);
+ }
if (tun_key->ip_tos) {
nl_msg_put_u8(a, OVS_TUNNEL_KEY_ATTR_TOS, tun_key->ip_tos);
}
(tun_key->gbp_flags << 16) | ntohs(tun_key->gbp_id));
nl_msg_end_nested(a, vxlan_opts_ofs);
}
+ tun_metadata_to_geneve_nlattr(tun_key, tun_flow_key, key_buf, a);
nl_msg_end_nested(a, tun_key_ofs);
}
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));
-}
+ /* 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;
-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;
+ switch (attr) {
+ case OVS_KEY_ATTR_UNSPEC:
+ case OVS_KEY_ATTR_ENCAP:
+ case __OVS_KEY_ATTR_MAX:
+ default:
+ return false;
- 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) {
- const struct flow_tnl *tun_mask = mask;
+ 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);
- return tun_mask->flags == FLOW_TNL_F_MASK
- && tun_mask->tun_id == OVS_BE64_MAX
- && tun_mask->ip_src == OVS_BE32_MAX
- && tun_mask->ip_dst == OVS_BE32_MAX
- && tun_mask->ip_tos == UINT8_MAX
- && tun_mask->ip_ttl == UINT8_MAX
- && tun_mask->tp_src == OVS_BE16_MAX
- && tun_mask->tp_dst == OVS_BE16_MAX
- && tun_mask->gbp_id == OVS_BE16_MAX
- && tun_mask->gbp_flags == UINT8_MAX;
+ 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);
}
+}
+
+/* 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);
+}
- return is_all_ones(mask, size);
+/* 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)
{
- struct flow_tnl tun_mask;
enum ovs_key_attr attr = nl_attr_type(ma);
- const void *mask;
- size_t size;
-
- if (attr == OVS_KEY_ATTR_TUNNEL) {
- memset(&tun_mask, 0, sizeof tun_mask);
- odp_tun_key_from_attr(ma, &tun_mask);
- mask = &tun_mask;
- size = sizeof tun_mask;
- } 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
-format_eth(struct ds *ds, const char *name, const uint8_t key[ETH_ADDR_LEN],
- const uint8_t (*mask)[ETH_ADDR_LEN], bool verbose)
+format_eth(struct ds *ds, const char *name, const struct eth_addr key,
+ const struct eth_addr *mask, bool verbose)
{
bool mask_empty = mask && eth_addr_is_zero(*mask);
ds_put_format(ds, "%s="ETH_ADDR_FMT",", name, ETH_ADDR_ARGS(key));
} else {
ds_put_format(ds, "%s=", name);
- eth_format_masked(key, *mask, ds);
+ eth_format_masked(key, mask, ds);
ds_put_char(ds, ',');
}
}
}
+
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(struct ds *ds, const char *name,
+ const struct in6_addr *key,
+ const struct in6_addr *mask,
+ bool verbose)
{
char buf[INET6_ADDRSTRLEN];
- const struct in6_addr *key = (const struct in6_addr *)key_;
- const struct in6_addr *mask = mask_ ? (const struct in6_addr *)*mask_
- : NULL;
bool mask_empty = mask && ipv6_mask_is_any(mask);
if (verbose || !mask_empty) {
bool mask_empty = mask && !*mask;
if (verbose || !mask_empty) {
- bool mask_full = !mask || (*mask & FLOW_TNL_F_MASK) == FLOW_TNL_F_MASK;
-
ds_put_cstr(ds, name);
ds_put_char(ds, '(');
- if (!mask_full) { /* Partially masked. */
- format_flags_masked(ds, NULL, flow_tun_flag_to_string, key, *mask);
+ if (mask) {
+ format_flags_masked(ds, NULL, flow_tun_flag_to_string, key,
+ *mask & FLOW_TNL_F_MASK, FLOW_TNL_F_MASK);
} else { /* Fully masked. */
- format_flags(ds, flow_tun_flag_to_string, key, ',');
+ format_flags(ds, flow_tun_flag_to_string, key, '|');
}
ds_put_cstr(ds, "),");
}
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;
ofpbuf_clear(&ofp);
}
- ds_chomp(ds, ',');
- ofpbuf_uninit(&ofp);
-}
-
-#define MASK(PTR, FIELD) PTR ? &PTR->FIELD : NULL
-
-static void
-format_odp_tun_geneve(const struct nlattr *attr,
- const struct nlattr *mask_attr, struct ds *ds,
- bool verbose)
-{
- int opts_len = nl_attr_get_size(attr);
- const struct geneve_opt *opt = nl_attr_get(attr);
- const struct geneve_opt *mask = mask_attr ?
- nl_attr_get(mask_attr) : NULL;
-
- if (mask && nl_attr_get_size(attr) != nl_attr_get_size(mask_attr)) {
- ds_put_format(ds, "value len %"PRIuSIZE" different from mask len %"PRIuSIZE,
- nl_attr_get_size(attr), nl_attr_get_size(mask_attr));
- return;
- }
+ ds_chomp(ds, ',');
+ ofpbuf_uninit(&ofp);
+}
+
+#define MASK(PTR, FIELD) PTR ? &PTR->FIELD : NULL
+static void
+format_geneve_opts(const struct geneve_opt *opt,
+ const struct geneve_opt *mask, int opts_len,
+ struct ds *ds, bool verbose)
+{
while (opts_len > 0) {
unsigned int len;
uint8_t data_len, data_len_mask;
verbose);
format_u8x(ds, "type", opt->type, MASK(mask, type), verbose);
format_u8u(ds, "len", data_len, mask ? &data_len_mask : NULL, verbose);
- if (verbose || !mask || !is_all_zeros(mask + 1, data_len)) {
+ if (data_len &&
+ (verbose || !mask || !is_all_zeros(mask + 1, data_len))) {
ds_put_hex(ds, opt + 1, data_len);
if (mask && !is_all_ones(mask + 1, data_len)) {
ds_put_char(ds, '/');
};
}
+static void
+format_odp_tun_geneve(const struct nlattr *attr,
+ const struct nlattr *mask_attr, struct ds *ds,
+ bool verbose)
+{
+ int opts_len = nl_attr_get_size(attr);
+ const struct geneve_opt *opt = nl_attr_get(attr);
+ const struct geneve_opt *mask = mask_attr ?
+ nl_attr_get(mask_attr) : NULL;
+
+ if (mask && nl_attr_get_size(attr) != nl_attr_get_size(mask_attr)) {
+ ds_put_format(ds, "value len %"PRIuSIZE" different from mask len %"PRIuSIZE,
+ nl_attr_get_size(attr), nl_attr_get_size(mask_attr));
+ return;
+ }
+
+ format_geneve_opts(opt, mask, opts_len, ds, verbose);
+}
+
static void
format_odp_tun_attr(const struct nlattr *attr, const struct nlattr *mask_attr,
struct ds *ds, bool verbose)
format_ipv4(ds, "dst", nl_attr_get_be32(a),
ma ? nl_attr_get(ma) : NULL, verbose);
break;
+ case OVS_TUNNEL_KEY_ATTR_IPV6_SRC: {
+ struct in6_addr ipv6_src;
+ ipv6_src = nl_attr_get_in6_addr(a);
+ format_in6_addr(ds, "ipv6_src", &ipv6_src,
+ ma ? nl_attr_get(ma) : NULL, verbose);
+ break;
+ }
+ case OVS_TUNNEL_KEY_ATTR_IPV6_DST: {
+ struct in6_addr ipv6_dst;
+ ipv6_dst = nl_attr_get_in6_addr(a);
+ format_in6_addr(ds, "ipv6_dst", &ipv6_dst,
+ ma ? nl_attr_get(ma) : NULL, verbose);
+ break;
+ }
case OVS_TUNNEL_KEY_ATTR_TOS:
format_u8x(ds, "tos", nl_attr_get_u8(a),
ma ? nl_attr_get(ma) : NULL, verbose);
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);
ofpbuf_uninit(&ofp);
}
+static const char *
+odp_ct_state_to_string(uint32_t flag)
+{
+ switch (flag) {
+ case OVS_CS_F_REPLY_DIR:
+ return "rpl";
+ case OVS_CS_F_TRACKED:
+ return "trk";
+ case OVS_CS_F_NEW:
+ return "new";
+ case OVS_CS_F_ESTABLISHED:
+ return "est";
+ case OVS_CS_F_RELATED:
+ return "rel";
+ case OVS_CS_F_INVALID:
+ return "inv";
+ case OVS_CS_F_SRC_NAT:
+ return "snat";
+ case OVS_CS_F_DST_NAT:
+ return "dnat";
+ default:
+ return NULL;
+ }
+}
+
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_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));
+ }
+}
- 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));
- }
+static bool
+mask_empty(const struct nlattr *ma)
+{
+ const void *mask;
+ size_t n;
+
+ if (!ma) {
+ return true;
}
+ mask = nl_attr_get(ma);
+ n = nl_attr_get_size(ma);
+
+ 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_MARK:
+ if (verbose || !mask_empty(ma)) {
+ ds_put_format(ds, "%#"PRIx32, nl_attr_get_u32(a));
+ if (!is_exact) {
+ ds_put_format(ds, "/%#"PRIx32, nl_attr_get_u32(ma));
+ }
+ }
+ break;
+
+ case OVS_KEY_ATTR_CT_STATE:
+ if (verbose) {
+ ds_put_format(ds, "%#"PRIx32, nl_attr_get_u32(a));
+ if (!is_exact) {
+ ds_put_format(ds, "/%#"PRIx32,
+ mask_empty(ma) ? 0 : nl_attr_get_u32(ma));
+ }
+ } else if (!is_exact) {
+ format_flags_masked(ds, NULL, odp_ct_state_to_string,
+ nl_attr_get_u32(a),
+ mask_empty(ma) ? 0 : nl_attr_get_u32(ma),
+ UINT32_MAX);
+ } else {
+ format_flags(ds, odp_ct_state_to_string, nl_attr_get_u32(a), '|');
+ }
+ break;
+
+ case OVS_KEY_ATTR_CT_ZONE:
+ if (verbose || !mask_empty(ma)) {
+ ds_put_format(ds, "%#"PRIx16, nl_attr_get_u16(a));
+ if (!is_exact) {
+ ds_put_format(ds, "/%#"PRIx16, nl_attr_get_u16(ma));
+ }
+ }
+ break;
+
+ case OVS_KEY_ATTR_CT_LABELS: {
+ 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, ',');
if (!is_exact) {
format_flags_masked(ds, NULL, packet_tcp_flag_to_string,
ntohs(nl_attr_get_be16(a)),
- ntohs(nl_attr_get_be16(ma)));
+ TCP_FLAGS(nl_attr_get_be16(ma)),
+ TCP_FLAGS(OVS_BE16_MAX));
} else {
format_flags(ds, packet_tcp_flag_to_string,
- ntohs(nl_attr_get_be16(a)), ',');
+ ntohs(nl_attr_get_be16(a)), '|');
}
break;
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)
return ofp->base;
}
+static void
+format_u128(struct ds *ds, const ovs_32aligned_u128 *key,
+ const ovs_32aligned_u128 *mask, bool verbose)
+{
+ 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(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)
+{
+ char *s = CONST_CAST(char *, s_);
+ ovs_be128 be_value;
+ ovs_be128 be_mask;
+
+ if (!parse_int_string(s, (uint8_t *)&be_value, sizeof be_value, &s)) {
+ *value = ntoh128(be_value);
+
+ if (mask) {
+ int n;
+
+ if (ovs_scan(s, "/%n", &n)) {
+ int error;
+
+ s += n;
+ error = parse_int_string(s, (uint8_t *)&be_mask,
+ sizeof be_mask, &s);
+ if (error) {
+ return error;
+ }
+ *mask = ntoh128(be_mask);
+ } else {
+ *mask = OVS_U128_MAX;
+ }
+ }
+ return s - s_;
+ }
+
+ return 0;
+}
+
int
odp_ufid_from_string(const char *s_, ovs_u128 *ufid)
{
const char *s = s_;
if (ovs_scan(s, "ufid:")) {
- size_t n;
-
s += 5;
- if (ovs_scan(s, "0x")) {
- s += 2;
- }
-
- n = strspn(s, hex_chars);
- if (n != 32) {
- return -EINVAL;
- }
- if (!ovs_scan(s, "%16"SCNx64"%16"SCNx64, &ufid->u64.hi,
- &ufid->u64.lo)) {
+ if (!uuid_from_string_prefix((struct uuid *)ufid, s)) {
return -EINVAL;
}
- s += n;
- s += strspn(s, delimiters);
+ s += UUID_LEN;
return s - s_;
}
void
odp_format_ufid(const ovs_u128 *ufid, struct ds *ds)
{
- ds_put_format(ds, "ufid:%016"PRIx64"%016"PRIx64, ufid->u64.hi,
- ufid->u64.lo);
+ ds_put_format(ds, "ufid:"UUID_FMT, UUID_ARGS((struct uuid *)ufid));
}
/* 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)));
/* Parsing. */
static int
-scan_eth(const char *s, uint8_t (*key)[ETH_ADDR_LEN],
- uint8_t (*mask)[ETH_ADDR_LEN])
+scan_eth(const char *s, struct eth_addr *key, struct eth_addr *mask)
{
int n;
- if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(*key), &n)) {
+ if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n",
+ ETH_ADDR_SCAN_ARGS(*key), &n)) {
int len = n;
if (mask) {
}
static int
-scan_ipv6(const char *s, ovs_be32 (*key)[4], ovs_be32 (*mask)[4])
+scan_in6_addr(const char *s, struct in6_addr *key, struct in6_addr *mask)
{
int n;
char ipv6_s[IPV6_SCAN_LEN + 1];
return 0;
}
+static int
+scan_u16(const char *s, uint16_t *key, uint16_t *mask)
+{
+ int n;
+
+ if (ovs_scan(s, "%"SCNi16"%n", key, &n)) {
+ int len = n;
+
+ if (mask) {
+ if (ovs_scan(s + len, "/%"SCNi16"%n", mask, &n)) {
+ len += n;
+ } else {
+ *mask = UINT16_MAX;
+ }
+ }
+ return len;
+ }
+ return 0;
+}
+
static int
scan_u32(const char *s, uint32_t *key, uint32_t *mask)
{
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, "/%"SCNi32"%n", &mask_, &n)) {
+ len += n;
+ *mask = htonl(mask_);
+ } else {
+ *mask = OVS_BE32_MAX;
+ }
+ }
+ return len;
+ }
+ return 0;
+}
+
static int
scan_be64(const char *s, ovs_be64 *key, ovs_be64 *mask)
{
uint32_t flags, fmask;
int n;
- n = parse_flags(s, flow_tun_flag_to_string, &flags,
- FLOW_TNL_F_MASK, mask ? &fmask : NULL);
+ n = parse_odp_flags(s, flow_tun_flag_to_string, &flags,
+ FLOW_TNL_F_MASK, mask ? &fmask : NULL);
if (n >= 0 && s[n] == ')') {
*key = flags;
if (mask) {
uint32_t flags, fmask;
int n;
- n = parse_flags(s, packet_tcp_flag_to_string, &flags,
- TCP_FLAGS(OVS_BE16_MAX), mask ? &fmask : NULL);
+ n = parse_odp_flags(s, packet_tcp_flag_to_string, &flags,
+ TCP_FLAGS(OVS_BE16_MAX), mask ? &fmask : NULL);
if (n >= 0) {
*key = htons(flags);
if (mask) {
return 0;
}
+static uint32_t
+ovs_to_odp_ct_state(uint8_t state)
+{
+ uint32_t odp = 0;
+
+#define CS_STATE(ENUM, INDEX, NAME) \
+ if (state & CS_##ENUM) { \
+ odp |= OVS_CS_F_##ENUM; \
+ }
+ CS_STATES
+#undef CS_STATE
+
+ return odp;
+}
+
+static uint8_t
+odp_to_ovs_ct_state(uint32_t flags)
+{
+ uint32_t state = 0;
+
+#define CS_STATE(ENUM, INDEX, NAME) \
+ if (flags & OVS_CS_F_##ENUM) { \
+ state |= CS_##ENUM; \
+ }
+ CS_STATES
+#undef CS_STATE
+
+ return state;
+}
+
+static int
+scan_ct_state(const char *s, uint32_t *key, uint32_t *mask)
+{
+ uint32_t flags, fmask;
+ int n;
+
+ n = parse_flags(s, odp_ct_state_to_string, ')', NULL, NULL, &flags,
+ ovs_to_odp_ct_state(CS_SUPPORTED_MASK),
+ mask ? &fmask : NULL);
+
+ if (n >= 0) {
+ *key = flags;
+ if (mask) {
+ *mask = fmask;
+ }
+ return n;
+ }
+ return 0;
+}
+
static int
scan_frag(const char *s, uint8_t *key, uint8_t *mask)
{
scan_vxlan_gbp(const char *s, uint32_t *key, uint32_t *mask)
{
const char *s_base = s;
- ovs_be16 id, id_mask;
- uint8_t flags, flags_mask;
+ ovs_be16 id = 0, id_mask = 0;
+ uint8_t flags = 0, flags_mask = 0;
if (!strncmp(s, "id=", 3)) {
s += 3;
s += scan_be16(s, &id, mask ? &id_mask : NULL);
- } else if (mask) {
- memset(&id_mask, 0, sizeof id_mask);
}
if (s[0] == ',') {
if (!strncmp(s, "flags=", 6)) {
s += 6;
s += scan_u8(s, &flags, mask ? &flags_mask : NULL);
- } else if (mask) {
- memset(&flags_mask, 0, sizeof flags_mask);
}
if (!strncmp(s, "))", 2)) {
return 0;
}
-struct geneve_scan {
- uint8_t d[252];
- int len;
-};
-
static int
scan_geneve(const char *s, struct geneve_scan *key, struct geneve_scan *mask)
{
const char *s_base = s;
- struct geneve_opt *opt = (struct geneve_opt *)key->d;
- struct geneve_opt *opt_mask = (struct geneve_opt *)(mask ? mask->d : NULL);
+ struct geneve_opt *opt = key->d;
+ struct geneve_opt *opt_mask = mask ? mask->d : NULL;
int len_remain = sizeof key->d;
while (s[0] == '{' && len_remain >= sizeof *opt) {
SCAN_FIELD_NESTED__(NAME, TYPE, SCAN_AS, 0, FUNC)
#define SCAN_PUT(ATTR, FUNC) \
- if (!mask || !is_all_zeros(&smask, sizeof smask)) { \
- SCAN_PUT_ATTR(key, ATTR, skey, FUNC); \
- if (mask) { \
- SCAN_PUT_ATTR(mask, ATTR, smask, FUNC); \
- } \
- }
+ SCAN_PUT_ATTR(key, ATTR, skey, FUNC); \
+ if (mask) \
+ SCAN_PUT_ATTR(mask, ATTR, smask, FUNC); \
#define SCAN_END(ATTR) \
SCAN_FINISH(); \
return s - start; \
}
+#define SCAN_BEGIN_ARRAY(NAME, TYPE, CNT) \
+ SCAN_IF(NAME); \
+ TYPE skey[CNT], smask[CNT]; \
+ memset(&skey, 0, sizeof skey); \
+ memset(&smask, 0, sizeof smask); \
+ int idx = 0, cnt = CNT; \
+ uint64_t fields = 0; \
+ do { \
+ int field = 0; \
+ len = 0;
+
+/* Scan named ('NAME') entry 'FIELD' as 'TYPE'. */
+#define SCAN_FIELD_ARRAY(NAME, TYPE, FIELD) \
+ if (strncmp(s, NAME, strlen(NAME)) == 0) { \
+ if (fields & (1UL << field)) { \
+ fields = 0; \
+ if (++idx == cnt) { \
+ break; \
+ } \
+ } \
+ s += strlen(NAME); \
+ SCAN_TYPE(TYPE, &skey[idx].FIELD, mask ? &smask[idx].FIELD : NULL); \
+ fields |= 1UL << field; \
+ continue; \
+ } \
+ field++;
+
+#define SCAN_PUT_ATTR_ARRAY(BUF, ATTR, DATA, CNT) \
+ nl_msg_put_unspec(BUF, ATTR, &(DATA), sizeof (DATA)[0] * (CNT)); \
+
+#define SCAN_PUT_ARRAY(ATTR, CNT) \
+ SCAN_PUT_ATTR_ARRAY(key, ATTR, skey, CNT); \
+ if (mask) { \
+ SCAN_PUT_ATTR_ARRAY(mask, ATTR, smask, CNT); \
+ }
+
+#define SCAN_END_ARRAY(ATTR) \
+ SCAN_FINISH(); \
+ if (idx == cnt) { \
+ return -EINVAL; \
+ } \
+ SCAN_PUT_ARRAY(ATTR, idx + 1); \
+ return s - start; \
+ }
+
#define SCAN_END_SINGLE(ATTR) \
SCAN_FINISH_SINGLE(); \
SCAN_PUT(ATTR, NULL); \
parse_odp_key_mask_attr(const char *s, const struct simap *port_names,
struct ofpbuf *key, struct ofpbuf *mask)
{
- if (!strncmp(s, "ufid:", 5)) {
- const char *start = s;
-
- /* Skip UFID. */
- s += 5;
- s += strspn(s, hex_chars);
- s += strspn(s, delimiters);
-
- return s - start;
+ /* Skip UFID. */
+ 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);
OVS_KEY_ATTR_RECIRC_ID);
SCAN_SINGLE("dp_hash(", uint32_t, u32, OVS_KEY_ATTR_DP_HASH);
+ SCAN_SINGLE("ct_state(", uint32_t, ct_state, OVS_KEY_ATTR_CT_STATE);
+ SCAN_SINGLE("ct_zone(", uint16_t, u16, OVS_KEY_ATTR_CT_ZONE);
+ 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_FIELD_NESTED("dst=", ovs_be32, ipv4, OVS_TUNNEL_KEY_ATTR_IPV4_DST);
+ SCAN_FIELD_NESTED("ipv6_src=", struct in6_addr, in6_addr, OVS_TUNNEL_KEY_ATTR_IPV6_SRC);
+ SCAN_FIELD_NESTED("ipv6_dst=", struct in6_addr, in6_addr, OVS_TUNNEL_KEY_ATTR_IPV6_DST);
SCAN_FIELD_NESTED("tos=", uint8_t, u8, OVS_TUNNEL_KEY_ATTR_TOS);
SCAN_FIELD_NESTED("ttl=", uint8_t, u8, OVS_TUNNEL_KEY_ATTR_TTL);
SCAN_FIELD_NESTED("tp_src=", ovs_be16, be16, OVS_TUNNEL_KEY_ATTR_TP_SRC);
SCAN_SINGLE("eth_type(", ovs_be16, be16, OVS_KEY_ATTR_ETHERTYPE);
- SCAN_BEGIN("mpls(", struct ovs_key_mpls) {
- SCAN_FIELD("label=", mpls_label, mpls_lse);
- SCAN_FIELD("tc=", mpls_tc, mpls_lse);
- SCAN_FIELD("ttl=", mpls_ttl, mpls_lse);
- SCAN_FIELD("bos=", mpls_bos, mpls_lse);
- } SCAN_END(OVS_KEY_ATTR_MPLS);
+ SCAN_BEGIN_ARRAY("mpls(", struct ovs_key_mpls, FLOW_MAX_MPLS_LABELS) {
+ SCAN_FIELD_ARRAY("label=", mpls_label, mpls_lse);
+ SCAN_FIELD_ARRAY("tc=", mpls_tc, mpls_lse);
+ SCAN_FIELD_ARRAY("ttl=", mpls_ttl, mpls_lse);
+ SCAN_FIELD_ARRAY("bos=", mpls_bos, mpls_lse);
+ } SCAN_END_ARRAY(OVS_KEY_ATTR_MPLS);
SCAN_BEGIN("ipv4(", struct ovs_key_ipv4) {
SCAN_FIELD("src=", ipv4, 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 {
static void put_tp_key(const union ovs_key_tp *, struct flow *);
static void
-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 recirc, bool export_mask)
+odp_flow_key_from_flow__(const struct odp_flow_key_parms *parms,
+ 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 *mask = parms->mask;
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 || export_mask) {
- tun_key_to_attr(buf, &data->tunnel);
+ if (flow_tnl_dst_is_set(&flow->tunnel) || export_mask) {
+ tun_key_to_attr(buf, &data->tunnel, &parms->flow->tunnel,
+ parms->key_buf);
}
nl_msg_put_u32(buf, OVS_KEY_ATTR_SKB_MARK, data->pkt_mark);
- if (recirc) {
+ if (parms->support.ct_state) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_STATE,
+ ovs_to_odp_ct_state(data->ct_state));
+ }
+ if (parms->support.ct_zone) {
+ nl_msg_put_u16(buf, OVS_KEY_ATTR_CT_ZONE, data->ct_zone);
+ }
+ if (parms->support.ct_mark) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_MARK, data->ct_mark);
+ }
+ if (parms->support.ct_label) {
+ 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 || odp_in_port != ODPP_NONE) {
- nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, 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;
int i, n;
n = flow_count_mpls_labels(flow, NULL);
- n = MIN(n, max_mpls_depth);
+ if (export_mask) {
+ n = MIN(n, parms->support.max_mpls_depth);
+ }
mpls_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_MPLS,
n * sizeof *mpls_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))
- && (!export_mask || (data->tp_src == htons(0xffff)
- && data->tp_dst == htons(0xffff)))) {
+ 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
+ * xlate_wc_finish() for details. */
+ && (!export_mask || (data->tp_src == htons(0xff)
+ && data->tp_dst == htons(0xff)))) {
struct ovs_key_nd *nd_key;
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);
- memcpy(nd_key->nd_sll, data->arp_sha, ETH_ADDR_LEN);
- memcpy(nd_key->nd_tll, data->arp_tha, ETH_ADDR_LEN);
+ 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]);
+ }
}
}
/* Appends a representation of 'flow' as OVS_KEY_ATTR_* attributes to 'buf'.
- * 'flow->in_port' is ignored (since it is likely to be an OpenFlow port
- * number rather than a datapath port number). Instead, if 'odp_in_port'
- * is anything other than ODPP_NONE, it is included in 'buf' as the input
- * port.
*
* 'buf' must have at least ODPUTIL_FLOW_KEY_BYTES bytes of space, or be
- * capable of being expanded to allow for that much space.
- *
- * 'recirc' indicates support for recirculation fields. If this is true, then
- * these fields will always be serialised. */
+ * capable of being expanded to allow for that much space. */
void
-odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow,
- const struct flow *mask, odp_port_t odp_in_port,
- bool recirc)
+odp_flow_key_from_flow(const struct odp_flow_key_parms *parms,
+ struct ofpbuf *buf)
{
- odp_flow_key_from_flow__(buf, flow, mask, odp_in_port, SIZE_MAX, recirc,
- false);
+ odp_flow_key_from_flow__(parms, false, buf);
}
/* Appends a representation of 'mask' as OVS_KEY_ATTR_* attributes to
- * 'buf'. 'flow' is used as a template to determine how to interpret
- * 'mask'. For example, the 'dl_type' of 'mask' describes the mask, but
- * it doesn't indicate whether the other fields should be interpreted as
- * ARP, IPv4, IPv6, etc.
+ * 'buf'.
*
* 'buf' must have at least ODPUTIL_FLOW_KEY_BYTES bytes of space, or be
- * capable of being expanded to allow for that much space.
- *
- * 'recirc' indicates support for recirculation fields. If this is true, then
- * these fields will always be serialised. */
+ * 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,
- size_t max_mpls_depth, bool recirc)
+odp_flow_key_from_mask(const struct odp_flow_key_parms *parms,
+ struct ofpbuf *buf)
{
- odp_flow_key_from_flow__(buf, flow, mask, u32_to_odp(odp_in_port_mask),
- max_mpls_depth, recirc, true);
+ odp_flow_key_from_flow__(parms, true, buf);
}
/* 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 (md->tunnel.ip_dst) {
- tun_key_to_attr(buf, &md->tunnel);
+ if (flow_tnl_dst_is_set(&md->tunnel)) {
+ tun_key_to_attr(buf, &md->tunnel, &md->tunnel, NULL);
}
nl_msg_put_u32(buf, OVS_KEY_ATTR_SKB_MARK, md->pkt_mark);
+ if (md->ct_state) {
+ nl_msg_put_u32(buf, OVS_KEY_ATTR_CT_STATE,
+ ovs_to_odp_ct_state(md->ct_state));
+ if (md->ct_zone) {
+ nl_msg_put_u16(buf, OVS_KEY_ATTR_CT_ZONE, md->ct_zone);
+ }
+ 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)) {
+ 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
* value "ODPP_NONE". */
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;
- *md = PKT_METADATA_INITIALIZER(ODPP_NONE);
+ 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));
+ break;
+ case OVS_KEY_ATTR_CT_ZONE:
+ md->ct_zone = nl_attr_get_u16(nla);
+ break;
+ case OVS_KEY_ATTR_CT_MARK:
+ md->ct_mark = nl_attr_get_u32(nla);
+ break;
+ case OVS_KEY_ATTR_CT_LABELS: {
+ 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_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, &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.");
}
}
odp_flow_key_hash(const struct nlattr *key, size_t key_len)
{
BUILD_ASSERT_DECL(!(NLA_ALIGNTO % sizeof(uint32_t)));
- return hash_words(ALIGNED_CAST(const uint32_t *, key),
- key_len / sizeof(uint32_t), 0);
+ return hash_bytes32(ALIGNED_CAST(const uint32_t *, key), key_len, 0);
}
static void
*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);
- memcpy(flow->arp_sha, nd_key->nd_sll, ETH_ADDR_LEN);
- memcpy(flow->arp_tha, nd_key->nd_tll, ETH_ADDR_LEN);
+ flow->nd_target = nd_key->nd_target;
+ flow->arp_sha = nd_key->nd_sll;
+ flow->arp_tha = nd_key->nd_tll;
if (is_mask) {
+ /* 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 xlate_wc_finish() for details.
+ * */
if (!is_all_zeros(nd_key, sizeof *nd_key) &&
- (flow->tp_src != htons(0xffff) ||
- flow->tp_dst != htons(0xffff))) {
+ (flow->tp_src != htons(0xff) ||
+ flow->tp_dst != htons(0xff))) {
return ODP_FIT_ERROR;
} else {
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ND;
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;
}
- 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));
+ } else {
+ if (!(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)) {
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);
expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_SKB_MARK;
}
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_STATE)) {
+ uint32_t odp_state = nl_attr_get_u32(attrs[OVS_KEY_ATTR_CT_STATE]);
+
+ flow->ct_state = odp_to_ovs_ct_state(odp_state);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_STATE;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_ZONE)) {
+ flow->ct_zone = nl_attr_get_u16(attrs[OVS_KEY_ATTR_CT_ZONE]);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_ZONE;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_MARK)) {
+ flow->ct_mark = nl_attr_get_u32(attrs[OVS_KEY_ATTR_CT_MARK]);
+ expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_CT_MARK;
+ }
+ if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_CT_LABELS)) {
+ 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], &flow->tunnel);
+ 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) {
- flow->vlan_tci = htons(0xffff);
+ /* A missing VLAN mask means exact match on vlan_tci 0 (== no VLAN). */
+ 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);
}
}
return odp_flow_key_to_flow__(key, key_len, flow, flow);
}
-/* Converts the 'key_len' bytes of OVS_KEY_ATTR_* attributes in 'key' to a mask
- * structure in 'mask'. 'flow' must be a previously translated flow
- * corresponding to 'mask'. Returns an ODP_FIT_* value that indicates how well
- * 'key' fits our expectations for what a flow key should contain. */
+/* 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 *key, size_t key_len,
- struct flow *mask, const struct flow *flow)
+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,
+ &mask->masks, src_flow);
+
+ } else {
+ /* A missing mask means that the flow should be exact matched.
+ * Generate an appropriate exact wildcard for the flow. */
+ flow_wildcards_init_for_packet(mask, src_flow);
+
+ return ODP_FIT_PERFECT;
+ }
+}
+
+/* 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, mask, flow);
+ enum odp_key_fitness fitness;
+
+ 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. */
odp_put_userspace_action(uint32_t pid,
const void *userdata, size_t userdata_size,
odp_port_t tunnel_out_port,
+ bool include_actions,
struct ofpbuf *odp_actions)
{
size_t userdata_ofs;
nl_msg_put_odp_port(odp_actions, OVS_USERSPACE_ATTR_EGRESS_TUN_PORT,
tunnel_out_port);
}
+ if (include_actions) {
+ nl_msg_put_flag(odp_actions, OVS_USERSPACE_ATTR_ACTIONS);
+ }
nl_msg_end_nested(odp_actions, offset);
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)
{
size_t offset = nl_msg_start_nested(odp_actions, OVS_ACTION_ATTR_SET);
- tun_key_to_attr(odp_actions, tunnel);
+ tun_key_to_attr(odp_actions, tunnel, tunnel, NULL);
nl_msg_end_nested(odp_actions, offset);
}
commit_odp_tunnel_action(const struct flow *flow, struct flow *base,
struct ofpbuf *odp_actions)
{
- /* A valid IPV4_TUNNEL must have non-zero ip_dst. */
- if (flow->tunnel.ip_dst) {
+ /* A valid IPV4_TUNNEL must have non-zero ip_dst; a valid IPv6 tunnel
+ * must have non-zero ipv6_dst. */
+ if (flow_tnl_dst_is_set(&flow->tunnel)) {
if (!memcmp(&base->tunnel, &flow->tunnel, sizeof base->tunnel)) {
return;
}
static void
get_ethernet_key(const struct flow *flow, struct ovs_key_ethernet *eth)
{
- memcpy(eth->eth_src, flow->dl_src, ETH_ADDR_LEN);
- memcpy(eth->eth_dst, flow->dl_dst, ETH_ADDR_LEN);
+ eth->eth_src = flow->dl_src;
+ eth->eth_dst = flow->dl_dst;
}
static void
put_ethernet_key(const struct ovs_key_ethernet *eth, struct flow *flow)
{
- memcpy(flow->dl_src, eth->eth_src, ETH_ADDR_LEN);
- memcpy(flow->dl_dst, eth->eth_dst, ETH_ADDR_LEN);
+ flow->dl_src = eth->eth_src;
+ flow->dl_dst = eth->eth_dst;
}
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;
arp->arp_sip = flow->nw_src;
arp->arp_tip = flow->nw_dst;
arp->arp_op = htons(flow->nw_proto);
- memcpy(arp->arp_sha, flow->arp_sha, ETH_ADDR_LEN);
- memcpy(arp->arp_tha, flow->arp_tha, ETH_ADDR_LEN);
+ arp->arp_sha = flow->arp_sha;
+ arp->arp_tha = flow->arp_tha;
}
static void
flow->nw_src = arp->arp_sip;
flow->nw_dst = arp->arp_tip;
flow->nw_proto = ntohs(arp->arp_op);
- memcpy(flow->arp_sha, arp->arp_sha, ETH_ADDR_LEN);
- memcpy(flow->arp_tha, arp->arp_tha, ETH_ADDR_LEN);
+ flow->arp_sha = arp->arp_sha;
+ flow->arp_tha = arp->arp_tha;
}
static enum slow_path_reason
return 0;
}
+static void
+get_icmp_key(const struct flow *flow, struct ovs_key_icmp *icmp)
+{
+ /* icmp_type and icmp_code are stored in tp_src and tp_dst, respectively */
+ icmp->icmp_type = ntohs(flow->tp_src);
+ icmp->icmp_code = ntohs(flow->tp_dst);
+}
+
+static void
+put_icmp_key(const struct ovs_key_icmp *icmp, struct flow *flow)
+{
+ /* icmp_type and icmp_code are stored in tp_src and tp_dst, respectively */
+ flow->tp_src = htons(icmp->icmp_type);
+ flow->tp_dst = htons(icmp->icmp_code);
+}
+
+static enum slow_path_reason
+commit_set_icmp_action(const struct flow *flow, struct flow *base_flow,
+ struct ofpbuf *odp_actions, struct flow_wildcards *wc)
+{
+ struct ovs_key_icmp key, mask, base;
+ enum ovs_key_attr attr;
+
+ if (is_icmpv4(flow, NULL)) {
+ attr = OVS_KEY_ATTR_ICMP;
+ } else if (is_icmpv6(flow, NULL)) {
+ attr = OVS_KEY_ATTR_ICMPV6;
+ } else {
+ return 0;
+ }
+
+ get_icmp_key(flow, &key);
+ get_icmp_key(base_flow, &base);
+ get_icmp_key(&wc->masks, &mask);
+
+ if (commit(attr, false, &key, &base, &mask, sizeof key, odp_actions)) {
+ put_icmp_key(&base, base_flow);
+ put_icmp_key(&mask, &wc->masks);
+ return SLOW_ACTION;
+ }
+ 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 */
- memcpy(nd->nd_sll, flow->arp_sha, ETH_ADDR_LEN);
- memcpy(nd->nd_tll, flow->arp_tha, ETH_ADDR_LEN);
+ 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, &flow->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 */
- memcpy(flow->arp_sha, nd->nd_sll, ETH_ADDR_LEN);
- memcpy(flow->arp_tha, nd->nd_tll, ETH_ADDR_LEN);
+ flow->arp_sha = nd->nd_sll;
+ flow->arp_tha = nd->nd_tll;
}
static enum slow_path_reason
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)
-{
- enum slow_path_reason slow;
-
- commit_set_ether_addr_action(flow, base, odp_actions, wc, use_masked);
- slow = commit_set_nw_action(flow, base, odp_actions, wc, use_masked);
+ bool use_masked, bool pending_encap,
+ struct ofpbuf *encap_data)
+{
+ enum slow_path_reason slow1, slow2;
+ 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);
- commit_mpls_action(flow, base, odp_actions);
- commit_vlan_action(flow->vlan_tci, base, odp_actions, wc);
+ slow2 = commit_set_icmp_action(flow, 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);
- return slow;
+ return slow1 ? slow1 : slow2;
}
projects / ovs.git / blobdiff