X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fodp-util.c;h=f1c23532bb016dbb48f05dc05743d7013825462c;hb=07659514c3c1e8998a4935a998b627d716c559f9;hp=6875e013bb28664d081ff3be281f936c6ed422b7;hpb=735806380968bf34a88bb48c98941bac00a4ec57;p=cascardo%2Fovs.git diff --git a/lib/odp-util.c b/lib/odp-util.c index 6875e013b..f1c23532b 100644 --- a/lib/odp-util.c +++ b/lib/odp-util.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc. + * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,8 +24,10 @@ #include #include #include + #include "byte-order.h" #include "coverage.h" +#include "dpif.h" #include "dynamic-string.h" #include "flow.h" #include "netlink.h" @@ -33,8 +35,11 @@ #include "packets.h" #include "simap.h" #include "timeval.h" +#include "tun-metadata.h" +#include "unaligned.h" #include "util.h" -#include "vlog.h" +#include "uuid.h" +#include "openvswitch/vlog.h" VLOG_DEFINE_THIS_MODULE(odp_util); @@ -48,6 +53,15 @@ VLOG_DEFINE_THIS_MODULE(odp_util); * from another. */ static const char *delimiters = ", \t\r\n"; +struct attr_len_tbl { + int len; + const struct attr_len_tbl *next; + int next_max; +}; +#define ATTR_LEN_INVALID -1 +#define ATTR_LEN_VARIABLE -2 +#define ATTR_LEN_NESTED -3 + static int parse_odp_key_mask_attr(const char *, const struct simap *port_names, struct ofpbuf *, struct ofpbuf *); static void format_odp_key_attr(const struct nlattr *a, @@ -55,15 +69,29 @@ static void format_odp_key_attr(const struct nlattr *a, 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); /* Returns one the following for the action with the given OVS_ACTION_ATTR_* * 'type': * * - For an action whose argument has a fixed length, returned that * nonnegative length in bytes. * - * - For an action with a variable-length argument, returns -2. + * - For an action with a variable-length argument, returns ATTR_LEN_VARIABLE. * - * - For an invalid 'type', returns -1. */ + * - For an invalid 'type', returns ATTR_LEN_INVALID. */ static int odp_action_len(uint16_t type) { @@ -73,20 +101,26 @@ odp_action_len(uint16_t type) switch ((enum ovs_action_attr) type) { case OVS_ACTION_ATTR_OUTPUT: return sizeof(uint32_t); - case OVS_ACTION_ATTR_USERSPACE: return -2; + case OVS_ACTION_ATTR_TUNNEL_PUSH: return ATTR_LEN_VARIABLE; + case OVS_ACTION_ATTR_TUNNEL_POP: 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_PUSH_MPLS: return sizeof(struct ovs_action_push_mpls); case OVS_ACTION_ATTR_POP_MPLS: return sizeof(ovs_be16); - case OVS_ACTION_ATTR_SET: return -2; - case OVS_ACTION_ATTR_SAMPLE: return -2; + case OVS_ACTION_ATTR_RECIRC: return sizeof(uint32_t); + case OVS_ACTION_ATTR_HASH: return sizeof(struct ovs_action_hash); + case OVS_ACTION_ATTR_SET: return 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_UNSPEC: case __OVS_ACTION_ATTR_MAX: - return -1; + return ATTR_LEN_INVALID; } - return -1; + return ATTR_LEN_INVALID; } /* Returns a string form of 'attr'. The return value is either a statically @@ -101,6 +135,8 @@ ovs_key_attr_to_string(enum ovs_key_attr attr, char *namebuf, size_t bufsize) 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_TUNNEL: return "tunnel"; case OVS_KEY_ATTR_IN_PORT: return "in_port"; case OVS_KEY_ATTR_ETHERNET: return "eth"; @@ -109,6 +145,7 @@ ovs_key_attr_to_string(enum ovs_key_attr attr, char *namebuf, size_t bufsize) case OVS_KEY_ATTR_IPV4: return "ipv4"; case OVS_KEY_ATTR_IPV6: return "ipv6"; case OVS_KEY_ATTR_TCP: return "tcp"; + case OVS_KEY_ATTR_TCP_FLAGS: return "tcp_flags"; case OVS_KEY_ATTR_UDP: return "udp"; case OVS_KEY_ATTR_SCTP: return "sctp"; case OVS_KEY_ATTR_ICMP: return "icmp"; @@ -116,6 +153,8 @@ ovs_key_attr_to_string(enum ovs_key_attr attr, char *namebuf, size_t bufsize) case OVS_KEY_ATTR_ARP: return "arp"; case OVS_KEY_ATTR_ND: return "nd"; case OVS_KEY_ATTR_MPLS: return "mpls"; + case OVS_KEY_ATTR_DP_HASH: return "dp_hash"; + case OVS_KEY_ATTR_RECIRC_ID: return "recirc_id"; case __OVS_KEY_ATTR_MAX: default: @@ -147,9 +186,8 @@ static void format_odp_sample_action(struct ds *ds, const struct nlattr *attr) { static const struct nl_policy ovs_sample_policy[] = { - { NL_A_NO_ATTR, 0, 0, false }, /* OVS_SAMPLE_ATTR_UNSPEC */ - { NL_A_U32, 0, 0, false }, /* OVS_SAMPLE_ATTR_PROBABILITY */ - { NL_A_NESTED, 0, 0, false }, /* OVS_SAMPLE_ATTR_ACTIONS */ + [OVS_SAMPLE_ATTR_PROBABILITY] = { .type = NL_A_U32 }, + [OVS_SAMPLE_ATTR_ACTIONS] = { .type = NL_A_NESTED } }; struct nlattr *a[ARRAY_SIZE(ovs_sample_policy)]; double percentage; @@ -200,65 +238,28 @@ slow_path_reason_to_explanation(enum slow_path_reason reason) } static int -parse_flags(const char *s, const char *(*bit_to_string)(uint32_t), - uint32_t *res) +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 = 0; - - if (s[n] != '(') { - return -EINVAL; - } - n++; - - while (s[n] != ')') { - unsigned long long int flags; - uint32_t bit; - int n0; - - if (sscanf(&s[n], "%lli%n", &flags, &n0) > 0 && n0 > 0) { - 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] == ')')) { - result |= bit; - n += len + (s[n + len] == ','); - break; - } - } - - if (!bit) { - return -EINVAL; - } - } - n++; - - *res = result; - 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) { static const struct nl_policy ovs_userspace_policy[] = { - { NL_A_NO_ATTR, 0, 0, false }, /* OVS_USERSPACE_ATTR_UNSPEC */ - { NL_A_U32, 0, 0, false }, /* OVS_USERSPACE_ATTR_PID */ - { NL_A_UNSPEC, 0, 0, true }, /* OVS_USERSPACE_ATTR_USERDATA */ + [OVS_USERSPACE_ATTR_PID] = { .type = NL_A_U32 }, + [OVS_USERSPACE_ATTR_USERDATA] = { .type = NL_A_UNSPEC, + .optional = true }, + [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; + const struct nlattr *tunnel_out_port_attr; if (!nl_parse_nested(attr, ovs_userspace_policy, a, ARRAY_SIZE(a))) { ds_put_cstr(ds, "userspace(error)"); @@ -307,9 +308,10 @@ format_odp_userspace_action(struct ds *ds, const struct nlattr *attr) cookie.flow_sample.collector_set_id, cookie.flow_sample.obs_domain_id, cookie.flow_sample.obs_point_id); - } else if (userdata_len == sizeof cookie.ipfix + } else if (userdata_len >= sizeof cookie.ipfix && cookie.type == USER_ACTION_COOKIE_IPFIX) { - ds_put_format(ds, ",ipfix"); + ds_put_format(ds, ",ipfix(output_port=%"PRIu32")", + cookie.ipfix.output_odp_port); } else { userdata_unspec = true; } @@ -325,18 +327,41 @@ format_odp_userspace_action(struct ds *ds, const struct nlattr *attr) } } + 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_char(ds, ')'); } static void -format_vlan_tci(struct ds *ds, ovs_be16 vlan_tci) +format_vlan_tci(struct ds *ds, ovs_be16 tci, ovs_be16 mask, bool verbose) { - ds_put_format(ds, "vid=%"PRIu16",pcp=%d", - vlan_tci_to_vid(vlan_tci), - vlan_tci_to_pcp(vlan_tci)); - if (!(vlan_tci & htons(VLAN_CFI))) { - ds_put_cstr(ds, ",cfi=0"); + if (verbose || vlan_tci_to_vid(tci) || vlan_tci_to_vid(mask)) { + ds_put_format(ds, "vid=%"PRIu16, vlan_tci_to_vid(tci)); + if (vlan_tci_to_vid(mask) != VLAN_VID_MASK) { /* Partially masked. */ + ds_put_format(ds, "/0x%"PRIx16, vlan_tci_to_vid(mask)); + }; + ds_put_char(ds, ','); + } + if (verbose || vlan_tci_to_pcp(tci) || vlan_tci_to_pcp(mask)) { + ds_put_format(ds, "pcp=%d", vlan_tci_to_pcp(tci)); + if (vlan_tci_to_pcp(mask) != (VLAN_PCP_MASK >> VLAN_PCP_SHIFT)) { + ds_put_format(ds, "/0x%x", vlan_tci_to_pcp(mask)); + } + ds_put_char(ds, ','); + } + if (!(tci & htons(VLAN_CFI))) { + ds_put_cstr(ds, "cfi=0"); + ds_put_char(ds, ','); } + ds_chomp(ds, ','); } static void @@ -351,20 +376,196 @@ format_mpls_lse(struct ds *ds, ovs_be32 mpls_lse) static void format_mpls(struct ds *ds, const struct ovs_key_mpls *mpls_key, - const struct ovs_key_mpls *mpls_mask) + const struct ovs_key_mpls *mpls_mask, int n) +{ + if (n == 1) { + ovs_be32 key = mpls_key->mpls_lse; + + if (mpls_mask == NULL) { + format_mpls_lse(ds, key); + } else { + ovs_be32 mask = mpls_mask->mpls_lse; + + ds_put_format(ds, "label=%"PRIu32"/0x%x,tc=%d/%x,ttl=%d/0x%x,bos=%d/%x", + mpls_lse_to_label(key), mpls_lse_to_label(mask), + mpls_lse_to_tc(key), mpls_lse_to_tc(mask), + mpls_lse_to_ttl(key), mpls_lse_to_ttl(mask), + mpls_lse_to_bos(key), mpls_lse_to_bos(mask)); + } + } else { + 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, ','); + } +} + +static void +format_odp_recirc_action(struct ds *ds, uint32_t recirc_id) +{ + ds_put_format(ds, "recirc(%#"PRIx32")", recirc_id); +} + +static void +format_odp_hash_action(struct ds *ds, const struct ovs_action_hash *hash_act) { - ovs_be32 key = mpls_key->mpls_lse; + ds_put_format(ds, "hash("); - if (mpls_mask == NULL) { - format_mpls_lse(ds, key); + if (hash_act->hash_alg == OVS_HASH_ALG_L4) { + ds_put_format(ds, "hash_l4(%"PRIu32")", hash_act->hash_basis); } else { - ovs_be32 mask = mpls_mask->mpls_lse; + ds_put_format(ds, "Unknown hash algorithm(%"PRIu32")", + hash_act->hash_alg); + } + ds_put_format(ds, ")"); +} + +static const void * +format_udp_tnl_push_header(struct ds *ds, const struct ip_header *ip) +{ + 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)); + + return udp + 1; +} + +static void +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; + + 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=", + 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 (data->tnl_type == OVS_VPORT_TYPE_VXLAN) { + const struct vxlanhdr *vxh; + + vxh = format_udp_tnl_push_header(ds, ip); + + ds_put_format(ds, "vxlan(flags=0x%"PRIx32",vni=0x%"PRIx32")", + ntohl(get_16aligned_be32(&vxh->vx_flags)), + ntohl(get_16aligned_be32(&vxh->vx_vni)) >> 8); + } else if (data->tnl_type == OVS_VPORT_TYPE_GENEVE) { + const struct genevehdr *gnh; + + gnh = format_udp_tnl_push_header(ds, ip); + + 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")", + ntohs(greh->flags), ntohs(greh->protocol)); + options = (ovs_16aligned_be32 *)(greh + 1); + if (greh->flags & htons(GRE_CSUM)) { + ds_put_format(ds, ",csum=0x%"PRIx16, ntohs(*((ovs_be16 *)options))); + options++; + } + if (greh->flags & htons(GRE_KEY)) { + ds_put_format(ds, ",key=0x%"PRIx32, ntohl(get_16aligned_be32(options))); + options++; + } + if (greh->flags & htons(GRE_SEQ)) { + ds_put_format(ds, ",seq=0x%"PRIx32, ntohl(get_16aligned_be32(options))); + options++; + } + ds_put_format(ds, ")"); + } + ds_put_format(ds, ")"); +} + +static void +format_odp_tnl_push_action(struct ds *ds, const struct nlattr *attr) +{ + 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); + format_odp_tnl_push_header(ds, data); + ds_put_format(ds, ",out_port(%"PRIu32"))", data->out_port); +} + +static const struct nl_policy ovs_conntrack_policy[] = { + [OVS_CT_ATTR_COMMIT] = { .type = NL_A_FLAG, .optional = true, }, + [OVS_CT_ATTR_ZONE] = { .type = NL_A_U16, .optional = true, }, +}; + +static void +format_odp_conntrack_action(struct ds *ds, const struct nlattr *attr) +{ + struct nlattr *a[ARRAY_SIZE(ovs_conntrack_policy)]; + bool commit; + uint16_t zone; - ds_put_format(ds, "label=%"PRIu32"/0x%x,tc=%d/%x,ttl=%d/0x%x,bos=%d/%x", - mpls_lse_to_label(key), mpls_lse_to_label(mask), - mpls_lse_to_tc(key), mpls_lse_to_tc(mask), - mpls_lse_to_ttl(key), mpls_lse_to_ttl(mask), - mpls_lse_to_bos(key), mpls_lse_to_bos(mask)); + 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; + zone = a[OVS_CT_ATTR_ZONE] ? nl_attr_get_u16(a[OVS_CT_ATTR_ZONE]) : 0; + + ds_put_format(ds, "ct"); + if (commit || zone) { + ds_put_cstr(ds, "("); + if (commit) { + ds_put_format(ds, "commit,"); + } + if (zone) { + ds_put_format(ds, "zone=%"PRIu16",", zone); + } + ds_chomp(ds, ','); + ds_put_cstr(ds, ")"); } } @@ -374,10 +575,12 @@ format_odp_action(struct ds *ds, const struct nlattr *a) 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)); - if (expected_len != -2 && nl_attr_get_size(a) != expected_len) { - ds_put_format(ds, "bad length %zu, expected %d for: ", + if (expected_len != ATTR_LEN_VARIABLE && + nl_attr_get_size(a) != expected_len) { + ds_put_format(ds, "bad length %"PRIuSIZE", expected %d for: ", nl_attr_get_size(a), expected_len); format_generic_odp_action(ds, a); return; @@ -387,9 +590,43 @@ format_odp_action(struct ds *ds, const struct nlattr *a) case OVS_ACTION_ATTR_OUTPUT: ds_put_format(ds, "%"PRIu32, nl_attr_get_u32(a)); break; + case OVS_ACTION_ATTR_TUNNEL_POP: + ds_put_format(ds, "tnl_pop(%"PRIu32")", nl_attr_get_u32(a)); + break; + case OVS_ACTION_ATTR_TUNNEL_PUSH: + format_odp_tnl_push_action(ds, a); + break; case OVS_ACTION_ATTR_USERSPACE: format_odp_userspace_action(ds, a); break; + case OVS_ACTION_ATTR_RECIRC: + format_odp_recirc_action(ds, nl_attr_get_u32(a)); + break; + case OVS_ACTION_ATTR_HASH: + format_odp_hash_action(ds, nl_attr_get(a)); + break; + case OVS_ACTION_ATTR_SET_MASKED: + a = nl_attr_get(a); + size = nl_attr_get_size(a) / 2; + ds_put_cstr(ds, "set("); + + /* Masked set action not supported for tunnel key, which is bigger. */ + if (size <= sizeof(struct ovs_key_ipv6)) { + struct nlattr attr[1 + DIV_ROUND_UP(sizeof(struct ovs_key_ipv6), + sizeof(struct nlattr))]; + struct nlattr mask[1 + DIV_ROUND_UP(sizeof(struct ovs_key_ipv6), + sizeof(struct nlattr))]; + + mask->nla_type = attr->nla_type = nl_attr_type(a); + mask->nla_len = attr->nla_len = NLA_HDRLEN + size; + memcpy(attr + 1, (char *)(a + 1), size); + memcpy(mask + 1, (char *)(a + 1) + size, size); + format_odp_key_attr(attr, mask, NULL, ds, false); + } else { + format_odp_key_attr(a, NULL, NULL, ds, false); + } + ds_put_cstr(ds, ")"); + break; case OVS_ACTION_ATTR_SET: ds_put_cstr(ds, "set("); format_odp_key_attr(nl_attr_get(a), NULL, NULL, ds, true); @@ -401,7 +638,7 @@ format_odp_action(struct ds *ds, const struct nlattr *a) 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); + format_vlan_tci(ds, vlan->vlan_tci, OVS_BE16_MAX, false); ds_put_char(ds, ')'); break; case OVS_ACTION_ATTR_POP_VLAN: @@ -422,6 +659,9 @@ format_odp_action(struct ds *ds, const struct nlattr *a) case OVS_ACTION_ATTR_SAMPLE: format_odp_sample_action(ds, a); break; + case OVS_ACTION_ATTR_CT: + format_odp_conntrack_action(ds, a); + break; case OVS_ACTION_ATTR_UNSPEC: case __OVS_ACTION_ATTR_MAX: default: @@ -461,60 +701,37 @@ format_odp_actions(struct ds *ds, const struct nlattr *actions, } } +/* Separate out parse_odp_userspace_action() function. */ static int -parse_odp_action(const char *s, const struct simap *port_names, - struct ofpbuf *actions) +parse_odp_userspace_action(const char *s, struct ofpbuf *actions) { - /* Many of the sscanf calls in this function use oversized destination - * fields because some sscanf() implementations truncate the range of %i - * directives, so that e.g. "%"SCNi16 interprets input of "0xfedc" as a - * value of 0x7fff. The other alternatives are to allow only a single - * radix (e.g. decimal or hexadecimal) or to write more sophisticated - * parsers. - * - * The tun_id parser has to use an alternative approach because there is no - * type larger than 64 bits. */ - - { - unsigned long long int port; - int n = -1; - - if (sscanf(s, "%lli%n", &port, &n) > 0 && n > 0) { - nl_msg_put_u32(actions, OVS_ACTION_ATTR_OUTPUT, port); - return n; - } - } - - if (port_names) { - int len = strcspn(s, delimiters); - struct simap_node *node; - - node = simap_find_len(port_names, s, len); - if (node) { - nl_msg_put_u32(actions, OVS_ACTION_ATTR_OUTPUT, node->data); - return len; - } + uint32_t pid; + union user_action_cookie cookie; + struct ofpbuf buf; + odp_port_t tunnel_out_port; + int n = -1; + void *user_data = NULL; + size_t user_data_size = 0; + bool include_actions = false; + + if (!ovs_scan(s, "userspace(pid=%"SCNi32"%n", &pid, &n)) { + return -EINVAL; } { - unsigned long long int pid; - unsigned long long int output; - unsigned long long int probability; - unsigned long long int collector_set_id; - unsigned long long int obs_domain_id; - unsigned long long int obs_point_id; + uint32_t output; + uint32_t probability; + uint32_t collector_set_id; + uint32_t obs_domain_id; + uint32_t obs_point_id; int vid, pcp; - int n = -1; - - if (sscanf(s, "userspace(pid=%lli)%n", &pid, &n) > 0 && n > 0) { - odp_put_userspace_action(pid, NULL, 0, actions); - return n; - } else if (sscanf(s, "userspace(pid=%lli,sFlow(vid=%i," - "pcp=%i,output=%lli))%n", - &pid, &vid, &pcp, &output, &n) > 0 && n > 0) { - union user_action_cookie cookie; + int n1 = -1; + if (ovs_scan(&s[n], ",sFlow(vid=%i," + "pcp=%i,output=%"SCNi32")%n", + &vid, &pcp, &output, &n1)) { uint16_t tci; + n += n1; tci = vid | (pcp << VLAN_PCP_SHIFT); if (tci) { tci |= VLAN_CFI; @@ -523,231 +740,593 @@ parse_odp_action(const char *s, const struct simap *port_names, cookie.type = USER_ACTION_COOKIE_SFLOW; cookie.sflow.vlan_tci = htons(tci); cookie.sflow.output = output; - odp_put_userspace_action(pid, &cookie, sizeof cookie.sflow, - actions); - return n; - } else if (sscanf(s, "userspace(pid=%lli,slow_path%n", &pid, &n) > 0 - && n > 0) { - union user_action_cookie cookie; + user_data = &cookie; + 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); - if (res < 0) { + 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; } - n += res; - if (s[n] != ')') { - return -EINVAL; - } - n++; - - odp_put_userspace_action(pid, &cookie, sizeof cookie.slow_path, - actions); - return n; - } else if (sscanf(s, "userspace(pid=%lli,flow_sample(probability=%lli," - "collector_set_id=%lli,obs_domain_id=%lli," - "obs_point_id=%lli))%n", - &pid, &probability, &collector_set_id, - &obs_domain_id, &obs_point_id, &n) > 0 && n > 0) { - union user_action_cookie cookie; + n += res + 1; + + user_data = &cookie; + user_data_size = sizeof cookie.slow_path; + } else if (ovs_scan(&s[n], ",flow_sample(probability=%"SCNi32"," + "collector_set_id=%"SCNi32"," + "obs_domain_id=%"SCNi32"," + "obs_point_id=%"SCNi32")%n", + &probability, &collector_set_id, + &obs_domain_id, &obs_point_id, &n1)) { + n += n1; cookie.type = USER_ACTION_COOKIE_FLOW_SAMPLE; cookie.flow_sample.probability = probability; 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; - odp_put_userspace_action(pid, &cookie, sizeof cookie.flow_sample, - actions); - return n; - } else if (sscanf(s, "userspace(pid=%lli,ipfix)%n", &pid, &n) > 0 - && n > 0) { - union user_action_cookie cookie; - + user_data = &cookie; + user_data_size = sizeof cookie.flow_sample; + } else if (ovs_scan(&s[n], ",ipfix(output_port=%"SCNi32")%n", + &output, &n1) ) { + n += n1; cookie.type = USER_ACTION_COOKIE_IPFIX; - odp_put_userspace_action(pid, &cookie, sizeof cookie.ipfix, - actions); - return n; - } else if (sscanf(s, "userspace(pid=%lli,userdata(%n", &pid, &n) > 0 - && n > 0) { - struct ofpbuf buf; + cookie.ipfix.output_odp_port = u32_to_odp(output); + user_data = &cookie; + user_data_size = sizeof cookie.ipfix; + } else if (ovs_scan(&s[n], ",userdata(%n", + &n1)) { char *end; + n += n1; ofpbuf_init(&buf, 16); end = ofpbuf_put_hex(&buf, &s[n], NULL); - if (end[0] == ')' && end[1] == ')') { - odp_put_userspace_action(pid, buf.data, buf.size, actions); - ofpbuf_uninit(&buf); - return (end + 2) - s; + if (end[0] != ')') { + return -EINVAL; } + user_data = buf.data; + user_data_size = buf.size; + n = (end + 1) - s; } } - if (!strncmp(s, "set(", 4)) { - size_t start_ofs; - int retval; - - start_ofs = nl_msg_start_nested(actions, OVS_ACTION_ATTR_SET); - retval = parse_odp_key_mask_attr(s + 4, port_names, actions, NULL); - if (retval < 0) { - return retval; - } - if (s[retval + 4] != ')') { - return -EINVAL; + { + int n1 = -1; + if (ovs_scan(&s[n], ",actions%n", &n1)) { + n += n1; + include_actions = true; } - nl_msg_end_nested(actions, start_ofs); - return retval + 5; } { - struct ovs_action_push_vlan push; - int tpid = ETH_TYPE_VLAN; - int vid, pcp; - int cfi = 1; - int n = -1; - - if ((sscanf(s, "push_vlan(vid=%i,pcp=%i)%n", &vid, &pcp, &n) > 0 - && n > 0) - || (sscanf(s, "push_vlan(vid=%i,pcp=%i,cfi=%i)%n", - &vid, &pcp, &cfi, &n) > 0 && n > 0) - || (sscanf(s, "push_vlan(tpid=%i,vid=%i,pcp=%i)%n", - &tpid, &vid, &pcp, &n) > 0 && n > 0) - || (sscanf(s, "push_vlan(tpid=%i,vid=%i,pcp=%i,cfi=%i)%n", - &tpid, &vid, &pcp, &cfi, &n) > 0 && n > 0)) { - push.vlan_tpid = htons(tpid); - push.vlan_tci = htons((vid << VLAN_VID_SHIFT) - | (pcp << VLAN_PCP_SHIFT) - | (cfi ? VLAN_CFI : 0)); - nl_msg_put_unspec(actions, OVS_ACTION_ATTR_PUSH_VLAN, - &push, sizeof push); - - return n; + 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, include_actions, actions); + return n + n1; + } else if (s[n] == ')') { + odp_put_userspace_action(pid, user_data, user_data_size, + ODPP_NONE, include_actions, actions); + return n + 1; } } - if (!strncmp(s, "pop_vlan", 8)) { - nl_msg_put_flag(actions, OVS_ACTION_ATTR_POP_VLAN); - return 8; - } - - { - double percentage; - int n = -1; + return -EINVAL; +} - if (sscanf(s, "sample(sample=%lf%%,actions(%n", &percentage, &n) > 0 - && percentage >= 0. && percentage <= 100.0 - && n > 0) { - size_t sample_ofs, actions_ofs; - double probability; +static int +ovs_parse_tnl_push(const char *s, struct ovs_action_push_tnl *data) +{ + struct eth_header *eth; + struct ip_header *ip; + 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; + void *l3, *l4; + int n = 0; - probability = floor(UINT32_MAX * (percentage / 100.0) + .5); - sample_ofs = nl_msg_start_nested(actions, OVS_ACTION_ATTR_SAMPLE); - nl_msg_put_u32(actions, OVS_SAMPLE_ATTR_PROBABILITY, - (probability <= 0 ? 0 - : probability >= UINT32_MAX ? UINT32_MAX - : probability)); + if (!ovs_scan_len(s, &n, "tnl_push(tnl_port(%"SCNi32"),", &data->tnl_port)) { + return -EINVAL; + } + eth = (struct eth_header *) data->header; + l3 = (data->header + sizeof *eth); + l4 = ((uint8_t *) l3 + sizeof (struct ip_header)); + ip = (struct ip_header *) 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))) { + return -EINVAL; + } - actions_ofs = nl_msg_start_nested(actions, - OVS_SAMPLE_ATTR_ACTIONS); - for (;;) { - int retval; + if (!ovs_scan_len(s, &n, "src="ETH_ADDR_SCAN_FMT",", + ETH_ADDR_SCAN_ARGS(eth->eth_src))) { + return -EINVAL; + } + if (!ovs_scan_len(s, &n, "dl_type=0x%"SCNx16"),", &dl_type)) { + return -EINVAL; + } + eth->eth_type = htons(dl_type); - n += strspn(s + n, delimiters); - if (s[n] == ')') { - break; + /* 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; + } + put_16aligned_be32(&ip->ip_src, sip); + put_16aligned_be32(&ip->ip_dst, dip); + + /* Tunnel header */ + 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)) { + uint32_t vx_flags, vni; + + udp->udp_src = htons(udp_src); + udp->udp_dst = htons(udp_dst); + udp->udp_len = 0; + udp->udp_csum = htons(csum); + + if (ovs_scan_len(s, &n, "vxlan(flags=0x%"SCNx32",vni=0x%"SCNx32"))", + &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 + + 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 + sizeof *ip + + sizeof *udp + sizeof *gnh; + + if (ovs_scan_len(s, &n, "oam,")) { + gnh->oam = 1; + } + 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; } - retval = parse_odp_action(s + n, port_names, actions); - if (retval < 0) { - return retval; - } - n += retval; + 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; } - nl_msg_end_nested(actions, actions_ofs); - nl_msg_end_nested(actions, sample_ofs); - return s[n + 1] == ')' ? n + 2 : -EINVAL; + gnh->proto_type = htons(ETH_TYPE_TEB); + put_16aligned_be32(&gnh->vni, htonl(vni << 8)); + tnl_type = OVS_VPORT_TYPE_GENEVE; + } else { + return -EINVAL; } - } + } else if (ovs_scan_len(s, &n, "gre((flags=0x%"SCNx16",proto=0x%"SCNx16")", + &gre_flags, &gre_proto)){ - return -EINVAL; -} + 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); -/* Parses the string representation of datapath actions, in the format output - * by format_odp_action(). Returns 0 if successful, otherwise a positive errno - * value. On success, the ODP actions are appended to 'actions' as a series of - * Netlink attributes. On failure, no data is appended to 'actions'. Either - * way, 'actions''s data might be reallocated. */ -int -odp_actions_from_string(const char *s, const struct simap *port_names, - struct ofpbuf *actions) -{ - size_t old_size; + if (greh->flags & htons(GRE_CSUM)) { + if (!ovs_scan_len(s, &n, ",csum=0x%"SCNx16, &csum)) { + return -EINVAL; + } - if (!strcasecmp(s, "drop")) { - return 0; - } + memset(options, 0, sizeof *options); + *((ovs_be16 *)options) = htons(csum); + options++; + } + if (greh->flags & htons(GRE_KEY)) { + uint32_t key; - old_size = actions->size; - for (;;) { - int retval; + if (!ovs_scan_len(s, &n, ",key=0x%"SCNx32, &key)) { + return -EINVAL; + } - s += strspn(s, delimiters); - if (!*s) { - return 0; + put_16aligned_be32(options, htonl(key)); + options++; } + if (greh->flags & htons(GRE_SEQ)) { + uint32_t seq; - retval = parse_odp_action(s, port_names, actions); - if (retval < 0 || !strchr(delimiters, s[retval])) { - actions->size = old_size; - return -retval; + if (!ovs_scan_len(s, &n, ",seq=0x%"SCNx32, &seq)) { + return -EINVAL; + } + put_16aligned_be32(options, htonl(seq)); + options++; } - s += retval; + + if (!ovs_scan_len(s, &n, "))")) { + return -EINVAL; + } + + header_len = sizeof *eth + sizeof *ip + + ((uint8_t *) options - (uint8_t *) greh); + } else { + return -EINVAL; } - return 0; -} - -/* Returns the correct length of the payload for a flow key attribute of the - * specified 'type', -1 if 'type' is unknown, or -2 if the attribute's payload - * is variable length. */ + /* 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; +} + static int -odp_flow_key_attr_len(uint16_t type) +parse_conntrack_action(const char *s_, struct ofpbuf *actions) { - if (type > OVS_KEY_ATTR_MAX) { - return -1; + const char *s = s_; + + if (ovs_scan(s, "ct")) { + bool commit = false; + uint16_t zone = 0; + size_t start; + char *end; + + s += 2; + if (ovs_scan(s, "(")) { + s++; + end = strchr(s, ')'); + if (!end) { + return -EINVAL; + } + + while (s != end) { + int n = -1; + + s += strspn(s, delimiters); + if (ovs_scan(s, "commit%n", &n)) { + commit = true; + s += n; + continue; + } + if (ovs_scan(s, "zone=%"SCNu16"%n", &zone, &n)) { + s += n; + continue; + } + + return -EINVAL; + } + s++; + } + + start = nl_msg_start_nested(actions, OVS_ACTION_ATTR_CT); + if (commit) { + nl_msg_put_flag(actions, OVS_CT_ATTR_COMMIT); + } + if (zone) { + nl_msg_put_u16(actions, OVS_CT_ATTR_ZONE, zone); + } + nl_msg_end_nested(actions, start); } - switch ((enum ovs_key_attr) type) { - case OVS_KEY_ATTR_ENCAP: return -2; - case OVS_KEY_ATTR_PRIORITY: return 4; - case OVS_KEY_ATTR_SKB_MARK: return 4; - case OVS_KEY_ATTR_TUNNEL: return -2; - case OVS_KEY_ATTR_IN_PORT: return 4; - case OVS_KEY_ATTR_ETHERNET: return sizeof(struct ovs_key_ethernet); - case OVS_KEY_ATTR_VLAN: return sizeof(ovs_be16); - case OVS_KEY_ATTR_ETHERTYPE: return 2; - case OVS_KEY_ATTR_MPLS: return sizeof(struct ovs_key_mpls); - case OVS_KEY_ATTR_IPV4: return sizeof(struct ovs_key_ipv4); - case OVS_KEY_ATTR_IPV6: return sizeof(struct ovs_key_ipv6); - case OVS_KEY_ATTR_TCP: return sizeof(struct ovs_key_tcp); - case OVS_KEY_ATTR_UDP: return sizeof(struct ovs_key_udp); - case OVS_KEY_ATTR_SCTP: return sizeof(struct ovs_key_sctp); - case OVS_KEY_ATTR_ICMP: return sizeof(struct ovs_key_icmp); - case OVS_KEY_ATTR_ICMPV6: return sizeof(struct ovs_key_icmpv6); - case OVS_KEY_ATTR_ARP: return sizeof(struct ovs_key_arp); - case OVS_KEY_ATTR_ND: return sizeof(struct ovs_key_nd); + return s - s_; +} - case OVS_KEY_ATTR_UNSPEC: - case __OVS_KEY_ATTR_MAX: - return -1; +static int +parse_odp_action(const char *s, const struct simap *port_names, + struct ofpbuf *actions) +{ + { + uint32_t port; + int n; + + if (ovs_scan(s, "%"SCNi32"%n", &port, &n)) { + nl_msg_put_u32(actions, OVS_ACTION_ATTR_OUTPUT, port); + return n; + } + } + + if (port_names) { + int len = strcspn(s, delimiters); + struct simap_node *node; + + node = simap_find_len(port_names, s, len); + if (node) { + nl_msg_put_u32(actions, OVS_ACTION_ATTR_OUTPUT, node->data); + return len; + } + } + + { + uint32_t recirc_id; + int n = -1; + + if (ovs_scan(s, "recirc(%"PRIu32")%n", &recirc_id, &n)) { + nl_msg_put_u32(actions, OVS_ACTION_ATTR_RECIRC, recirc_id); + return n; + } + } + + if (!strncmp(s, "userspace(", 10)) { + return parse_odp_userspace_action(s, actions); + } + + if (!strncmp(s, "set(", 4)) { + size_t start_ofs; + int retval; + struct nlattr mask[128 / sizeof(struct nlattr)]; + struct ofpbuf maskbuf; + struct nlattr *nested, *key; + size_t size; + + /* 'mask' is big enough to hold any key. */ + ofpbuf_use_stack(&maskbuf, mask, sizeof mask); + + start_ofs = nl_msg_start_nested(actions, OVS_ACTION_ATTR_SET); + retval = parse_odp_key_mask_attr(s + 4, port_names, actions, &maskbuf); + if (retval < 0) { + return retval; + } + if (s[retval + 4] != ')') { + return -EINVAL; + } + + nested = ofpbuf_at_assert(actions, start_ofs, sizeof *nested); + key = nested + 1; + + size = nl_attr_get_size(mask); + if (size == nl_attr_get_size(key)) { + /* Change to masked set action if not fully masked. */ + if (!is_all_ones(mask + 1, size)) { + key->nla_len += size; + ofpbuf_put(actions, mask + 1, size); + /* 'actions' may have been reallocated by ofpbuf_put(). */ + nested = ofpbuf_at_assert(actions, start_ofs, sizeof *nested); + nested->nla_type = OVS_ACTION_ATTR_SET_MASKED; + } + } + + nl_msg_end_nested(actions, start_ofs); + return retval + 5; + } + + { + struct ovs_action_push_vlan push; + int tpid = ETH_TYPE_VLAN; + int vid, pcp; + int cfi = 1; + int n = -1; + + if (ovs_scan(s, "push_vlan(vid=%i,pcp=%i)%n", &vid, &pcp, &n) + || ovs_scan(s, "push_vlan(vid=%i,pcp=%i,cfi=%i)%n", + &vid, &pcp, &cfi, &n) + || ovs_scan(s, "push_vlan(tpid=%i,vid=%i,pcp=%i)%n", + &tpid, &vid, &pcp, &n) + || ovs_scan(s, "push_vlan(tpid=%i,vid=%i,pcp=%i,cfi=%i)%n", + &tpid, &vid, &pcp, &cfi, &n)) { + push.vlan_tpid = htons(tpid); + push.vlan_tci = htons((vid << VLAN_VID_SHIFT) + | (pcp << VLAN_PCP_SHIFT) + | (cfi ? VLAN_CFI : 0)); + nl_msg_put_unspec(actions, OVS_ACTION_ATTR_PUSH_VLAN, + &push, sizeof push); + + return n; + } + } + + if (!strncmp(s, "pop_vlan", 8)) { + nl_msg_put_flag(actions, OVS_ACTION_ATTR_POP_VLAN); + return 8; + } + + { + double percentage; + int n = -1; + + if (ovs_scan(s, "sample(sample=%lf%%,actions(%n", &percentage, &n) + && percentage >= 0. && percentage <= 100.0) { + size_t sample_ofs, actions_ofs; + double probability; + + probability = floor(UINT32_MAX * (percentage / 100.0) + .5); + sample_ofs = nl_msg_start_nested(actions, OVS_ACTION_ATTR_SAMPLE); + nl_msg_put_u32(actions, OVS_SAMPLE_ATTR_PROBABILITY, + (probability <= 0 ? 0 + : probability >= UINT32_MAX ? UINT32_MAX + : probability)); + + actions_ofs = nl_msg_start_nested(actions, + OVS_SAMPLE_ATTR_ACTIONS); + 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; + } + nl_msg_end_nested(actions, actions_ofs); + nl_msg_end_nested(actions, sample_ofs); + + return s[n + 1] == ')' ? n + 2 : -EINVAL; + } + } + + { + uint32_t port; + int n; + + if (ovs_scan(s, "tnl_pop(%"SCNi32")%n", &port, &n)) { + nl_msg_put_u32(actions, OVS_ACTION_ATTR_TUNNEL_POP, port); + return n; + } + } + + { + int retval; + + retval = parse_conntrack_action(s, actions); + if (retval) { + return retval; + } + } + + { + struct ovs_action_push_tnl data; + int n; + + n = ovs_parse_tnl_push(s, &data); + if (n > 0) { + odp_put_tnl_push_action(actions, &data); + return n; + } else if (n < 0) { + return n; + } + } + return -EINVAL; +} + +/* Parses the string representation of datapath actions, in the format output + * by format_odp_action(). Returns 0 if successful, otherwise a positive errno + * value. On success, the ODP actions are appended to 'actions' as a series of + * Netlink attributes. On failure, no data is appended to 'actions'. Either + * way, 'actions''s data might be reallocated. */ +int +odp_actions_from_string(const char *s, const struct simap *port_names, + struct ofpbuf *actions) +{ + size_t old_size; + + if (!strcasecmp(s, "drop")) { + return 0; + } + + old_size = actions->size; + for (;;) { + int retval; + + s += strspn(s, delimiters); + if (!*s) { + return 0; + } + + retval = parse_odp_action(s, port_names, actions); + if (retval < 0 || !strchr(delimiters, s[retval])) { + actions->size = old_size; + return -retval; + } + s += retval; + } + + return 0; +} + +static const struct attr_len_tbl ovs_vxlan_ext_attr_lens[OVS_VXLAN_EXT_MAX + 1] = { + [OVS_VXLAN_EXT_GBP] = { .len = 4 }, +}; + +static const struct attr_len_tbl ovs_tun_key_attr_lens[OVS_TUNNEL_KEY_ATTR_MAX + 1] = { + [OVS_TUNNEL_KEY_ATTR_ID] = { .len = 8 }, + [OVS_TUNNEL_KEY_ATTR_IPV4_SRC] = { .len = 4 }, + [OVS_TUNNEL_KEY_ATTR_IPV4_DST] = { .len = 4 }, + [OVS_TUNNEL_KEY_ATTR_TOS] = { .len = 1 }, + [OVS_TUNNEL_KEY_ATTR_TTL] = { .len = 1 }, + [OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT] = { .len = 0 }, + [OVS_TUNNEL_KEY_ATTR_CSUM] = { .len = 0 }, + [OVS_TUNNEL_KEY_ATTR_TP_SRC] = { .len = 2 }, + [OVS_TUNNEL_KEY_ATTR_TP_DST] = { .len = 2 }, + [OVS_TUNNEL_KEY_ATTR_OAM] = { .len = 0 }, + [OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS] = { .len = ATTR_LEN_VARIABLE }, + [OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS] = { .len = ATTR_LEN_NESTED, + .next = ovs_vxlan_ext_attr_lens , + .next_max = OVS_VXLAN_EXT_MAX}, +}; + +static const struct attr_len_tbl ovs_flow_key_attr_lens[OVS_KEY_ATTR_MAX + 1] = { + [OVS_KEY_ATTR_ENCAP] = { .len = ATTR_LEN_NESTED }, + [OVS_KEY_ATTR_PRIORITY] = { .len = 4 }, + [OVS_KEY_ATTR_SKB_MARK] = { .len = 4 }, + [OVS_KEY_ATTR_DP_HASH] = { .len = 4 }, + [OVS_KEY_ATTR_RECIRC_ID] = { .len = 4 }, + [OVS_KEY_ATTR_TUNNEL] = { .len = ATTR_LEN_NESTED, + .next = ovs_tun_key_attr_lens, + .next_max = OVS_TUNNEL_KEY_ATTR_MAX }, + [OVS_KEY_ATTR_IN_PORT] = { .len = 4 }, + [OVS_KEY_ATTR_ETHERNET] = { .len = sizeof(struct ovs_key_ethernet) }, + [OVS_KEY_ATTR_VLAN] = { .len = 2 }, + [OVS_KEY_ATTR_ETHERTYPE] = { .len = 2 }, + [OVS_KEY_ATTR_MPLS] = { .len = ATTR_LEN_VARIABLE }, + [OVS_KEY_ATTR_IPV4] = { .len = sizeof(struct ovs_key_ipv4) }, + [OVS_KEY_ATTR_IPV6] = { .len = sizeof(struct ovs_key_ipv6) }, + [OVS_KEY_ATTR_TCP] = { .len = sizeof(struct ovs_key_tcp) }, + [OVS_KEY_ATTR_TCP_FLAGS] = { .len = 2 }, + [OVS_KEY_ATTR_UDP] = { .len = sizeof(struct ovs_key_udp) }, + [OVS_KEY_ATTR_SCTP] = { .len = sizeof(struct ovs_key_sctp) }, + [OVS_KEY_ATTR_ICMP] = { .len = sizeof(struct ovs_key_icmp) }, + [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 }, +}; + +/* Returns the correct length of the payload for a flow key attribute of the + * specified 'type', ATTR_LEN_INVALID if 'type' is unknown, ATTR_LEN_VARIABLE + * 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) +{ + if (type > max_len) { + return ATTR_LEN_INVALID; } - return -1; + return tbl[type].len; } static void @@ -784,25 +1363,11 @@ ovs_frag_type_to_string(enum ovs_frag_type type) } } -static int -tunnel_key_attr_len(int type) -{ - switch (type) { - case OVS_TUNNEL_KEY_ATTR_ID: return 8; - case OVS_TUNNEL_KEY_ATTR_IPV4_SRC: return 4; - case OVS_TUNNEL_KEY_ATTR_IPV4_DST: return 4; - case OVS_TUNNEL_KEY_ATTR_TOS: return 1; - case OVS_TUNNEL_KEY_ATTR_TTL: return 1; - case OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT: return 0; - case OVS_TUNNEL_KEY_ATTR_CSUM: return 0; - case __OVS_TUNNEL_KEY_ATTR_MAX: - return -1; - } - return -1; -} - -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, + const struct nlattr *flow_attrs, size_t flow_attr_len, + const struct flow_tnl *src_tun, struct flow_tnl *tun, + bool udpif) { unsigned int left; const struct nlattr *a; @@ -812,7 +1377,8 @@ odp_tun_key_from_attr(const struct nlattr *attr, struct flow_tnl *tun) NL_NESTED_FOR_EACH(a, left, attr) { uint16_t type = nl_attr_type(a); size_t len = nl_attr_get_size(a); - int expected_len = tunnel_key_attr_len(type); + int expected_len = odp_key_attr_len(ovs_tun_key_attr_lens, + OVS_TUNNEL_ATTR_MAX, type); if (len != expected_len && expected_len >= 0) { return ODP_FIT_ERROR; @@ -842,6 +1408,41 @@ odp_tun_key_from_attr(const struct nlattr *attr, struct flow_tnl *tun) case OVS_TUNNEL_KEY_ATTR_CSUM: tun->flags |= FLOW_TNL_F_CSUM; break; + case OVS_TUNNEL_KEY_ATTR_TP_SRC: + tun->tp_src = nl_attr_get_be16(a); + break; + case OVS_TUNNEL_KEY_ATTR_TP_DST: + tun->tp_dst = nl_attr_get_be16(a); + break; + case OVS_TUNNEL_KEY_ATTR_OAM: + tun->flags |= FLOW_TNL_F_OAM; + break; + case OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS: { + static const struct nl_policy vxlan_opts_policy[] = { + [OVS_VXLAN_EXT_GBP] = { .type = NL_A_U32 }, + }; + struct nlattr *ext[ARRAY_SIZE(vxlan_opts_policy)]; + + if (!nl_parse_nested(a, vxlan_opts_policy, ext, ARRAY_SIZE(ext))) { + return ODP_FIT_ERROR; + } + + if (ext[OVS_VXLAN_EXT_GBP]) { + uint32_t gbp = nl_attr_get_u32(ext[OVS_VXLAN_EXT_GBP]); + + tun->gbp_id = htons(gbp & 0xFFFF); + tun->gbp_flags = (gbp >> 16) & 0xFF; + } + + break; + } + case OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS: + if (tun_metadata_from_geneve_nlattr(a, flow_attrs, flow_attr_len, + src_tun, udpif, tun)) { + return ODP_FIT_ERROR; + } + break; + default: /* Allow this to show up as unexpected, if there are unknown * tunnel attribute, eventually resulting in ODP_FIT_TOO_MUCH. */ @@ -854,19 +1455,30 @@ odp_tun_key_from_attr(const struct nlattr *attr, struct flow_tnl *tun) return ODP_FIT_ERROR; } if (unknown) { - return ODP_FIT_TOO_MUCH; + return ODP_FIT_TOO_MUCH; } return ODP_FIT_PERFECT; } +enum odp_key_fitness +odp_tun_key_from_attr(const struct nlattr *attr, bool udpif, + struct flow_tnl *tun) +{ + memset(tun, 0, sizeof *tun); + return odp_tun_key_from_attr__(attr, NULL, 0, NULL, tun, udpif); +} + 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; tun_key_ofs = nl_msg_start_nested(a, OVS_KEY_ATTR_TUNNEL); - if (tun_key->flags & FLOW_TNL_F_KEY) { + /* tun_id != 0 without FLOW_TNL_F_KEY is valid if tun_key is a mask. */ + if (tun_key->tun_id || tun_key->flags & FLOW_TNL_F_KEY) { nl_msg_put_be64(a, OVS_TUNNEL_KEY_ATTR_ID, tun_key->tun_id); } if (tun_key->ip_src) { @@ -885,6 +1497,24 @@ tun_key_to_attr(struct ofpbuf *a, const struct flow_tnl *tun_key) if (tun_key->flags & FLOW_TNL_F_CSUM) { nl_msg_put_flag(a, OVS_TUNNEL_KEY_ATTR_CSUM); } + if (tun_key->tp_src) { + nl_msg_put_be16(a, OVS_TUNNEL_KEY_ATTR_TP_SRC, tun_key->tp_src); + } + if (tun_key->tp_dst) { + nl_msg_put_be16(a, OVS_TUNNEL_KEY_ATTR_TP_DST, tun_key->tp_dst); + } + if (tun_key->flags & FLOW_TNL_F_OAM) { + nl_msg_put_flag(a, OVS_TUNNEL_KEY_ATTR_OAM); + } + if (tun_key->gbp_flags || tun_key->gbp_id) { + size_t vxlan_opts_ofs; + + vxlan_opts_ofs = nl_msg_start_nested(a, OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS); + nl_msg_put_u32(a, OVS_VXLAN_EXT_GBP, + (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); } @@ -895,33 +1525,55 @@ odp_mask_attr_is_wildcard(const struct nlattr *ma) return is_all_zeros(nl_attr_get(ma), nl_attr_get_size(ma)); } +static bool +odp_mask_is_exact(enum ovs_key_attr attr, const void *mask, size_t size) +{ + if (attr == OVS_KEY_ATTR_TCP_FLAGS) { + return TCP_FLAGS(*(ovs_be16 *)mask) == TCP_FLAGS(OVS_BE16_MAX); + } + if (attr == OVS_KEY_ATTR_IPV6) { + const struct ovs_key_ipv6 *ipv6_mask = mask; + + 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) { + return false; + } + + 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); + } + + return is_all_ones(mask, size); +} + static bool odp_mask_attr_is_exact(const struct nlattr *ma) { - bool is_exact = false; enum ovs_key_attr attr = nl_attr_type(ma); + const void *mask; + size_t size; if (attr == OVS_KEY_ATTR_TUNNEL) { - /* XXX this is a hack for now. Should change - * the exact match dection to per field - * instead of per attribute. - */ - struct flow_tnl tun_mask; - memset(&tun_mask, 0, sizeof tun_mask); - odp_tun_key_from_attr(ma, &tun_mask); - if (tun_mask.flags == (FLOW_TNL_F_KEY - | FLOW_TNL_F_DONT_FRAGMENT - | FLOW_TNL_F_CSUM)) { - /* The flags are exact match, check the remaining fields. */ - tun_mask.flags = 0xffff; - is_exact = is_all_ones((uint8_t *)&tun_mask, - offsetof(struct flow_tnl, ip_ttl)); - } + return false; } else { - is_exact = is_all_ones(nl_attr_get(ma), nl_attr_get_size(ma)); + mask = nl_attr_get(ma); + size = nl_attr_get_size(ma); } - return is_exact; + return odp_mask_is_exact(attr, mask, size); } void @@ -963,47 +1615,563 @@ odp_portno_names_destroy(struct hmap *portno_names) } } +/* Format helpers. */ + 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_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); + + if (verbose || !mask_empty) { + bool mask_full = !mask || eth_mask_is_exact(*mask); + + if (mask_full) { + 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); + ds_put_char(ds, ','); + } + } +} + +static void +format_be64(struct ds *ds, const char *name, ovs_be64 key, + const ovs_be64 *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + bool mask_full = !mask || *mask == OVS_BE64_MAX; + + ds_put_format(ds, "%s=0x%"PRIx64, name, ntohll(key)); + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "/%#"PRIx64, ntohll(*mask)); + } + ds_put_char(ds, ','); + } +} + +static void +format_ipv4(struct ds *ds, const char *name, ovs_be32 key, + const ovs_be32 *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + bool mask_full = !mask || *mask == OVS_BE32_MAX; + + ds_put_format(ds, "%s="IP_FMT, name, IP_ARGS(key)); + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "/"IP_FMT, IP_ARGS(*mask)); + } + ds_put_char(ds, ','); + } +} + +static void +format_ipv6(struct ds *ds, const char *name, const ovs_be32 key_[4], + const ovs_be32 (*mask_)[4], 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_full = !mask || ipv6_mask_is_exact(mask); + + inet_ntop(AF_INET6, key, buf, sizeof buf); + ds_put_format(ds, "%s=%s", name, buf); + if (!mask_full) { /* Partially masked. */ + inet_ntop(AF_INET6, mask, buf, sizeof buf); + ds_put_format(ds, "/%s", buf); + } + ds_put_char(ds, ','); + } +} + +static void +format_ipv6_label(struct ds *ds, const char *name, ovs_be32 key, + const ovs_be32 *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + bool mask_full = !mask + || (*mask & htonl(IPV6_LABEL_MASK)) == htonl(IPV6_LABEL_MASK); + + ds_put_format(ds, "%s=%#"PRIx32, name, ntohl(key)); + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "/%#"PRIx32, ntohl(*mask)); + } + ds_put_char(ds, ','); + } +} + +static void +format_u8x(struct ds *ds, const char *name, uint8_t key, + const uint8_t *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + bool mask_full = !mask || *mask == UINT8_MAX; + + ds_put_format(ds, "%s=%#"PRIx8, name, key); + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "/%#"PRIx8, *mask); + } + ds_put_char(ds, ','); + } +} + +static void +format_u8u(struct ds *ds, const char *name, uint8_t key, + const uint8_t *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + bool mask_full = !mask || *mask == UINT8_MAX; + + ds_put_format(ds, "%s=%"PRIu8, name, key); + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "/%#"PRIx8, *mask); + } + ds_put_char(ds, ','); + } +} + +static void +format_be16(struct ds *ds, const char *name, ovs_be16 key, + const ovs_be16 *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + bool mask_full = !mask || *mask == OVS_BE16_MAX; + + ds_put_format(ds, "%s=%"PRIu16, name, ntohs(key)); + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "/%#"PRIx16, ntohs(*mask)); + } + ds_put_char(ds, ','); + } +} + +static void +format_be16x(struct ds *ds, const char *name, ovs_be16 key, + const ovs_be16 *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + bool mask_full = !mask || *mask == OVS_BE16_MAX; + + ds_put_format(ds, "%s=%#"PRIx16, name, ntohs(key)); + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "/%#"PRIx16, ntohs(*mask)); + } + ds_put_char(ds, ','); + } +} + +static void +format_tun_flags(struct ds *ds, const char *name, uint16_t key, + const uint16_t *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + if (verbose || !mask_empty) { + ds_put_cstr(ds, name); + ds_put_char(ds, '('); + 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, '|'); + } + 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) { - struct flow_tnl tun_key; - enum ovs_key_attr attr = nl_attr_type(a); - char namebuf[OVS_KEY_ATTR_BUFSIZE]; int expected_len; - bool is_exact; - is_exact = ma ? odp_mask_attr_is_exact(ma) : true; + expected_len = odp_key_attr_len(tbl, max_len, nl_attr_type(a)); + if (expected_len != ATTR_LEN_VARIABLE && + expected_len != ATTR_LEN_NESTED) { - ds_put_cstr(ds, ovs_key_attr_to_string(attr, namebuf, sizeof namebuf)); + bool bad_key_len = nl_attr_get_size(a) != expected_len; + bool bad_mask_len = ma && nl_attr_get_size(ma) != expected_len; - { - expected_len = odp_flow_key_attr_len(nl_attr_type(a)); - if (expected_len != -2) { - bool bad_key_len = nl_attr_get_size(a) != expected_len; - bool bad_mask_len = ma && nl_attr_get_size(a) != expected_len; - - if (bad_key_len || bad_mask_len) { - if (bad_key_len) { - ds_put_format(ds, "(bad key length %zu, expected %d)(", - nl_attr_get_size(a), - odp_flow_key_attr_len(nl_attr_type(a))); - } - format_generic_odp_key(a, ds); + if (bad_key_len || bad_mask_len) { + if (need_key) { + ds_put_format(ds, "key%u", nl_attr_type(a)); + } + if (bad_key_len) { + ds_put_format(ds, "(bad key length %"PRIuSIZE", expected %d)(", + nl_attr_get_size(a), expected_len); + } + format_generic_odp_key(a, ds); + if (ma) { + ds_put_char(ds, '/'); if (bad_mask_len) { - ds_put_char(ds, '/'); - ds_put_format(ds, "(bad mask length %zu, expected %d)(", - nl_attr_get_size(ma), - odp_flow_key_attr_len(nl_attr_type(ma))); + ds_put_format(ds, "(bad mask length %"PRIuSIZE", expected %d)(", + nl_attr_get_size(ma), expected_len); } format_generic_odp_key(ma, ds); - ds_put_char(ds, ')'); - return; + } + ds_put_char(ds, ')'); + return false; + } + } + + return true; +} + +static void +format_unknown_key(struct ds *ds, const struct nlattr *a, + const struct nlattr *ma) +{ + ds_put_format(ds, "key%u(", nl_attr_type(a)); + format_generic_odp_key(a, ds); + if (ma && !odp_mask_attr_is_exact(ma)) { + ds_put_char(ds, '/'); + format_generic_odp_key(ma, ds); + } + ds_put_cstr(ds, "),"); +} + +static void +format_odp_tun_vxlan_opt(const struct nlattr *attr, + const struct nlattr *mask_attr, struct ds *ds, + bool verbose) +{ + unsigned int left; + const struct nlattr *a; + struct ofpbuf ofp; + + ofpbuf_init(&ofp, 100); + NL_NESTED_FOR_EACH(a, left, attr) { + uint16_t type = nl_attr_type(a); + const struct nlattr *ma = NULL; + + if (mask_attr) { + ma = nl_attr_find__(nl_attr_get(mask_attr), + nl_attr_get_size(mask_attr), type); + if (!ma) { + ma = generate_all_wildcard_mask(ovs_vxlan_ext_attr_lens, + OVS_VXLAN_EXT_MAX, + &ofp, a); + } + } + + if (!check_attr_len(ds, a, ma, ovs_vxlan_ext_attr_lens, + OVS_VXLAN_EXT_MAX, true)) { + continue; + } + + switch (type) { + case OVS_VXLAN_EXT_GBP: { + uint32_t key = nl_attr_get_u32(a); + ovs_be16 id, id_mask; + uint8_t flags, flags_mask; + + id = htons(key & 0xFFFF); + flags = (key >> 16) & 0xFF; + if (ma) { + uint32_t mask = nl_attr_get_u32(ma); + id_mask = htons(mask & 0xFFFF); + flags_mask = (mask >> 16) & 0xFF; + } + + ds_put_cstr(ds, "gbp("); + format_be16(ds, "id", id, ma ? &id_mask : NULL, verbose); + format_u8x(ds, "flags", flags, ma ? &flags_mask : NULL, verbose); + ds_chomp(ds, ','); + ds_put_cstr(ds, "),"); + break; + } + + default: + format_unknown_key(ds, a, ma); + } + ofpbuf_clear(&ofp); + } + + 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; + + if (opts_len < sizeof *opt) { + ds_put_format(ds, "opt len %u less than minimum %"PRIuSIZE, + opts_len, sizeof *opt); + return; + } + + data_len = opt->length * 4; + if (mask) { + if (mask->length == 0x1f) { + data_len_mask = UINT8_MAX; + } else { + data_len_mask = mask->length; + } + } + len = sizeof *opt + data_len; + if (len > opts_len) { + ds_put_format(ds, "opt len %u greater than remaining %u", + len, opts_len); + return; + } + + ds_put_char(ds, '{'); + format_be16x(ds, "class", opt->opt_class, MASK(mask, opt_class), + verbose); + format_u8x(ds, "type", opt->type, MASK(mask, type), verbose); + format_u8u(ds, "len", data_len, mask ? &data_len_mask : NULL, verbose); + 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, '/'); + ds_put_hex(ds, mask + 1, data_len); + } + } else { + ds_chomp(ds, ','); + } + ds_put_char(ds, '}'); + + opt += len / sizeof(*opt); + if (mask) { + mask += len / sizeof(*opt); + } + opts_len -= len; + }; +} + +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) +{ + unsigned int left; + const struct nlattr *a; + uint16_t flags = 0; + uint16_t mask_flags = 0; + struct ofpbuf ofp; + + ofpbuf_init(&ofp, 100); + NL_NESTED_FOR_EACH(a, left, attr) { + enum ovs_tunnel_key_attr type = nl_attr_type(a); + const struct nlattr *ma = NULL; + + if (mask_attr) { + ma = nl_attr_find__(nl_attr_get(mask_attr), + nl_attr_get_size(mask_attr), type); + if (!ma) { + ma = generate_all_wildcard_mask(ovs_tun_key_attr_lens, + OVS_TUNNEL_KEY_ATTR_MAX, + &ofp, a); + } + } + + if (!check_attr_len(ds, a, ma, ovs_tun_key_attr_lens, + OVS_TUNNEL_KEY_ATTR_MAX, true)) { + continue; + } + + switch (type) { + case OVS_TUNNEL_KEY_ATTR_ID: + format_be64(ds, "tun_id", nl_attr_get_be64(a), + ma ? nl_attr_get(ma) : NULL, verbose); + flags |= FLOW_TNL_F_KEY; + if (ma) { + mask_flags |= FLOW_TNL_F_KEY; + } + break; + case OVS_TUNNEL_KEY_ATTR_IPV4_SRC: + format_ipv4(ds, "src", nl_attr_get_be32(a), + ma ? nl_attr_get(ma) : NULL, verbose); + break; + case OVS_TUNNEL_KEY_ATTR_IPV4_DST: + format_ipv4(ds, "dst", nl_attr_get_be32(a), + 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); + break; + case OVS_TUNNEL_KEY_ATTR_TTL: + format_u8u(ds, "ttl", nl_attr_get_u8(a), + ma ? nl_attr_get(ma) : NULL, verbose); + break; + case OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT: + flags |= FLOW_TNL_F_DONT_FRAGMENT; + break; + case OVS_TUNNEL_KEY_ATTR_CSUM: + flags |= FLOW_TNL_F_CSUM; + break; + case OVS_TUNNEL_KEY_ATTR_TP_SRC: + format_be16(ds, "tp_src", nl_attr_get_be16(a), + ma ? nl_attr_get(ma) : NULL, verbose); + break; + case OVS_TUNNEL_KEY_ATTR_TP_DST: + format_be16(ds, "tp_dst", nl_attr_get_be16(a), + ma ? nl_attr_get(ma) : NULL, verbose); + break; + case OVS_TUNNEL_KEY_ATTR_OAM: + flags |= FLOW_TNL_F_OAM; + break; + case OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS: + ds_put_cstr(ds, "vxlan("); + format_odp_tun_vxlan_opt(a, ma, ds, verbose); + ds_put_cstr(ds, "),"); + break; + case OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS: + ds_put_cstr(ds, "geneve("); + format_odp_tun_geneve(a, ma, ds, verbose); + ds_put_cstr(ds, "),"); + break; + case __OVS_TUNNEL_KEY_ATTR_MAX: + default: + format_unknown_key(ds, a, ma); + } + ofpbuf_clear(&ofp); + } + + /* Flags can have a valid mask even if the attribute is not set, so + * we need to collect these separately. */ + if (mask_attr) { + NL_NESTED_FOR_EACH(a, left, mask_attr) { + switch (nl_attr_type(a)) { + case OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT: + mask_flags |= FLOW_TNL_F_DONT_FRAGMENT; + break; + case OVS_TUNNEL_KEY_ATTR_CSUM: + mask_flags |= FLOW_TNL_F_CSUM; + break; + case OVS_TUNNEL_KEY_ATTR_OAM: + mask_flags |= FLOW_TNL_F_OAM; + break; } } } + format_tun_flags(ds, "flags", flags, mask_attr ? &mask_flags : NULL, + verbose); + ds_chomp(ds, ','); + 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"; + default: + return NULL; + } +} + +static void +format_frag(struct ds *ds, const char *name, uint8_t key, + const uint8_t *mask, bool verbose) +{ + bool mask_empty = mask && !*mask; + + /* ODP frag is an enumeration field; partial masks are not meaningful. */ + if (verbose || !mask_empty) { + bool mask_full = !mask || *mask == UINT8_MAX; + + if (!mask_full) { /* Partially masked. */ + ds_put_format(ds, "error: partial mask not supported for frag (%#" + PRIx8"),", *mask); + } else { + ds_put_format(ds, "%s=%s,", name, ovs_frag_type_to_string(key)); + } + } +} + +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); +} + +static void +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]; + bool is_exact; + + is_exact = ma ? odp_mask_attr_is_exact(ma) : true; + + 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: @@ -1019,51 +2187,43 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, case OVS_KEY_ATTR_PRIORITY: case OVS_KEY_ATTR_SKB_MARK: + case OVS_KEY_ATTR_DP_HASH: + case OVS_KEY_ATTR_RECIRC_ID: ds_put_format(ds, "%#"PRIx32, nl_attr_get_u32(a)); if (!is_exact) { ds_put_format(ds, "/%#"PRIx32, nl_attr_get_u32(ma)); } break; - case OVS_KEY_ATTR_TUNNEL: - memset(&tun_key, 0, sizeof tun_key); - if (odp_tun_key_from_attr(a, &tun_key) == ODP_FIT_ERROR) { - ds_put_format(ds, "error"); + 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) { - struct flow_tnl tun_mask; - - memset(&tun_mask, 0, sizeof tun_mask); - odp_tun_key_from_attr(ma, &tun_mask); - ds_put_format(ds, "tun_id=%#"PRIx64"/%#"PRIx64 - ",src="IP_FMT"/"IP_FMT",dst="IP_FMT"/"IP_FMT - ",tos=%#"PRIx8"/%#"PRIx8",ttl=%"PRIu8"/%#"PRIx8 - ",flags(", - ntohll(tun_key.tun_id), ntohll(tun_mask.tun_id), - IP_ARGS(tun_key.ip_src), IP_ARGS(tun_mask.ip_src), - IP_ARGS(tun_key.ip_dst), IP_ARGS(tun_mask.ip_dst), - tun_key.ip_tos, tun_mask.ip_tos, - tun_key.ip_ttl, tun_mask.ip_ttl); + 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; - format_flags(ds, flow_tun_flag_to_string, tun_key.flags, ','); + 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; - /* XXX This code is correct, but enabling it would break the unit - test. Disable it for now until the input parser is fixed. - ds_put_char(ds, '/'); - format_flags(ds, flow_tun_flag_to_string, tun_mask.flags, ','); - */ - ds_put_char(ds, ')'); - } else { - ds_put_format(ds, "tun_id=0x%"PRIx64",src="IP_FMT",dst="IP_FMT"," - "tos=0x%"PRIx8",ttl=%"PRIu8",flags(", - ntohll(tun_key.tun_id), - IP_ARGS(tun_key.ip_src), - IP_ARGS(tun_key.ip_dst), - tun_key.ip_tos, tun_key.ip_ttl); - - format_flags(ds, flow_tun_flag_to_string, tun_key.flags, ','); - ds_put_char(ds, ')'); - } + case OVS_KEY_ATTR_TUNNEL: + format_odp_tun_attr(a, ma, ds, verbose); break; case OVS_KEY_ATTR_IN_PORT: @@ -1083,54 +2243,41 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, } break; - case OVS_KEY_ATTR_ETHERNET: - if (!is_exact) { - const struct ovs_key_ethernet *eth_mask = nl_attr_get(ma); - const struct ovs_key_ethernet *eth_key = nl_attr_get(a); - - ds_put_format(ds, "src="ETH_ADDR_FMT"/"ETH_ADDR_FMT - ",dst="ETH_ADDR_FMT"/"ETH_ADDR_FMT, - ETH_ADDR_ARGS(eth_key->eth_src), - ETH_ADDR_ARGS(eth_mask->eth_src), - ETH_ADDR_ARGS(eth_key->eth_dst), - ETH_ADDR_ARGS(eth_mask->eth_dst)); - } else { - const struct ovs_key_ethernet *eth_key = nl_attr_get(a); + 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); - ds_put_format(ds, "src="ETH_ADDR_FMT",dst="ETH_ADDR_FMT, - ETH_ADDR_ARGS(eth_key->eth_src), - ETH_ADDR_ARGS(eth_key->eth_dst)); - } + format_eth(ds, "src", key->eth_src, MASK(mask, eth_src), verbose); + format_eth(ds, "dst", key->eth_dst, MASK(mask, eth_dst), verbose); + ds_chomp(ds, ','); break; - + } case OVS_KEY_ATTR_VLAN: - { - ovs_be16 vlan_tci = nl_attr_get_be16(a); - if (!is_exact) { - ovs_be16 mask = nl_attr_get_be16(ma); - ds_put_format(ds, "vid=%"PRIu16"/0x%"PRIx16",pcp=%d/0x%x,cfi=%d/%d", - vlan_tci_to_vid(vlan_tci), - vlan_tci_to_vid(mask), - vlan_tci_to_pcp(vlan_tci), - vlan_tci_to_pcp(mask), - vlan_tci_to_cfi(vlan_tci), - vlan_tci_to_cfi(mask)); - } else { - format_vlan_tci(ds, vlan_tci); - } - } + format_vlan_tci(ds, nl_attr_get_be16(a), + ma ? nl_attr_get_be16(ma) : OVS_BE16_MAX, verbose); break; case OVS_KEY_ATTR_MPLS: { const struct ovs_key_mpls *mpls_key = nl_attr_get(a); const struct ovs_key_mpls *mpls_mask = NULL; + size_t size = nl_attr_get_size(a); + + if (!size || size % sizeof *mpls_key) { + ds_put_format(ds, "(bad key length %"PRIuSIZE")", size); + return; + } if (!is_exact) { mpls_mask = nl_attr_get(ma); + if (size != nl_attr_get_size(ma)) { + ds_put_format(ds, "(key length %"PRIuSIZE" != " + "mask length %"PRIuSIZE")", + size, nl_attr_get_size(ma)); + return; + } } - format_mpls(ds, mpls_key, mpls_mask); + format_mpls(ds, mpls_key, mpls_mask, size / sizeof *mpls_key); break; } - case OVS_KEY_ATTR_ETHERTYPE: ds_put_format(ds, "0x%04"PRIx16, ntohs(nl_attr_get_be16(a))); if (!is_exact) { @@ -1138,229 +2285,108 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, } break; - case OVS_KEY_ATTR_IPV4: - if (!is_exact) { - const struct ovs_key_ipv4 *ipv4_key = nl_attr_get(a); - const struct ovs_key_ipv4 *ipv4_mask = nl_attr_get(ma); - - ds_put_format(ds, "src="IP_FMT"/"IP_FMT",dst="IP_FMT"/"IP_FMT - ",proto=%"PRIu8"/%#"PRIx8",tos=%#"PRIx8"/%#"PRIx8 - ",ttl=%"PRIu8"/%#"PRIx8",frag=%s/%#"PRIx8, - IP_ARGS(ipv4_key->ipv4_src), - IP_ARGS(ipv4_mask->ipv4_src), - IP_ARGS(ipv4_key->ipv4_dst), - IP_ARGS(ipv4_mask->ipv4_dst), - ipv4_key->ipv4_proto, ipv4_mask->ipv4_proto, - ipv4_key->ipv4_tos, ipv4_mask->ipv4_tos, - ipv4_key->ipv4_ttl, ipv4_mask->ipv4_ttl, - ovs_frag_type_to_string(ipv4_key->ipv4_frag), - ipv4_mask->ipv4_frag); - } else { - const struct ovs_key_ipv4 *ipv4_key = nl_attr_get(a); - - ds_put_format(ds, "src="IP_FMT",dst="IP_FMT",proto=%"PRIu8 - ",tos=%#"PRIx8",ttl=%"PRIu8",frag=%s", - IP_ARGS(ipv4_key->ipv4_src), - IP_ARGS(ipv4_key->ipv4_dst), - ipv4_key->ipv4_proto, ipv4_key->ipv4_tos, - ipv4_key->ipv4_ttl, - ovs_frag_type_to_string(ipv4_key->ipv4_frag)); - } + case OVS_KEY_ATTR_IPV4: { + const struct ovs_key_ipv4 *key = nl_attr_get(a); + const struct ovs_key_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_u8x(ds, "tos", key->ipv4_tos, MASK(mask, ipv4_tos), verbose); + format_u8u(ds, "ttl", key->ipv4_ttl, MASK(mask, ipv4_ttl), verbose); + format_frag(ds, "frag", key->ipv4_frag, MASK(mask, ipv4_frag), + verbose); + ds_chomp(ds, ','); break; - - case OVS_KEY_ATTR_IPV6: - if (!is_exact) { - const struct ovs_key_ipv6 *ipv6_key, *ipv6_mask; - char src_str[INET6_ADDRSTRLEN]; - char dst_str[INET6_ADDRSTRLEN]; - char src_mask[INET6_ADDRSTRLEN]; - char dst_mask[INET6_ADDRSTRLEN]; - - ipv6_key = nl_attr_get(a); - inet_ntop(AF_INET6, ipv6_key->ipv6_src, src_str, sizeof src_str); - inet_ntop(AF_INET6, ipv6_key->ipv6_dst, dst_str, sizeof dst_str); - - ipv6_mask = nl_attr_get(ma); - inet_ntop(AF_INET6, ipv6_mask->ipv6_src, src_mask, sizeof src_mask); - inet_ntop(AF_INET6, ipv6_mask->ipv6_dst, dst_mask, sizeof dst_mask); - - ds_put_format(ds, "src=%s/%s,dst=%s/%s,label=%#"PRIx32"/%#"PRIx32 - ",proto=%"PRIu8"/%#"PRIx8",tclass=%#"PRIx8"/%#"PRIx8 - ",hlimit=%"PRIu8"/%#"PRIx8",frag=%s/%#"PRIx8, - src_str, src_mask, dst_str, dst_mask, - ntohl(ipv6_key->ipv6_label), - ntohl(ipv6_mask->ipv6_label), - ipv6_key->ipv6_proto, ipv6_mask->ipv6_proto, - ipv6_key->ipv6_tclass, ipv6_mask->ipv6_tclass, - ipv6_key->ipv6_hlimit, ipv6_mask->ipv6_hlimit, - ovs_frag_type_to_string(ipv6_key->ipv6_frag), - ipv6_mask->ipv6_frag); - } else { - const struct ovs_key_ipv6 *ipv6_key; - char src_str[INET6_ADDRSTRLEN]; - char dst_str[INET6_ADDRSTRLEN]; - - ipv6_key = nl_attr_get(a); - inet_ntop(AF_INET6, ipv6_key->ipv6_src, src_str, sizeof src_str); - inet_ntop(AF_INET6, ipv6_key->ipv6_dst, dst_str, sizeof dst_str); - - ds_put_format(ds, "src=%s,dst=%s,label=%#"PRIx32",proto=%"PRIu8 - ",tclass=%#"PRIx8",hlimit=%"PRIu8",frag=%s", - src_str, dst_str, ntohl(ipv6_key->ipv6_label), - ipv6_key->ipv6_proto, ipv6_key->ipv6_tclass, - ipv6_key->ipv6_hlimit, - ovs_frag_type_to_string(ipv6_key->ipv6_frag)); - } + } + case OVS_KEY_ATTR_IPV6: { + 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_ipv6_label(ds, "label", key->ipv6_label, MASK(mask, ipv6_label), + verbose); + format_u8u(ds, "proto", key->ipv6_proto, MASK(mask, ipv6_proto), + verbose); + format_u8x(ds, "tclass", key->ipv6_tclass, MASK(mask, ipv6_tclass), + verbose); + format_u8u(ds, "hlimit", key->ipv6_hlimit, MASK(mask, ipv6_hlimit), + verbose); + format_frag(ds, "frag", key->ipv6_frag, MASK(mask, ipv6_frag), + verbose); + ds_chomp(ds, ','); break; - + } + /* These have the same structure and format. */ case OVS_KEY_ATTR_TCP: - if (!is_exact) { - const struct ovs_key_tcp *tcp_mask = nl_attr_get(ma); - const struct ovs_key_tcp *tcp_key = nl_attr_get(a); - - ds_put_format(ds, "src=%"PRIu16"/%#"PRIx16 - ",dst=%"PRIu16"/%#"PRIx16, - ntohs(tcp_key->tcp_src), ntohs(tcp_mask->tcp_src), - ntohs(tcp_key->tcp_dst), ntohs(tcp_mask->tcp_dst)); - } else { - const struct ovs_key_tcp *tcp_key = nl_attr_get(a); - - ds_put_format(ds, "src=%"PRIu16",dst=%"PRIu16, - ntohs(tcp_key->tcp_src), ntohs(tcp_key->tcp_dst)); - } - break; - case OVS_KEY_ATTR_UDP: - if (!is_exact) { - const struct ovs_key_udp *udp_mask = nl_attr_get(ma); - const struct ovs_key_udp *udp_key = nl_attr_get(a); + case OVS_KEY_ATTR_SCTP: { + const struct ovs_key_tcp *key = nl_attr_get(a); + const struct ovs_key_tcp *mask = ma ? nl_attr_get(ma) : NULL; - ds_put_format(ds, "src=%"PRIu16"/%#"PRIx16 - ",dst=%"PRIu16"/%#"PRIx16, - ntohs(udp_key->udp_src), ntohs(udp_mask->udp_src), - ntohs(udp_key->udp_dst), ntohs(udp_mask->udp_dst)); - } else { - const struct ovs_key_udp *udp_key = nl_attr_get(a); - - ds_put_format(ds, "src=%"PRIu16",dst=%"PRIu16, - ntohs(udp_key->udp_src), ntohs(udp_key->udp_dst)); - } + format_be16(ds, "src", key->tcp_src, MASK(mask, tcp_src), verbose); + format_be16(ds, "dst", key->tcp_dst, MASK(mask, tcp_dst), verbose); + ds_chomp(ds, ','); break; - - case OVS_KEY_ATTR_SCTP: - if (ma) { - const struct ovs_key_sctp *sctp_mask = nl_attr_get(ma); - const struct ovs_key_sctp *sctp_key = nl_attr_get(a); - - ds_put_format(ds, "src=%"PRIu16"/%#"PRIx16 - ",dst=%"PRIu16"/%#"PRIx16, - ntohs(sctp_key->sctp_src), ntohs(sctp_mask->sctp_src), - ntohs(sctp_key->sctp_dst), ntohs(sctp_mask->sctp_dst)); - } else { - const struct ovs_key_sctp *sctp_key = nl_attr_get(a); - - ds_put_format(ds, "(src=%"PRIu16",dst=%"PRIu16")", - ntohs(sctp_key->sctp_src), ntohs(sctp_key->sctp_dst)); - } - break; - - case OVS_KEY_ATTR_ICMP: + } + case OVS_KEY_ATTR_TCP_FLAGS: if (!is_exact) { - const struct ovs_key_icmp *icmp_mask = nl_attr_get(ma); - const struct ovs_key_icmp *icmp_key = nl_attr_get(a); - - ds_put_format(ds, "type=%"PRIu8"/%#"PRIx8",code=%"PRIu8"/%#"PRIx8, - icmp_key->icmp_type, icmp_mask->icmp_type, - icmp_key->icmp_code, icmp_mask->icmp_code); + format_flags_masked(ds, NULL, packet_tcp_flag_to_string, + ntohs(nl_attr_get_be16(a)), + TCP_FLAGS(nl_attr_get_be16(ma)), + TCP_FLAGS(OVS_BE16_MAX)); } else { - const struct ovs_key_icmp *icmp_key = nl_attr_get(a); - - ds_put_format(ds, "type=%"PRIu8",code=%"PRIu8, - icmp_key->icmp_type, icmp_key->icmp_code); + format_flags(ds, packet_tcp_flag_to_string, + ntohs(nl_attr_get_be16(a)), '|'); } break; - case OVS_KEY_ATTR_ICMPV6: - if (!is_exact) { - const struct ovs_key_icmpv6 *icmpv6_mask = nl_attr_get(ma); - const struct ovs_key_icmpv6 *icmpv6_key = nl_attr_get(a); - - ds_put_format(ds, "type=%"PRIu8"/%#"PRIx8",code=%"PRIu8"/%#"PRIx8, - icmpv6_key->icmpv6_type, icmpv6_mask->icmpv6_type, - icmpv6_key->icmpv6_code, icmpv6_mask->icmpv6_code); - } else { - const struct ovs_key_icmpv6 *icmpv6_key = nl_attr_get(a); + case OVS_KEY_ATTR_ICMP: { + const struct ovs_key_icmp *key = nl_attr_get(a); + const struct ovs_key_icmp *mask = ma ? nl_attr_get(ma) : NULL; - ds_put_format(ds, "type=%"PRIu8",code=%"PRIu8, - icmpv6_key->icmpv6_type, icmpv6_key->icmpv6_code); - } + format_u8u(ds, "type", key->icmp_type, MASK(mask, icmp_type), verbose); + format_u8u(ds, "code", key->icmp_code, MASK(mask, icmp_code), verbose); + ds_chomp(ds, ','); break; + } + case OVS_KEY_ATTR_ICMPV6: { + const struct ovs_key_icmpv6 *key = nl_attr_get(a); + const struct ovs_key_icmpv6 *mask = ma ? nl_attr_get(ma) : NULL; - case OVS_KEY_ATTR_ARP: - if (!is_exact) { - const struct ovs_key_arp *arp_mask = nl_attr_get(ma); - const struct ovs_key_arp *arp_key = nl_attr_get(a); - - ds_put_format(ds, "sip="IP_FMT"/"IP_FMT",tip="IP_FMT"/"IP_FMT - ",op=%"PRIu16"/%#"PRIx16 - ",sha="ETH_ADDR_FMT"/"ETH_ADDR_FMT - ",tha="ETH_ADDR_FMT"/"ETH_ADDR_FMT, - IP_ARGS(arp_key->arp_sip), - IP_ARGS(arp_mask->arp_sip), - IP_ARGS(arp_key->arp_tip), - IP_ARGS(arp_mask->arp_tip), - ntohs(arp_key->arp_op), ntohs(arp_mask->arp_op), - ETH_ADDR_ARGS(arp_key->arp_sha), - ETH_ADDR_ARGS(arp_mask->arp_sha), - ETH_ADDR_ARGS(arp_key->arp_tha), - ETH_ADDR_ARGS(arp_mask->arp_tha)); - } else { - const struct ovs_key_arp *arp_key = nl_attr_get(a); - - ds_put_format(ds, "sip="IP_FMT",tip="IP_FMT",op=%"PRIu16"," - "sha="ETH_ADDR_FMT",tha="ETH_ADDR_FMT, - IP_ARGS(arp_key->arp_sip), IP_ARGS(arp_key->arp_tip), - ntohs(arp_key->arp_op), - ETH_ADDR_ARGS(arp_key->arp_sha), - ETH_ADDR_ARGS(arp_key->arp_tha)); - } + format_u8u(ds, "type", key->icmpv6_type, MASK(mask, icmpv6_type), + verbose); + format_u8u(ds, "code", key->icmpv6_code, MASK(mask, icmpv6_code), + verbose); + ds_chomp(ds, ','); break; + } + case OVS_KEY_ATTR_ARP: { + const struct ovs_key_arp *mask = ma ? nl_attr_get(ma) : NULL; + const struct ovs_key_arp *key = nl_attr_get(a); + format_ipv4(ds, "sip", key->arp_sip, MASK(mask, arp_sip), verbose); + format_ipv4(ds, "tip", key->arp_tip, MASK(mask, arp_tip), verbose); + format_be16(ds, "op", key->arp_op, MASK(mask, arp_op), verbose); + format_eth(ds, "sha", key->arp_sha, MASK(mask, arp_sha), verbose); + format_eth(ds, "tha", key->arp_tha, MASK(mask, arp_tha), verbose); + ds_chomp(ds, ','); + break; + } case OVS_KEY_ATTR_ND: { - const struct ovs_key_nd *nd_key, *nd_mask = NULL; - char target[INET6_ADDRSTRLEN]; - - nd_key = nl_attr_get(a); - if (!is_exact) { - nd_mask = nl_attr_get(ma); - } + const struct ovs_key_nd *mask = ma ? nl_attr_get(ma) : NULL; + const struct ovs_key_nd *key = nl_attr_get(a); - inet_ntop(AF_INET6, nd_key->nd_target, target, sizeof target); - ds_put_format(ds, "target=%s", target); - if (!is_exact) { - inet_ntop(AF_INET6, nd_mask->nd_target, target, sizeof target); - ds_put_format(ds, "/%s", target); - } + format_ipv6(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); - if (!eth_addr_is_zero(nd_key->nd_sll)) { - ds_put_format(ds, ",sll="ETH_ADDR_FMT, - ETH_ADDR_ARGS(nd_key->nd_sll)); - if (!is_exact) { - ds_put_format(ds, "/"ETH_ADDR_FMT, - ETH_ADDR_ARGS(nd_mask->nd_sll)); - } - } - if (!eth_addr_is_zero(nd_key->nd_tll)) { - ds_put_format(ds, ",tll="ETH_ADDR_FMT, - ETH_ADDR_ARGS(nd_key->nd_tll)); - if (!is_exact) { - ds_put_format(ds, "/"ETH_ADDR_FMT, - ETH_ADDR_ARGS(nd_mask->nd_tll)); - } - } + ds_chomp(ds, ','); break; } - case OVS_KEY_ATTR_UNSPEC: case __OVS_KEY_ATTR_MAX: default: @@ -1375,21 +2401,27 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, } static struct nlattr * -generate_all_wildcard_mask(struct ofpbuf *ofp, const struct nlattr *key) +generate_all_wildcard_mask(const struct attr_len_tbl tbl[], int max, + struct ofpbuf *ofp, const struct nlattr *key) { const struct nlattr *a; unsigned int left; int type = nl_attr_type(key); int size = nl_attr_get_size(key); - if (odp_flow_key_attr_len(type) >=0) { - memset(nl_msg_put_unspec_uninit(ofp, type, size), 0, size); + if (odp_key_attr_len(tbl, max, type) != ATTR_LEN_NESTED) { + nl_msg_put_unspec_zero(ofp, type, size); } else { size_t nested_mask; + if (tbl[type].next) { + tbl = tbl[type].next; + max = tbl[type].next_max; + } + nested_mask = nl_msg_start_nested(ofp, type); NL_ATTR_FOR_EACH(a, left, key, nl_attr_get_size(key)) { - generate_all_wildcard_mask(ofp, nl_attr_get(a)); + generate_all_wildcard_mask(tbl, max, ofp, nl_attr_get(a)); } nl_msg_end_nested(ofp, nested_mask); } @@ -1397,6 +2429,31 @@ generate_all_wildcard_mask(struct ofpbuf *ofp, const struct nlattr *key) return ofp->base; } +int +odp_ufid_from_string(const char *s_, ovs_u128 *ufid) +{ + const char *s = s_; + + if (ovs_scan(s, "ufid:")) { + s += 5; + + if (!uuid_from_string_prefix((struct uuid *)ufid, s)) { + return -EINVAL; + } + s += UUID_LEN; + + return s - s_; + } + + return 0; +} + +void +odp_format_ufid(const ovs_u128 *ufid, struct ds *ds) +{ + 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 @@ -1424,7 +2481,9 @@ odp_flow_format(const struct nlattr *key, size_t key_len, has_ethtype_key = true; } - is_nested_attr = (odp_flow_key_attr_len(attr_type) == -2); + is_nested_attr = odp_key_attr_len(ovs_flow_key_attr_lens, + OVS_KEY_ATTR_MAX, attr_type) == + ATTR_LEN_NESTED; if (mask && mask_len) { ma = nl_attr_find__(mask, mask_len, nl_attr_type(a)); @@ -1433,7 +2492,9 @@ odp_flow_format(const struct nlattr *key, size_t key_len, if (verbose || !is_wildcard || is_nested_attr) { if (is_wildcard && !ma) { - ma = generate_all_wildcard_mask(&ofp, a); + ma = generate_all_wildcard_mask(ovs_flow_key_attr_lens, + OVS_KEY_ATTR_MAX, + &ofp, a); } if (!first_field) { ds_put_char(ds, ','); @@ -1478,872 +2539,954 @@ odp_flow_key_format(const struct nlattr *key, odp_flow_format(key, key_len, NULL, 0, NULL, ds, true); } -static void -put_nd(struct ovs_key_nd* nd_key, const uint8_t *nd_sll, - const uint8_t *nd_tll, struct ofpbuf *key) +static bool +ovs_frag_type_from_string(const char *s, enum ovs_frag_type *type) { - if (nd_sll) { - memcpy(nd_key->nd_sll, nd_sll, ETH_ADDR_LEN); + if (!strcasecmp(s, "no")) { + *type = OVS_FRAG_TYPE_NONE; + } else if (!strcasecmp(s, "first")) { + *type = OVS_FRAG_TYPE_FIRST; + } else if (!strcasecmp(s, "later")) { + *type = OVS_FRAG_TYPE_LATER; + } else { + return false; } + return true; +} - if (nd_tll) { - memcpy(nd_key->nd_tll, nd_tll, ETH_ADDR_LEN); - } +/* Parsing. */ - nl_msg_put_unspec(key, OVS_KEY_ATTR_ND, nd_key, sizeof *nd_key); +static int +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)) { + int len = n; + + if (mask) { + if (ovs_scan(s + len, "/"ETH_ADDR_SCAN_FMT"%n", + ETH_ADDR_SCAN_ARGS(*mask), &n)) { + len += n; + } else { + memset(mask, 0xff, sizeof *mask); + } + } + return len; + } + return 0; } static int -put_nd_key(int n, const char *nd_target_s, const uint8_t *nd_sll, - const uint8_t *nd_tll, struct ofpbuf *key) +scan_ipv4(const char *s, ovs_be32 *key, ovs_be32 *mask) { - struct ovs_key_nd nd_key; + int n; - memset(&nd_key, 0, sizeof nd_key); + if (ovs_scan(s, IP_SCAN_FMT"%n", IP_SCAN_ARGS(key), &n)) { + int len = n; - if (inet_pton(AF_INET6, nd_target_s, nd_key.nd_target) != 1) { - return -EINVAL; + if (mask) { + if (ovs_scan(s + len, "/"IP_SCAN_FMT"%n", + IP_SCAN_ARGS(mask), &n)) { + len += n; + } else { + *mask = OVS_BE32_MAX; + } + } + return len; } + return 0; +} - put_nd(&nd_key, nd_sll, nd_tll, key); - return n; +static int +scan_ipv6(const char *s, ovs_be32 (*key)[4], ovs_be32 (*mask)[4]) +{ + int n; + char ipv6_s[IPV6_SCAN_LEN + 1]; + + if (ovs_scan(s, IPV6_SCAN_FMT"%n", ipv6_s, &n) + && inet_pton(AF_INET6, ipv6_s, key) == 1) { + int len = n; + + if (mask) { + if (ovs_scan(s + len, "/"IPV6_SCAN_FMT"%n", ipv6_s, &n) + && inet_pton(AF_INET6, ipv6_s, mask) == 1) { + len += n; + } else { + memset(mask, 0xff, sizeof *mask); + } + } + return len; + } + return 0; } static int -put_nd_mask(int n, const char *nd_target_s, - const uint8_t *nd_sll, const uint8_t *nd_tll, struct ofpbuf *mask) +scan_ipv6_label(const char *s, ovs_be32 *key, ovs_be32 *mask) { - struct ovs_key_nd nd_mask; + int key_, mask_; + int n; - memset(&nd_mask, 0xff, sizeof nd_mask); + if (ovs_scan(s, "%i%n", &key_, &n) + && (key_ & ~IPV6_LABEL_MASK) == 0) { + int len = n; - if (strlen(nd_target_s) != 0 && - inet_pton(AF_INET6, nd_target_s, nd_mask.nd_target) != 1) { - return -EINVAL; + *key = htonl(key_); + if (mask) { + if (ovs_scan(s + len, "/%i%n", &mask_, &n) + && (mask_ & ~IPV6_LABEL_MASK) == 0) { + len += n; + *mask = htonl(mask_); + } else { + *mask = htonl(IPV6_LABEL_MASK); + } + } + return len; } + return 0; +} - put_nd(&nd_mask, nd_sll, nd_tll, mask); - return n; +static int +scan_u8(const char *s, uint8_t *key, uint8_t *mask) +{ + int n; + + if (ovs_scan(s, "%"SCNi8"%n", key, &n)) { + int len = n; + + if (mask) { + if (ovs_scan(s + len, "/%"SCNi8"%n", mask, &n)) { + len += n; + } else { + *mask = UINT8_MAX; + } + } + return len; + } + return 0; } -static bool -ovs_frag_type_from_string(const char *s, enum ovs_frag_type *type) +static int +scan_u16(const char *s, uint16_t *key, uint16_t *mask) { - if (!strcasecmp(s, "no")) { - *type = OVS_FRAG_TYPE_NONE; - } else if (!strcasecmp(s, "first")) { - *type = OVS_FRAG_TYPE_FIRST; - } else if (!strcasecmp(s, "later")) { - *type = OVS_FRAG_TYPE_LATER; - } else { - return false; + 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 true; + return 0; } -static ovs_be32 -mpls_lse_from_components(int mpls_label, int mpls_tc, int mpls_ttl, int mpls_bos) +static int +scan_u32(const char *s, uint32_t *key, uint32_t *mask) { - return (htonl((mpls_label << MPLS_LABEL_SHIFT) | - (mpls_tc << MPLS_TC_SHIFT) | - (mpls_ttl << MPLS_TTL_SHIFT) | - (mpls_bos << MPLS_BOS_SHIFT))); + int n; + + if (ovs_scan(s, "%"SCNi32"%n", key, &n)) { + int len = n; + + if (mask) { + if (ovs_scan(s + len, "/%"SCNi32"%n", mask, &n)) { + len += n; + } else { + *mask = UINT32_MAX; + } + } + return len; + } + return 0; } static int -parse_odp_key_mask_attr(const char *s, const struct simap *port_names, - struct ofpbuf *key, struct ofpbuf *mask) +scan_be16(const char *s, ovs_be16 *key, ovs_be16 *mask) { - /* Many of the sscanf calls in this function use oversized destination - * fields because some sscanf() implementations truncate the range of %i - * directives, so that e.g. "%"SCNi16 interprets input of "0xfedc" as a - * value of 0x7fff. The other alternatives are to allow only a single - * radix (e.g. decimal or hexadecimal) or to write more sophisticated - * parsers. - * - * The tun_id parser has to use an alternative approach because there is no - * type larger than 64 bits. */ + uint16_t key_, mask_; + int n; - { - unsigned long long int priority; - unsigned long long int priority_mask; - int n = -1; + if (ovs_scan(s, "%"SCNi16"%n", &key_, &n)) { + int len = n; - if (mask && sscanf(s, "skb_priority(%lli/%lli)%n", &priority, - &priority_mask, &n) > 0 && n > 0) { - nl_msg_put_u32(key, OVS_KEY_ATTR_PRIORITY, priority); - nl_msg_put_u32(mask, OVS_KEY_ATTR_PRIORITY, priority_mask); - return n; - } else if (sscanf(s, "skb_priority(%lli)%n", - &priority, &n) > 0 && n > 0) { - nl_msg_put_u32(key, OVS_KEY_ATTR_PRIORITY, priority); - if (mask) { - nl_msg_put_u32(mask, OVS_KEY_ATTR_PRIORITY, UINT32_MAX); + *key = htons(key_); + if (mask) { + if (ovs_scan(s + len, "/%"SCNi16"%n", &mask_, &n)) { + len += n; + *mask = htons(mask_); + } else { + *mask = OVS_BE16_MAX; } - return n; } + return len; } + return 0; +} - { - unsigned long long int mark; - unsigned long long int mark_mask; - int n = -1; +static int +scan_be64(const char *s, ovs_be64 *key, ovs_be64 *mask) +{ + uint64_t key_, mask_; + int n; - if (mask && sscanf(s, "skb_mark(%lli/%lli)%n", &mark, - &mark_mask, &n) > 0 && n > 0) { - nl_msg_put_u32(key, OVS_KEY_ATTR_SKB_MARK, mark); - nl_msg_put_u32(mask, OVS_KEY_ATTR_SKB_MARK, mark_mask); - return n; - } else if (sscanf(s, "skb_mark(%lli)%n", &mark, &n) > 0 && n > 0) { - nl_msg_put_u32(key, OVS_KEY_ATTR_SKB_MARK, mark); - if (mask) { - nl_msg_put_u32(mask, OVS_KEY_ATTR_SKB_MARK, UINT32_MAX); + if (ovs_scan(s, "%"SCNi64"%n", &key_, &n)) { + int len = n; + + *key = htonll(key_); + if (mask) { + if (ovs_scan(s + len, "/%"SCNi64"%n", &mask_, &n)) { + len += n; + *mask = htonll(mask_); + } else { + *mask = OVS_BE64_MAX; } - return n; } + return len; + } + return 0; +} + +static int +scan_tun_flags(const char *s, uint16_t *key, uint16_t *mask) +{ + uint32_t flags, fmask; + int n; + + 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) { + *mask = fmask; + } + return n + 1; + } + return 0; +} + +static int +scan_tcp_flags(const char *s, ovs_be16 *key, ovs_be16 *mask) +{ + uint32_t flags, fmask; + int n; + + 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) { + *mask = htons(fmask); + } + return n; + } + return 0; +} + +static uint32_t +ovs_to_odp_ct_state(uint8_t state) +{ + uint32_t odp = 0; + + if (state & CS_NEW) { + odp |= OVS_CS_F_NEW; + } + if (state & CS_ESTABLISHED) { + odp |= OVS_CS_F_ESTABLISHED; + } + if (state & CS_RELATED) { + odp |= OVS_CS_F_RELATED; + } + if (state & CS_INVALID) { + odp |= OVS_CS_F_INVALID; + } + if (state & CS_REPLY_DIR) { + odp |= OVS_CS_F_REPLY_DIR; + } + if (state & CS_TRACKED) { + odp |= OVS_CS_F_TRACKED; + } + + return odp; +} + +static uint8_t +odp_to_ovs_ct_state(uint32_t flags) +{ + uint32_t state = 0; + + if (flags & OVS_CS_F_NEW) { + state |= CS_NEW; + } + if (flags & OVS_CS_F_ESTABLISHED) { + state |= CS_ESTABLISHED; + } + if (flags & OVS_CS_F_RELATED) { + state |= CS_RELATED; + } + if (flags & OVS_CS_F_INVALID) { + state |= CS_INVALID; + } + if (flags & OVS_CS_F_REPLY_DIR) { + state |= CS_REPLY_DIR; + } + if (flags & OVS_CS_F_TRACKED) { + state |= CS_TRACKED; } - { - char tun_id_s[32]; - int tos, tos_mask, ttl, ttl_mask; - struct flow_tnl tun_key, tun_key_mask; - unsigned long long tun_id_mask; - int n = -1; - - if (mask && sscanf(s, "tunnel(tun_id=%31[x0123456789abcdefABCDEF]/%llx," - "src="IP_SCAN_FMT"/"IP_SCAN_FMT",dst="IP_SCAN_FMT - "/"IP_SCAN_FMT",tos=%i/%i,ttl=%i/%i,flags%n", - tun_id_s, &tun_id_mask, - IP_SCAN_ARGS(&tun_key.ip_src), - IP_SCAN_ARGS(&tun_key_mask.ip_src), - IP_SCAN_ARGS(&tun_key.ip_dst), - IP_SCAN_ARGS(&tun_key_mask.ip_dst), - &tos, &tos_mask, &ttl, &ttl_mask, - &n) > 0 && n > 0) { - int res; - uint32_t flags; - - tun_key.tun_id = htonll(strtoull(tun_id_s, NULL, 0)); - tun_key_mask.tun_id = htonll(tun_id_mask); - tun_key.ip_tos = tos; - tun_key_mask.ip_tos = tos_mask; - tun_key.ip_ttl = ttl; - tun_key_mask.ip_ttl = ttl_mask; - res = parse_flags(&s[n], flow_tun_flag_to_string, &flags); - tun_key.flags = flags; - tun_key_mask.flags = UINT16_MAX; - - if (res < 0) { - return res; - } - n += res; - if (s[n] != ')') { - return -EINVAL; - } - n++; - tun_key_to_attr(key, &tun_key); - if (mask) { - tun_key_to_attr(mask, &tun_key_mask); - } - return n; - } else if (sscanf(s, "tunnel(tun_id=%31[x0123456789abcdefABCDEF]," - "src="IP_SCAN_FMT",dst="IP_SCAN_FMT - ",tos=%i,ttl=%i,flags%n", tun_id_s, - IP_SCAN_ARGS(&tun_key.ip_src), - IP_SCAN_ARGS(&tun_key.ip_dst), &tos, &ttl, - &n) > 0 && n > 0) { - int res; - uint32_t flags; + return state; +} - tun_key.tun_id = htonll(strtoull(tun_id_s, NULL, 0)); - tun_key.ip_tos = tos; - tun_key.ip_ttl = ttl; - res = parse_flags(&s[n], flow_tun_flag_to_string, &flags); - tun_key.flags = flags; +static int +scan_ct_state(const char *s, uint32_t *key, uint32_t *mask) +{ + uint32_t flags, fmask; + int n; - if (res < 0) { - return res; - } - n += res; - if (s[n] != ')') { - return -EINVAL; - } - n++; - tun_key_to_attr(key, &tun_key); + n = parse_flags(s, odp_ct_state_to_string, ')', NULL, NULL, &flags, + ovs_to_odp_ct_state(CS_SUPPORTED_MASK), + mask ? &fmask : NULL); - if (mask) { - memset(&tun_key, 0xff, sizeof tun_key); - tun_key_to_attr(mask, &tun_key); - } - return n; + if (n >= 0) { + *key = flags; + if (mask) { + *mask = fmask; } + return n; } + return 0; +} - { - unsigned long long int in_port; - unsigned long long int in_port_mask; - int n = -1; +static int +scan_frag(const char *s, uint8_t *key, uint8_t *mask) +{ + int n; + char frag[8]; + enum ovs_frag_type frag_type; - if (mask && sscanf(s, "in_port(%lli/%lli)%n", &in_port, - &in_port_mask, &n) > 0 && n > 0) { - nl_msg_put_u32(key, OVS_KEY_ATTR_IN_PORT, in_port); - nl_msg_put_u32(mask, OVS_KEY_ATTR_IN_PORT, in_port_mask); - return n; - } else if (sscanf(s, "in_port(%lli)%n", &in_port, &n) > 0 && n > 0) { - nl_msg_put_u32(key, OVS_KEY_ATTR_IN_PORT, in_port); - if (mask) { - nl_msg_put_u32(mask, OVS_KEY_ATTR_IN_PORT, UINT32_MAX); - } - return n; + if (ovs_scan(s, "%7[a-z]%n", frag, &n) + && ovs_frag_type_from_string(frag, &frag_type)) { + int len = n; + + *key = frag_type; + if (mask) { + *mask = UINT8_MAX; } + return len; } + return 0; +} + +static int +scan_port(const char *s, uint32_t *key, uint32_t *mask, + const struct simap *port_names) +{ + int n; + if (ovs_scan(s, "%"SCNi32"%n", key, &n)) { + int len = n; - if (port_names && !strncmp(s, "in_port(", 8)) { - const char *name; + if (mask) { + if (ovs_scan(s + len, "/%"SCNi32"%n", mask, &n)) { + len += n; + } else { + *mask = UINT32_MAX; + } + } + return len; + } else if (port_names) { const struct simap_node *node; - int name_len; + int len; - name = s + 8; - name_len = strcspn(name, ")"); - node = simap_find_len(port_names, name, name_len); + len = strcspn(s, ")"); + node = simap_find_len(port_names, s, len); if (node) { - nl_msg_put_u32(key, OVS_KEY_ATTR_IN_PORT, node->data); + *key = node->data; if (mask) { - nl_msg_put_u32(mask, OVS_KEY_ATTR_IN_PORT, UINT32_MAX); + *mask = UINT32_MAX; } - return 8 + name_len + 1; + return len; } } + return 0; +} - { - struct ovs_key_ethernet eth_key; - struct ovs_key_ethernet eth_key_mask; - int n = -1; +/* Helper for vlan parsing. */ +struct ovs_key_vlan__ { + ovs_be16 tci; +}; - if (mask && sscanf(s, - "eth(src="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"," - "dst="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT")%n", - ETH_ADDR_SCAN_ARGS(eth_key.eth_src), - ETH_ADDR_SCAN_ARGS(eth_key_mask.eth_src), - ETH_ADDR_SCAN_ARGS(eth_key.eth_dst), - ETH_ADDR_SCAN_ARGS(eth_key_mask.eth_dst), &n) > 0 && n > 0) { - - nl_msg_put_unspec(key, OVS_KEY_ATTR_ETHERNET, - ð_key, sizeof eth_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ETHERNET, - ð_key_mask, sizeof eth_key_mask); - return n; - } else if (sscanf(s, - "eth(src="ETH_ADDR_SCAN_FMT",dst="ETH_ADDR_SCAN_FMT")%n", - ETH_ADDR_SCAN_ARGS(eth_key.eth_src), - ETH_ADDR_SCAN_ARGS(eth_key.eth_dst), &n) > 0 && n > 0) { - nl_msg_put_unspec(key, OVS_KEY_ATTR_ETHERNET, - ð_key, sizeof eth_key); +static bool +set_be16_bf(ovs_be16 *bf, uint8_t bits, uint8_t offset, uint16_t value) +{ + const uint16_t mask = ((1U << bits) - 1) << offset; - if (mask) { - memset(ð_key, 0xff, sizeof eth_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ETHERNET, - ð_key, sizeof eth_key); - } - return n; - } + if (value >> bits) { + return false; } - { - uint16_t vid, vid_mask; - int pcp, pcp_mask; - int cfi, cfi_mask; - int n = -1; + *bf = htons((ntohs(*bf) & ~mask) | (value << offset)); + return true; +} - if (mask && (sscanf(s, "vlan(vid=%"SCNi16"/%"SCNi16",pcp=%i/%i)%n", - &vid, &vid_mask, &pcp, &pcp_mask, &n) > 0 && n > 0)) { - nl_msg_put_be16(key, OVS_KEY_ATTR_VLAN, - htons((vid << VLAN_VID_SHIFT) | - (pcp << VLAN_PCP_SHIFT) | - VLAN_CFI)); - nl_msg_put_be16(mask, OVS_KEY_ATTR_VLAN, - htons((vid_mask << VLAN_VID_SHIFT) | - (pcp_mask << VLAN_PCP_SHIFT) | - (1 << VLAN_CFI_SHIFT))); - return n; - } else if ((sscanf(s, "vlan(vid=%"SCNi16",pcp=%i)%n", - &vid, &pcp, &n) > 0 && n > 0)) { - nl_msg_put_be16(key, OVS_KEY_ATTR_VLAN, - htons((vid << VLAN_VID_SHIFT) | - (pcp << VLAN_PCP_SHIFT) | - VLAN_CFI)); - if (mask) { - nl_msg_put_be16(mask, OVS_KEY_ATTR_VLAN, OVS_BE16_MAX); - } - return n; - } else if (mask && (sscanf(s, "vlan(vid=%"SCNi16"/%"SCNi16",pcp=%i/%i,cfi=%i/%i)%n", - &vid, &vid_mask, &pcp, &pcp_mask, &cfi, &cfi_mask, &n) > 0 && n > 0)) { - nl_msg_put_be16(key, OVS_KEY_ATTR_VLAN, - htons((vid << VLAN_VID_SHIFT) | - (pcp << VLAN_PCP_SHIFT) | - (cfi ? VLAN_CFI : 0))); - nl_msg_put_be16(mask, OVS_KEY_ATTR_VLAN, - htons((vid_mask << VLAN_VID_SHIFT) | - (pcp_mask << VLAN_PCP_SHIFT) | - (cfi_mask << VLAN_CFI_SHIFT))); - return n; - } else if ((sscanf(s, "vlan(vid=%"SCNi16",pcp=%i,cfi=%i)%n", - &vid, &pcp, &cfi, &n) > 0 && n > 0)) { - nl_msg_put_be16(key, OVS_KEY_ATTR_VLAN, - htons((vid << VLAN_VID_SHIFT) | - (pcp << VLAN_PCP_SHIFT) | - (cfi ? VLAN_CFI : 0))); - if (mask) { - nl_msg_put_be16(mask, OVS_KEY_ATTR_VLAN, OVS_BE16_MAX); - } - return n; - } - } +static int +scan_be16_bf(const char *s, ovs_be16 *key, ovs_be16 *mask, uint8_t bits, + uint8_t offset) +{ + uint16_t key_, mask_; + int n; - { - int eth_type; - int eth_type_mask; - int n = -1; + if (ovs_scan(s, "%"SCNi16"%n", &key_, &n)) { + int len = n; - if (mask && sscanf(s, "eth_type(%i/%i)%n", - ð_type, ð_type_mask, &n) > 0 && n > 0) { - if (eth_type != 0) { - nl_msg_put_be16(key, OVS_KEY_ATTR_ETHERTYPE, htons(eth_type)); - } - nl_msg_put_be16(mask, OVS_KEY_ATTR_ETHERTYPE, htons(eth_type_mask)); - return n; - } else if (sscanf(s, "eth_type(%i)%n", ð_type, &n) > 0 && n > 0) { - nl_msg_put_be16(key, OVS_KEY_ATTR_ETHERTYPE, htons(eth_type)); + if (set_be16_bf(key, bits, offset, key_)) { if (mask) { - nl_msg_put_be16(mask, OVS_KEY_ATTR_ETHERTYPE, OVS_BE16_MAX); + if (ovs_scan(s + len, "/%"SCNi16"%n", &mask_, &n)) { + len += n; + + if (!set_be16_bf(mask, bits, offset, mask_)) { + return 0; + } + } else { + *mask |= htons(((1U << bits) - 1) << offset); + } } - return n; + return len; } } + return 0; +} - { - int label, tc, ttl, bos; - int label_mask, tc_mask, ttl_mask, bos_mask; - int n = -1; +static int +scan_vid(const char *s, ovs_be16 *key, ovs_be16 *mask) +{ + return scan_be16_bf(s, key, mask, 12, VLAN_VID_SHIFT); +} + +static int +scan_pcp(const char *s, ovs_be16 *key, ovs_be16 *mask) +{ + return scan_be16_bf(s, key, mask, 3, VLAN_PCP_SHIFT); +} - if (mask && sscanf(s, "mpls(label=%"SCNi32"/%"SCNi32",tc=%i/%i,ttl=%i/%i,bos=%i/%i)%n", - &label, &label_mask, &tc, &tc_mask, &ttl, &ttl_mask, &bos, &bos_mask, &n) > 0 && n > 0) { - struct ovs_key_mpls *mpls, *mpls_mask; +static int +scan_cfi(const char *s, ovs_be16 *key, ovs_be16 *mask) +{ + return scan_be16_bf(s, key, mask, 1, VLAN_CFI_SHIFT); +} - mpls = nl_msg_put_unspec_uninit(key, OVS_KEY_ATTR_MPLS, - sizeof *mpls); - mpls->mpls_lse = mpls_lse_from_components(label, tc, ttl, bos); +/* For MPLS. */ +static bool +set_be32_bf(ovs_be32 *bf, uint8_t bits, uint8_t offset, uint32_t value) +{ + const uint32_t mask = ((1U << bits) - 1) << offset; - mpls_mask = nl_msg_put_unspec_uninit(mask, OVS_KEY_ATTR_MPLS, - sizeof *mpls_mask); - mpls_mask->mpls_lse = mpls_lse_from_components( - label_mask, tc_mask, ttl_mask, bos_mask); - return n; - } else if (sscanf(s, "mpls(label=%"SCNi32",tc=%i,ttl=%i,bos=%i)%n", - &label, &tc, &ttl, &bos, &n) > 0 && - n > 0) { - struct ovs_key_mpls *mpls; - - mpls = nl_msg_put_unspec_uninit(key, OVS_KEY_ATTR_MPLS, - sizeof *mpls); - mpls->mpls_lse = mpls_lse_from_components(label, tc, ttl, bos); - if (mask) { - mpls = nl_msg_put_unspec_uninit(mask, OVS_KEY_ATTR_MPLS, - sizeof *mpls); - mpls->mpls_lse = OVS_BE32_MAX; - } - return n; - } + if (value >> bits) { + return false; } + *bf = htonl((ntohl(*bf) & ~mask) | (value << offset)); + return true; +} - { - ovs_be32 ipv4_src, ipv4_src_mask; - ovs_be32 ipv4_dst, ipv4_dst_mask; - int ipv4_proto, ipv4_proto_mask; - int ipv4_tos, ipv4_tos_mask; - int ipv4_ttl, ipv4_ttl_mask; - char frag[8]; - int ipv4_frag_mask; - enum ovs_frag_type ipv4_frag; - int n = -1; +static int +scan_be32_bf(const char *s, ovs_be32 *key, ovs_be32 *mask, uint8_t bits, + uint8_t offset) +{ + uint32_t key_, mask_; + int n; - if (mask && sscanf(s, "ipv4(src="IP_SCAN_FMT"/"IP_SCAN_FMT"," - "dst="IP_SCAN_FMT"/"IP_SCAN_FMT"," - "proto=%i/%i,tos=%i/%i,ttl=%i/%i," - "frag=%7[a-z]/%i)%n", - IP_SCAN_ARGS(&ipv4_src), IP_SCAN_ARGS(&ipv4_src_mask), - IP_SCAN_ARGS(&ipv4_dst), IP_SCAN_ARGS(&ipv4_dst_mask), - &ipv4_proto, &ipv4_proto_mask, - &ipv4_tos, &ipv4_tos_mask, &ipv4_ttl, &ipv4_ttl_mask, - frag, &ipv4_frag_mask, &n) > 0 - && n > 0 - && ovs_frag_type_from_string(frag, &ipv4_frag)) { - struct ovs_key_ipv4 ipv4_key; - struct ovs_key_ipv4 ipv4_mask; - - ipv4_key.ipv4_src = ipv4_src; - ipv4_key.ipv4_dst = ipv4_dst; - ipv4_key.ipv4_proto = ipv4_proto; - ipv4_key.ipv4_tos = ipv4_tos; - ipv4_key.ipv4_ttl = ipv4_ttl; - ipv4_key.ipv4_frag = ipv4_frag; - nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV4, - &ipv4_key, sizeof ipv4_key); - - ipv4_mask.ipv4_src = ipv4_src_mask; - ipv4_mask.ipv4_dst = ipv4_dst_mask; - ipv4_mask.ipv4_proto = ipv4_proto_mask; - ipv4_mask.ipv4_tos = ipv4_tos_mask; - ipv4_mask.ipv4_ttl = ipv4_ttl_mask; - ipv4_mask.ipv4_frag = ipv4_frag_mask; - nl_msg_put_unspec(mask, OVS_KEY_ATTR_IPV4, - &ipv4_mask, sizeof ipv4_mask); - return n; - } else if (sscanf(s, "ipv4(src="IP_SCAN_FMT",dst="IP_SCAN_FMT"," - "proto=%i,tos=%i,ttl=%i,frag=%7[a-z])%n", - IP_SCAN_ARGS(&ipv4_src), IP_SCAN_ARGS(&ipv4_dst), - &ipv4_proto, &ipv4_tos, &ipv4_ttl, frag, &n) > 0 - && n > 0 - && ovs_frag_type_from_string(frag, &ipv4_frag)) { - struct ovs_key_ipv4 ipv4_key; - - ipv4_key.ipv4_src = ipv4_src; - ipv4_key.ipv4_dst = ipv4_dst; - ipv4_key.ipv4_proto = ipv4_proto; - ipv4_key.ipv4_tos = ipv4_tos; - ipv4_key.ipv4_ttl = ipv4_ttl; - ipv4_key.ipv4_frag = ipv4_frag; - nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV4, - &ipv4_key, sizeof ipv4_key); + if (ovs_scan(s, "%"SCNi32"%n", &key_, &n)) { + int len = n; + if (set_be32_bf(key, bits, offset, key_)) { if (mask) { - memset(&ipv4_key, 0xff, sizeof ipv4_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_IPV4, - &ipv4_key, sizeof ipv4_key); + if (ovs_scan(s + len, "/%"SCNi32"%n", &mask_, &n)) { + len += n; + + if (!set_be32_bf(mask, bits, offset, mask_)) { + return 0; + } + } else { + *mask |= htonl(((1U << bits) - 1) << offset); + } } - return n; + return len; } } + return 0; +} - { - char ipv6_src_s[IPV6_SCAN_LEN + 1]; - char ipv6_src_mask_s[IPV6_SCAN_LEN + 1]; - char ipv6_dst_s[IPV6_SCAN_LEN + 1]; - char ipv6_dst_mask_s[IPV6_SCAN_LEN + 1]; - int ipv6_label, ipv6_label_mask; - int ipv6_proto, ipv6_proto_mask; - int ipv6_tclass, ipv6_tclass_mask; - int ipv6_hlimit, ipv6_hlimit_mask; - char frag[8]; - enum ovs_frag_type ipv6_frag; - int ipv6_frag_mask; - int n = -1; - - if (mask && sscanf(s, "ipv6(src="IPV6_SCAN_FMT"/"IPV6_SCAN_FMT",dst=" - IPV6_SCAN_FMT"/"IPV6_SCAN_FMT"," - "label=%i/%i,proto=%i/%i,tclass=%i/%i," - "hlimit=%i/%i,frag=%7[a-z]/%i)%n", - ipv6_src_s, ipv6_src_mask_s, ipv6_dst_s, ipv6_dst_mask_s, - &ipv6_label, &ipv6_label_mask, &ipv6_proto, - &ipv6_proto_mask, &ipv6_tclass, &ipv6_tclass_mask, - &ipv6_hlimit, &ipv6_hlimit_mask, frag, - &ipv6_frag_mask, &n) > 0 - && n > 0 - && ovs_frag_type_from_string(frag, &ipv6_frag)) { - struct ovs_key_ipv6 ipv6_key; - struct ovs_key_ipv6 ipv6_mask; - - if (inet_pton(AF_INET6, ipv6_src_s, &ipv6_key.ipv6_src) != 1 || - inet_pton(AF_INET6, ipv6_dst_s, &ipv6_key.ipv6_dst) != 1 || - inet_pton(AF_INET6, ipv6_src_mask_s, &ipv6_mask.ipv6_src) != 1 || - inet_pton(AF_INET6, ipv6_dst_mask_s, &ipv6_mask.ipv6_dst) != 1) { - return -EINVAL; - } +static int +scan_mpls_label(const char *s, ovs_be32 *key, ovs_be32 *mask) +{ + return scan_be32_bf(s, key, mask, 20, MPLS_LABEL_SHIFT); +} - ipv6_key.ipv6_label = htonl(ipv6_label); - ipv6_key.ipv6_proto = ipv6_proto; - ipv6_key.ipv6_tclass = ipv6_tclass; - ipv6_key.ipv6_hlimit = ipv6_hlimit; - ipv6_key.ipv6_frag = ipv6_frag; - nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV6, - &ipv6_key, sizeof ipv6_key); - - ipv6_mask.ipv6_label = htonl(ipv6_label_mask); - ipv6_mask.ipv6_proto = ipv6_proto_mask; - ipv6_mask.ipv6_tclass = ipv6_tclass_mask; - ipv6_mask.ipv6_hlimit = ipv6_hlimit_mask; - ipv6_mask.ipv6_frag = ipv6_frag_mask; - nl_msg_put_unspec(mask, OVS_KEY_ATTR_IPV6, - &ipv6_mask, sizeof ipv6_mask); - return n; - } else if (sscanf(s, "ipv6(src="IPV6_SCAN_FMT",dst="IPV6_SCAN_FMT"," - "label=%i,proto=%i,tclass=%i,hlimit=%i,frag=%7[a-z])%n", - ipv6_src_s, ipv6_dst_s, &ipv6_label, - &ipv6_proto, &ipv6_tclass, &ipv6_hlimit, frag, &n) > 0 - && n > 0 - && ovs_frag_type_from_string(frag, &ipv6_frag)) { - struct ovs_key_ipv6 ipv6_key; - - if (inet_pton(AF_INET6, ipv6_src_s, &ipv6_key.ipv6_src) != 1 || - inet_pton(AF_INET6, ipv6_dst_s, &ipv6_key.ipv6_dst) != 1) { - return -EINVAL; - } - ipv6_key.ipv6_label = htonl(ipv6_label); - ipv6_key.ipv6_proto = ipv6_proto; - ipv6_key.ipv6_tclass = ipv6_tclass; - ipv6_key.ipv6_hlimit = ipv6_hlimit; - ipv6_key.ipv6_frag = ipv6_frag; - nl_msg_put_unspec(key, OVS_KEY_ATTR_IPV6, - &ipv6_key, sizeof ipv6_key); +static int +scan_mpls_tc(const char *s, ovs_be32 *key, ovs_be32 *mask) +{ + return scan_be32_bf(s, key, mask, 3, MPLS_TC_SHIFT); +} - if (mask) { - memset(&ipv6_key, 0xff, sizeof ipv6_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_IPV6, - &ipv6_key, sizeof ipv6_key); - } - return n; - } - } +static int +scan_mpls_ttl(const char *s, ovs_be32 *key, ovs_be32 *mask) +{ + return scan_be32_bf(s, key, mask, 8, MPLS_TTL_SHIFT); +} - { - int tcp_src; - int tcp_dst; - int tcp_src_mask; - int tcp_dst_mask; - int n = -1; +static int +scan_mpls_bos(const char *s, ovs_be32 *key, ovs_be32 *mask) +{ + return scan_be32_bf(s, key, mask, 1, MPLS_BOS_SHIFT); +} - if (mask && sscanf(s, "tcp(src=%i/%i,dst=%i/%i)%n", - &tcp_src, &tcp_src_mask, &tcp_dst, &tcp_dst_mask, &n) > 0 - && n > 0) { - struct ovs_key_tcp tcp_key; - struct ovs_key_tcp tcp_mask; +static int +scan_vxlan_gbp(const char *s, uint32_t *key, uint32_t *mask) +{ + const char *s_base = s; + ovs_be16 id = 0, id_mask = 0; + uint8_t flags = 0, flags_mask = 0; - tcp_key.tcp_src = htons(tcp_src); - tcp_key.tcp_dst = htons(tcp_dst); - nl_msg_put_unspec(key, OVS_KEY_ATTR_TCP, &tcp_key, sizeof tcp_key); + if (!strncmp(s, "id=", 3)) { + s += 3; + s += scan_be16(s, &id, mask ? &id_mask : NULL); + } - tcp_mask.tcp_src = htons(tcp_src_mask); - tcp_mask.tcp_dst = htons(tcp_dst_mask); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_TCP, - &tcp_mask, sizeof tcp_mask); - return n; - } else if (sscanf(s, "tcp(src=%i,dst=%i)%n",&tcp_src, &tcp_dst, &n) > 0 - && n > 0) { - struct ovs_key_tcp tcp_key; + if (s[0] == ',') { + s++; + } + if (!strncmp(s, "flags=", 6)) { + s += 6; + s += scan_u8(s, &flags, mask ? &flags_mask : NULL); + } - tcp_key.tcp_src = htons(tcp_src); - tcp_key.tcp_dst = htons(tcp_dst); - nl_msg_put_unspec(key, OVS_KEY_ATTR_TCP, &tcp_key, sizeof tcp_key); + if (!strncmp(s, "))", 2)) { + s += 2; - if (mask) { - memset(&tcp_key, 0xff, sizeof tcp_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_TCP, - &tcp_key, sizeof tcp_key); - } - return n; + *key = (flags << 16) | ntohs(id); + if (mask) { + *mask = (flags_mask << 16) | ntohs(id_mask); } + + return s - s_base; } - { - int udp_src; - int udp_dst; - int udp_src_mask; - int udp_dst_mask; - int n = -1; + return 0; +} - if (mask && sscanf(s, "udp(src=%i/%i,dst=%i/%i)%n", - &udp_src, &udp_src_mask, - &udp_dst, &udp_dst_mask, &n) > 0 && n > 0) { - struct ovs_key_udp udp_key; - struct ovs_key_udp udp_mask; +static int +scan_geneve(const char *s, struct geneve_scan *key, struct geneve_scan *mask) +{ + const char *s_base = s; + struct geneve_opt *opt = key->d; + struct geneve_opt *opt_mask = mask ? mask->d : NULL; + int len_remain = sizeof key->d; - udp_key.udp_src = htons(udp_src); - udp_key.udp_dst = htons(udp_dst); - nl_msg_put_unspec(key, OVS_KEY_ATTR_UDP, &udp_key, sizeof udp_key); + while (s[0] == '{' && len_remain >= sizeof *opt) { + int data_len = 0; - udp_mask.udp_src = htons(udp_src_mask); - udp_mask.udp_dst = htons(udp_dst_mask); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_UDP, - &udp_mask, sizeof udp_mask); - return n; + s++; + len_remain -= sizeof *opt; + + if (!strncmp(s, "class=", 6)) { + s += 6; + s += scan_be16(s, &opt->opt_class, + mask ? &opt_mask->opt_class : NULL); + } else if (mask) { + memset(&opt_mask->opt_class, 0, sizeof opt_mask->opt_class); + } + + if (s[0] == ',') { + s++; + } + if (!strncmp(s, "type=", 5)) { + s += 5; + s += scan_u8(s, &opt->type, mask ? &opt_mask->type : NULL); + } else if (mask) { + memset(&opt_mask->type, 0, sizeof opt_mask->type); } - if (sscanf(s, "udp(src=%i,dst=%i)%n", &udp_src, &udp_dst, &n) > 0 - && n > 0) { - struct ovs_key_udp udp_key; - udp_key.udp_src = htons(udp_src); - udp_key.udp_dst = htons(udp_dst); - nl_msg_put_unspec(key, OVS_KEY_ATTR_UDP, &udp_key, sizeof udp_key); + if (s[0] == ',') { + s++; + } + if (!strncmp(s, "len=", 4)) { + uint8_t opt_len, opt_len_mask; + s += 4; + s += scan_u8(s, &opt_len, mask ? &opt_len_mask : NULL); + if (opt_len > 124 || opt_len % 4 || opt_len > len_remain) { + return 0; + } + opt->length = opt_len / 4; if (mask) { - memset(&udp_key, 0xff, sizeof udp_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_UDP, &udp_key, sizeof udp_key); + opt_mask->length = opt_len_mask; } - return n; + data_len = opt_len; + } else if (mask) { + memset(&opt_mask->type, 0, sizeof opt_mask->type); } - } - { - int sctp_src; - int sctp_dst; - int sctp_src_mask; - int sctp_dst_mask; - int n = -1; - - if (mask && sscanf(s, "sctp(src=%i/%i,dst=%i/%i)%n", - &sctp_src, &sctp_src_mask, - &sctp_dst, &sctp_dst_mask, &n) > 0 && n > 0) { - struct ovs_key_sctp sctp_key; - struct ovs_key_sctp sctp_mask; - - sctp_key.sctp_src = htons(sctp_src); - sctp_key.sctp_dst = htons(sctp_dst); - nl_msg_put_unspec(key, OVS_KEY_ATTR_SCTP, &sctp_key, sizeof sctp_key); - - sctp_mask.sctp_src = htons(sctp_src_mask); - sctp_mask.sctp_dst = htons(sctp_dst_mask); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_SCTP, - &sctp_mask, sizeof sctp_mask); - return n; + if (s[0] == ',') { + s++; + } + if (parse_int_string(s, (uint8_t *)(opt + 1), data_len, (char **)&s)) { + return 0; } - if (sscanf(s, "sctp(src=%i,dst=%i)%n", &sctp_src, &sctp_dst, &n) > 0 - && n > 0) { - struct ovs_key_sctp sctp_key; - sctp_key.sctp_src = htons(sctp_src); - sctp_key.sctp_dst = htons(sctp_dst); - nl_msg_put_unspec(key, OVS_KEY_ATTR_SCTP, &sctp_key, sizeof sctp_key); + if (mask) { + if (s[0] == '/') { + s++; + if (parse_int_string(s, (uint8_t *)(opt_mask + 1), + data_len, (char **)&s)) { + return 0; + } + } + opt_mask->r1 = 0; + opt_mask->r2 = 0; + opt_mask->r3 = 0; + } + if (s[0] == '}') { + s++; + opt += 1 + data_len / 4; if (mask) { - memset(&sctp_key, 0xff, sizeof sctp_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_SCTP, &sctp_key, sizeof sctp_key); + opt_mask += 1 + data_len / 4; } - return n; + len_remain -= data_len; } } - { - int icmp_type; - int icmp_code; - int icmp_type_mask; - int icmp_code_mask; - int n = -1; + if (s[0] == ')') { + int len = sizeof key->d - len_remain; - if (mask && sscanf(s, "icmp(type=%i/%i,code=%i/%i)%n", - &icmp_type, &icmp_type_mask, - &icmp_code, &icmp_code_mask, &n) > 0 && n > 0) { - struct ovs_key_icmp icmp_key; - struct ovs_key_icmp icmp_mask; - - icmp_key.icmp_type = icmp_type; - icmp_key.icmp_code = icmp_code; - nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMP, - &icmp_key, sizeof icmp_key); - - icmp_mask.icmp_type = icmp_type_mask; - icmp_mask.icmp_code = icmp_code_mask; - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ICMP, - &icmp_mask, sizeof icmp_mask); - return n; - } else if (sscanf(s, "icmp(type=%i,code=%i)%n", - &icmp_type, &icmp_code, &n) > 0 - && n > 0) { - struct ovs_key_icmp icmp_key; - - icmp_key.icmp_type = icmp_type; - icmp_key.icmp_code = icmp_code; - nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMP, - &icmp_key, sizeof icmp_key); - if (mask) { - memset(&icmp_key, 0xff, sizeof icmp_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ICMP, &icmp_key, - sizeof icmp_key); - } - return n; + s++; + key->len = len; + if (mask) { + mask->len = len; } + return s - s_base; } - { - struct ovs_key_icmpv6 icmpv6_key; - struct ovs_key_icmpv6 icmpv6_mask; - int icmpv6_type_mask; - int icmpv6_code_mask; - int n = -1; + return 0; +} - if (mask && sscanf(s, "icmpv6(type=%"SCNi8"/%i,code=%"SCNi8"/%i)%n", - &icmpv6_key.icmpv6_type, &icmpv6_type_mask, - &icmpv6_key.icmpv6_code, &icmpv6_code_mask, &n) > 0 - && n > 0) { - nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMPV6, - &icmpv6_key, sizeof icmpv6_key); - - icmpv6_mask.icmpv6_type = icmpv6_type_mask; - icmpv6_mask.icmpv6_code = icmpv6_code_mask; - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ICMPV6, &icmpv6_mask, - sizeof icmpv6_mask); - return n; - } else if (sscanf(s, "icmpv6(type=%"SCNi8",code=%"SCNi8")%n", - &icmpv6_key.icmpv6_type, &icmpv6_key.icmpv6_code,&n) > 0 - && n > 0) { - nl_msg_put_unspec(key, OVS_KEY_ATTR_ICMPV6, - &icmpv6_key, sizeof icmpv6_key); +static void +tun_flags_to_attr(struct ofpbuf *a, const void *data_) +{ + const uint16_t *flags = data_; - if (mask) { - memset(&icmpv6_key, 0xff, sizeof icmpv6_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ICMPV6, &icmpv6_key, - sizeof icmpv6_key); - } - return n; - } + if (*flags & FLOW_TNL_F_DONT_FRAGMENT) { + nl_msg_put_flag(a, OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT); + } + if (*flags & FLOW_TNL_F_CSUM) { + nl_msg_put_flag(a, OVS_TUNNEL_KEY_ATTR_CSUM); + } + if (*flags & FLOW_TNL_F_OAM) { + nl_msg_put_flag(a, OVS_TUNNEL_KEY_ATTR_OAM); } +} - { - ovs_be32 arp_sip, arp_sip_mask; - ovs_be32 arp_tip, arp_tip_mask; - int arp_op, arp_op_mask; - uint8_t arp_sha[ETH_ADDR_LEN]; - uint8_t arp_sha_mask[ETH_ADDR_LEN]; - uint8_t arp_tha[ETH_ADDR_LEN]; - uint8_t arp_tha_mask[ETH_ADDR_LEN]; - int n = -1; +static void +vxlan_gbp_to_attr(struct ofpbuf *a, const void *data_) +{ + const uint32_t *gbp = data_; - if (mask && sscanf(s, "arp(sip="IP_SCAN_FMT"/"IP_SCAN_FMT"," - "tip="IP_SCAN_FMT"/"IP_SCAN_FMT"," - "op=%i/%i,sha="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"," - "tha="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT")%n", - IP_SCAN_ARGS(&arp_sip), IP_SCAN_ARGS(&arp_sip_mask), - IP_SCAN_ARGS(&arp_tip), IP_SCAN_ARGS(&arp_tip_mask), - &arp_op, &arp_op_mask, - ETH_ADDR_SCAN_ARGS(arp_sha), - ETH_ADDR_SCAN_ARGS(arp_sha_mask), - ETH_ADDR_SCAN_ARGS(arp_tha), - ETH_ADDR_SCAN_ARGS(arp_tha_mask), &n) > 0 && n > 0) { - struct ovs_key_arp arp_key; - struct ovs_key_arp arp_mask; - - memset(&arp_key, 0, sizeof arp_key); - arp_key.arp_sip = arp_sip; - arp_key.arp_tip = arp_tip; - arp_key.arp_op = htons(arp_op); - memcpy(arp_key.arp_sha, arp_sha, ETH_ADDR_LEN); - memcpy(arp_key.arp_tha, arp_tha, ETH_ADDR_LEN); - nl_msg_put_unspec(key, OVS_KEY_ATTR_ARP, &arp_key, sizeof arp_key); - - arp_mask.arp_sip = arp_sip_mask; - arp_mask.arp_tip = arp_tip_mask; - arp_mask.arp_op = htons(arp_op_mask); - memcpy(arp_mask.arp_sha, arp_sha_mask, ETH_ADDR_LEN); - memcpy(arp_mask.arp_tha, arp_tha_mask, ETH_ADDR_LEN); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ARP, - &arp_mask, sizeof arp_mask); - return n; - } else if (sscanf(s, "arp(sip="IP_SCAN_FMT",tip="IP_SCAN_FMT"," - "op=%i,sha="ETH_ADDR_SCAN_FMT",tha="ETH_ADDR_SCAN_FMT")%n", - IP_SCAN_ARGS(&arp_sip), - IP_SCAN_ARGS(&arp_tip), - &arp_op, - ETH_ADDR_SCAN_ARGS(arp_sha), - ETH_ADDR_SCAN_ARGS(arp_tha), &n) > 0 && n > 0) { - struct ovs_key_arp arp_key; - - memset(&arp_key, 0, sizeof arp_key); - arp_key.arp_sip = arp_sip; - arp_key.arp_tip = arp_tip; - arp_key.arp_op = htons(arp_op); - memcpy(arp_key.arp_sha, arp_sha, ETH_ADDR_LEN); - memcpy(arp_key.arp_tha, arp_tha, ETH_ADDR_LEN); - nl_msg_put_unspec(key, OVS_KEY_ATTR_ARP, &arp_key, sizeof arp_key); + if (*gbp) { + size_t vxlan_opts_ofs; - if (mask) { - memset(&arp_key, 0xff, sizeof arp_key); - nl_msg_put_unspec(mask, OVS_KEY_ATTR_ARP, - &arp_key, sizeof arp_key); - } - return n; - } + vxlan_opts_ofs = nl_msg_start_nested(a, OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS); + nl_msg_put_u32(a, OVS_VXLAN_EXT_GBP, *gbp); + nl_msg_end_nested(a, vxlan_opts_ofs); } +} - { - char nd_target_s[IPV6_SCAN_LEN + 1]; - char nd_target_mask_s[IPV6_SCAN_LEN + 1]; - uint8_t nd_sll[ETH_ADDR_LEN]; - uint8_t nd_sll_mask[ETH_ADDR_LEN]; - uint8_t nd_tll[ETH_ADDR_LEN]; - uint8_t nd_tll_mask[ETH_ADDR_LEN]; - int n = -1; +static void +geneve_to_attr(struct ofpbuf *a, const void *data_) +{ + const struct geneve_scan *geneve = data_; - nd_target_mask_s[0] = 0; - memset(nd_sll_mask, 0xff, sizeof nd_sll_mask); - memset(nd_tll_mask, 0xff, sizeof nd_tll_mask); - - if (mask && sscanf(s, "nd(target="IPV6_SCAN_FMT"/"IPV6_SCAN_FMT")%n", - nd_target_s, nd_target_mask_s, &n) > 0 && n > 0) { - put_nd_key(n, nd_target_s, NULL, NULL, key); - put_nd_mask(n, nd_target_mask_s, NULL, NULL, mask); - } else if (sscanf(s, "nd(target="IPV6_SCAN_FMT")%n", - nd_target_s, &n) > 0 && n > 0) { - put_nd_key(n, nd_target_s, NULL, NULL, key); - if (mask) { - put_nd_mask(n, nd_target_mask_s, NULL, NULL, mask); - } - } else if (mask && sscanf(s, "nd(target="IPV6_SCAN_FMT"/"IPV6_SCAN_FMT - ",sll="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT")%n", - nd_target_s, nd_target_mask_s, - ETH_ADDR_SCAN_ARGS(nd_sll), - ETH_ADDR_SCAN_ARGS(nd_sll_mask), &n) > 0 && n > 0) { - put_nd_key(n, nd_target_s, nd_sll, NULL, key); - put_nd_mask(n, nd_target_mask_s, nd_sll_mask, NULL, mask); - } else if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT")%n", - nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll), &n) > 0 - && n > 0) { - put_nd_key(n, nd_target_s, nd_sll, NULL, key); - if (mask) { - put_nd_mask(n, nd_target_mask_s, nd_sll_mask, NULL, mask); - } - } else if (mask && sscanf(s, "nd(target="IPV6_SCAN_FMT"/"IPV6_SCAN_FMT - ",tll="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT")%n", - nd_target_s, nd_target_mask_s, - ETH_ADDR_SCAN_ARGS(nd_tll), - ETH_ADDR_SCAN_ARGS(nd_tll_mask), &n) > 0 && n > 0) { - put_nd_key(n, nd_target_s, NULL, nd_tll, key); - put_nd_mask(n, nd_target_mask_s, NULL, nd_tll_mask, mask); - } else if (sscanf(s, "nd(target="IPV6_SCAN_FMT",tll="ETH_ADDR_SCAN_FMT")%n", - nd_target_s, ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0 - && n > 0) { - put_nd_key(n, nd_target_s, NULL, nd_tll, key); - if (mask) { - put_nd_mask(n, nd_target_mask_s, NULL, nd_tll_mask, mask); - } - } else if (mask && sscanf(s, "nd(target="IPV6_SCAN_FMT"/"IPV6_SCAN_FMT - ",sll="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"," - "tll="ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT")%n", - nd_target_s, nd_target_mask_s, - ETH_ADDR_SCAN_ARGS(nd_sll), ETH_ADDR_SCAN_ARGS(nd_sll_mask), - ETH_ADDR_SCAN_ARGS(nd_tll), ETH_ADDR_SCAN_ARGS(nd_tll_mask), - &n) > 0 - && n > 0) { - put_nd_key(n, nd_target_s, nd_sll, nd_tll, key); - put_nd_mask(n, nd_target_mask_s, nd_sll_mask, nd_tll_mask, mask); - } else if (sscanf(s, "nd(target="IPV6_SCAN_FMT",sll="ETH_ADDR_SCAN_FMT"," - "tll="ETH_ADDR_SCAN_FMT")%n", - nd_target_s, ETH_ADDR_SCAN_ARGS(nd_sll), - ETH_ADDR_SCAN_ARGS(nd_tll), &n) > 0 - && n > 0) { - put_nd_key(n, nd_target_s, nd_sll, nd_tll, key); - if (mask) { - put_nd_mask(n, nd_target_mask_s, - nd_sll_mask, nd_tll_mask, mask); - } + nl_msg_put_unspec(a, OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS, geneve->d, + geneve->len); +} + +#define SCAN_PUT_ATTR(BUF, ATTR, DATA, FUNC) \ + { \ + unsigned long call_fn = (unsigned long)FUNC; \ + if (call_fn) { \ + typedef void (*fn)(struct ofpbuf *, const void *); \ + fn func = FUNC; \ + func(BUF, &(DATA)); \ + } else { \ + nl_msg_put_unspec(BUF, ATTR, &(DATA), sizeof (DATA)); \ + } \ + } + +#define SCAN_IF(NAME) \ + if (strncmp(s, NAME, strlen(NAME)) == 0) { \ + const char *start = s; \ + int len; \ + \ + s += strlen(NAME) + +/* Usually no special initialization is needed. */ +#define SCAN_BEGIN(NAME, TYPE) \ + SCAN_IF(NAME); \ + TYPE skey, smask; \ + memset(&skey, 0, sizeof skey); \ + memset(&smask, 0, sizeof smask); \ + do { \ + len = 0; + +/* Init as fully-masked as mask will not be scanned. */ +#define SCAN_BEGIN_FULLY_MASKED(NAME, TYPE) \ + SCAN_IF(NAME); \ + TYPE skey, smask; \ + memset(&skey, 0, sizeof skey); \ + memset(&smask, 0xff, sizeof smask); \ + do { \ + len = 0; + +/* VLAN needs special initialization. */ +#define SCAN_BEGIN_INIT(NAME, TYPE, KEY_INIT, MASK_INIT) \ + SCAN_IF(NAME); \ + TYPE skey = KEY_INIT; \ + TYPE smask = MASK_INIT; \ + do { \ + len = 0; + +/* Scan unnamed entry as 'TYPE' */ +#define SCAN_TYPE(TYPE, KEY, MASK) \ + len = scan_##TYPE(s, KEY, MASK); \ + if (len == 0) { \ + return -EINVAL; \ + } \ + s += len + +/* Scan named ('NAME') entry 'FIELD' as 'TYPE'. */ +#define SCAN_FIELD(NAME, TYPE, FIELD) \ + if (strncmp(s, NAME, strlen(NAME)) == 0) { \ + s += strlen(NAME); \ + SCAN_TYPE(TYPE, &skey.FIELD, mask ? &smask.FIELD : NULL); \ + continue; \ + } + +#define SCAN_FINISH() \ + } while (*s++ == ',' && len != 0); \ + if (s[-1] != ')') { \ + return -EINVAL; \ } - if (n != -1) - return n; +#define SCAN_FINISH_SINGLE() \ + } while (false); \ + if (*s++ != ')') { \ + return -EINVAL; \ + } + +/* Beginning of nested attribute. */ +#define SCAN_BEGIN_NESTED(NAME, ATTR) \ + SCAN_IF(NAME); \ + size_t key_offset, mask_offset; \ + key_offset = nl_msg_start_nested(key, ATTR); \ + if (mask) { \ + mask_offset = nl_msg_start_nested(mask, ATTR); \ + } \ + do { \ + len = 0; + +#define SCAN_END_NESTED() \ + SCAN_FINISH(); \ + nl_msg_end_nested(key, key_offset); \ + if (mask) { \ + nl_msg_end_nested(mask, mask_offset); \ + } \ + return s - start; \ + } + +#define SCAN_FIELD_NESTED__(NAME, TYPE, SCAN_AS, ATTR, FUNC) \ + if (strncmp(s, NAME, strlen(NAME)) == 0) { \ + TYPE skey, smask; \ + memset(&skey, 0, sizeof skey); \ + memset(&smask, 0xff, sizeof smask); \ + s += strlen(NAME); \ + SCAN_TYPE(SCAN_AS, &skey, &smask); \ + SCAN_PUT(ATTR, FUNC); \ + continue; \ + } + +#define SCAN_FIELD_NESTED(NAME, TYPE, SCAN_AS, ATTR) \ + SCAN_FIELD_NESTED__(NAME, TYPE, SCAN_AS, ATTR, NULL) + +#define SCAN_FIELD_NESTED_FUNC(NAME, TYPE, SCAN_AS, FUNC) \ + 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); \ + } \ + } + +#define SCAN_END(ATTR) \ + SCAN_FINISH(); \ + SCAN_PUT(ATTR, NULL); \ + return s - start; \ + } +#define SCAN_END_SINGLE(ATTR) \ + SCAN_FINISH_SINGLE(); \ + SCAN_PUT(ATTR, NULL); \ + return s - start; \ } +#define SCAN_SINGLE(NAME, TYPE, SCAN_AS, ATTR) \ + SCAN_BEGIN(NAME, TYPE) { \ + SCAN_TYPE(SCAN_AS, &skey, &smask); \ + } SCAN_END_SINGLE(ATTR) + +#define SCAN_SINGLE_FULLY_MASKED(NAME, TYPE, SCAN_AS, ATTR) \ + SCAN_BEGIN_FULLY_MASKED(NAME, TYPE) { \ + SCAN_TYPE(SCAN_AS, &skey, NULL); \ + } SCAN_END_SINGLE(ATTR) + +/* scan_port needs one extra argument. */ +#define SCAN_SINGLE_PORT(NAME, TYPE, ATTR) \ + SCAN_BEGIN(NAME, TYPE) { \ + len = scan_port(s, &skey, &smask, port_names); \ + if (len == 0) { \ + return -EINVAL; \ + } \ + s += len; \ + } SCAN_END_SINGLE(ATTR) + +static int +parse_odp_key_mask_attr(const char *s, const struct simap *port_names, + struct ofpbuf *key, struct ofpbuf *mask) +{ + ovs_u128 ufid; + int len; + + /* Skip UFID. */ + len = odp_ufid_from_string(s, &ufid); + if (len) { + return len; + } + + SCAN_SINGLE("skb_priority(", uint32_t, u32, OVS_KEY_ATTR_PRIORITY); + SCAN_SINGLE("skb_mark(", uint32_t, u32, OVS_KEY_ATTR_SKB_MARK); + SCAN_SINGLE_FULLY_MASKED("recirc_id(", uint32_t, u32, + 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_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("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_FIELD_NESTED("tp_dst=", ovs_be16, be16, OVS_TUNNEL_KEY_ATTR_TP_DST); + SCAN_FIELD_NESTED_FUNC("vxlan(gbp(", uint32_t, vxlan_gbp, vxlan_gbp_to_attr); + SCAN_FIELD_NESTED_FUNC("geneve(", struct geneve_scan, geneve, + geneve_to_attr); + SCAN_FIELD_NESTED_FUNC("flags(", uint16_t, tun_flags, tun_flags_to_attr); + } SCAN_END_NESTED(); + + SCAN_SINGLE_PORT("in_port(", uint32_t, OVS_KEY_ATTR_IN_PORT); + + SCAN_BEGIN("eth(", struct ovs_key_ethernet) { + SCAN_FIELD("src=", eth, eth_src); + SCAN_FIELD("dst=", eth, eth_dst); + } SCAN_END(OVS_KEY_ATTR_ETHERNET); + + SCAN_BEGIN_INIT("vlan(", struct ovs_key_vlan__, + { htons(VLAN_CFI) }, { htons(VLAN_CFI) }) { + SCAN_FIELD("vid=", vid, tci); + SCAN_FIELD("pcp=", pcp, tci); + SCAN_FIELD("cfi=", cfi, tci); + } SCAN_END(OVS_KEY_ATTR_VLAN); + + 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("ipv4(", struct ovs_key_ipv4) { + SCAN_FIELD("src=", ipv4, ipv4_src); + SCAN_FIELD("dst=", ipv4, ipv4_dst); + SCAN_FIELD("proto=", u8, ipv4_proto); + SCAN_FIELD("tos=", u8, ipv4_tos); + SCAN_FIELD("ttl=", u8, ipv4_ttl); + SCAN_FIELD("frag=", frag, ipv4_frag); + } 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("label=", ipv6_label, ipv6_label); + SCAN_FIELD("proto=", u8, ipv6_proto); + SCAN_FIELD("tclass=", u8, ipv6_tclass); + SCAN_FIELD("hlimit=", u8, ipv6_hlimit); + SCAN_FIELD("frag=", frag, ipv6_frag); + } SCAN_END(OVS_KEY_ATTR_IPV6); + + SCAN_BEGIN("tcp(", struct ovs_key_tcp) { + SCAN_FIELD("src=", be16, tcp_src); + SCAN_FIELD("dst=", be16, tcp_dst); + } SCAN_END(OVS_KEY_ATTR_TCP); + + SCAN_SINGLE("tcp_flags(", ovs_be16, tcp_flags, OVS_KEY_ATTR_TCP_FLAGS); + + SCAN_BEGIN("udp(", struct ovs_key_udp) { + SCAN_FIELD("src=", be16, udp_src); + SCAN_FIELD("dst=", be16, udp_dst); + } SCAN_END(OVS_KEY_ATTR_UDP); + + SCAN_BEGIN("sctp(", struct ovs_key_sctp) { + SCAN_FIELD("src=", be16, sctp_src); + SCAN_FIELD("dst=", be16, sctp_dst); + } SCAN_END(OVS_KEY_ATTR_SCTP); + + SCAN_BEGIN("icmp(", struct ovs_key_icmp) { + SCAN_FIELD("type=", u8, icmp_type); + SCAN_FIELD("code=", u8, icmp_code); + } SCAN_END(OVS_KEY_ATTR_ICMP); + + SCAN_BEGIN("icmpv6(", struct ovs_key_icmpv6) { + SCAN_FIELD("type=", u8, icmpv6_type); + SCAN_FIELD("code=", u8, icmpv6_code); + } SCAN_END(OVS_KEY_ATTR_ICMPV6); + + SCAN_BEGIN("arp(", struct ovs_key_arp) { + SCAN_FIELD("sip=", ipv4, arp_sip); + SCAN_FIELD("tip=", ipv4, arp_tip); + SCAN_FIELD("op=", be16, arp_op); + SCAN_FIELD("sha=", eth, arp_sha); + SCAN_FIELD("tha=", eth, arp_tha); + } SCAN_END(OVS_KEY_ATTR_ARP); + + SCAN_BEGIN("nd(", struct ovs_key_nd) { + SCAN_FIELD("target=", ipv6, nd_target); + SCAN_FIELD("sll=", eth, nd_sll); + SCAN_FIELD("tll=", eth, nd_tll); + } SCAN_END(OVS_KEY_ATTR_ND); + + /* Encap open-coded. */ if (!strncmp(s, "encap(", 6)) { const char *start = s; size_t encap, encap_mask = 0; @@ -2357,7 +3500,7 @@ parse_odp_key_mask_attr(const char *s, const struct simap *port_names, for (;;) { int retval; - s += strspn(s, ", \t\r\n"); + s += strspn(s, delimiters); if (!*s) { return -EINVAL; } else if (*s == ')') { @@ -2422,57 +3565,88 @@ odp_flow_from_string(const char *s, const struct simap *port_names, } static uint8_t -ovs_to_odp_frag(uint8_t nw_frag) -{ - return (nw_frag == 0 ? OVS_FRAG_TYPE_NONE - : nw_frag == FLOW_NW_FRAG_ANY ? OVS_FRAG_TYPE_FIRST - : OVS_FRAG_TYPE_LATER); -} - -static uint8_t -ovs_to_odp_frag_mask(uint8_t nw_frag_mask) +ovs_to_odp_frag(uint8_t nw_frag, bool is_mask) { - uint8_t frag_mask = ~(OVS_FRAG_TYPE_FIRST | OVS_FRAG_TYPE_LATER); - - frag_mask |= (nw_frag_mask & FLOW_NW_FRAG_ANY) ? OVS_FRAG_TYPE_FIRST : 0; - frag_mask |= (nw_frag_mask & FLOW_NW_FRAG_LATER) ? OVS_FRAG_TYPE_LATER : 0; - - return frag_mask; + if (is_mask) { + /* Netlink interface 'enum ovs_frag_type' is an 8-bit enumeration type, + * not a set of flags or bitfields. Hence, if the struct flow nw_frag + * mask, which is a set of bits, has the FLOW_NW_FRAG_ANY as zero, we + * must use a zero mask for the netlink frag field, and all ones mask + * otherwise. */ + return (nw_frag & FLOW_NW_FRAG_ANY) ? UINT8_MAX : 0; + } + return !(nw_frag & FLOW_NW_FRAG_ANY) ? OVS_FRAG_TYPE_NONE + : nw_frag & FLOW_NW_FRAG_LATER ? OVS_FRAG_TYPE_LATER + : OVS_FRAG_TYPE_FIRST; } +static void get_ethernet_key(const struct flow *, struct ovs_key_ethernet *); +static void put_ethernet_key(const struct ovs_key_ethernet *, struct flow *); +static void get_ipv4_key(const struct flow *, struct ovs_key_ipv4 *, + bool is_mask); +static void put_ipv4_key(const struct ovs_key_ipv4 *, struct flow *, + bool is_mask); +static void get_ipv6_key(const struct flow *, struct ovs_key_ipv6 *, + bool is_mask); +static void put_ipv6_key(const struct ovs_key_ipv6 *, struct flow *, + bool is_mask); +static void get_arp_key(const struct flow *, struct ovs_key_arp *); +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 *); + +/* These share the same layout. */ +union ovs_key_tp { + struct ovs_key_tcp tcp; + struct ovs_key_udp udp; + struct ovs_key_sctp sctp; +}; + +static void get_tp_key(const struct flow *, 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 *data, - const struct flow *flow, odp_port_t odp_in_port) +odp_flow_key_from_flow__(const struct odp_flow_key_parms *parms, + bool export_mask, struct ofpbuf *buf) { - bool is_mask; struct ovs_key_ethernet *eth_key; size_t encap; - - /* We assume that if 'data' and 'flow' are not the same, we should - * treat 'data' as a mask. */ - is_mask = (data != flow); + const struct flow *flow = parms->flow; + const struct flow *data = export_mask ? parms->mask : parms->flow; nl_msg_put_u32(buf, OVS_KEY_ATTR_PRIORITY, data->skb_priority); - if (flow->tunnel.ip_dst || is_mask) { - tun_key_to_attr(buf, &data->tunnel); + if (flow->tunnel.ip_dst || 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 (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.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' * is not the magical value "ODPP_NONE". */ - if (is_mask || odp_in_port != ODPP_NONE) { - nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, odp_in_port); + if (export_mask || parms->odp_in_port != ODPP_NONE) { + nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, parms->odp_in_port); } eth_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ETHERNET, sizeof *eth_key); - memcpy(eth_key->eth_src, data->dl_src, ETH_ADDR_LEN); - memcpy(eth_key->eth_dst, data->dl_dst, ETH_ADDR_LEN); + get_ethernet_key(data, eth_key); if (flow->vlan_tci != htons(0) || flow->dl_type == htons(ETH_TYPE_VLAN)) { - if (is_mask) { + if (export_mask) { nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, OVS_BE16_MAX); } else { nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, htons(ETH_TYPE_VLAN)); @@ -2498,7 +3672,7 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, * 0xffff Any non-Ethernet II frame (except valid * 802.3 SNAP packet with valid eth_type). */ - if (is_mask) { + if (export_mask) { nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, OVS_BE16_MAX); } goto unencap; @@ -2511,68 +3685,57 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, ipv4_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV4, sizeof *ipv4_key); - ipv4_key->ipv4_src = data->nw_src; - ipv4_key->ipv4_dst = data->nw_dst; - ipv4_key->ipv4_proto = data->nw_proto; - ipv4_key->ipv4_tos = data->nw_tos; - ipv4_key->ipv4_ttl = data->nw_ttl; - ipv4_key->ipv4_frag = is_mask ? ovs_to_odp_frag_mask(data->nw_frag) - : ovs_to_odp_frag(data->nw_frag); + get_ipv4_key(data, ipv4_key, export_mask); } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) { struct ovs_key_ipv6 *ipv6_key; ipv6_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_IPV6, sizeof *ipv6_key); - memcpy(ipv6_key->ipv6_src, &data->ipv6_src, sizeof ipv6_key->ipv6_src); - memcpy(ipv6_key->ipv6_dst, &data->ipv6_dst, sizeof ipv6_key->ipv6_dst); - ipv6_key->ipv6_label = data->ipv6_label; - ipv6_key->ipv6_proto = data->nw_proto; - ipv6_key->ipv6_tclass = data->nw_tos; - ipv6_key->ipv6_hlimit = data->nw_ttl; - ipv6_key->ipv6_frag = is_mask ? ovs_to_odp_frag_mask(data->nw_frag) - : ovs_to_odp_frag(data->nw_frag); + get_ipv6_key(data, ipv6_key, export_mask); } else if (flow->dl_type == htons(ETH_TYPE_ARP) || flow->dl_type == htons(ETH_TYPE_RARP)) { struct ovs_key_arp *arp_key; arp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_ARP, sizeof *arp_key); - memset(arp_key, 0, sizeof *arp_key); - arp_key->arp_sip = data->nw_src; - arp_key->arp_tip = data->nw_dst; - arp_key->arp_op = htons(data->nw_proto); - memcpy(arp_key->arp_sha, data->arp_sha, ETH_ADDR_LEN); - memcpy(arp_key->arp_tha, data->arp_tha, ETH_ADDR_LEN); + get_arp_key(data, arp_key); } else if (eth_type_mpls(flow->dl_type)) { struct ovs_key_mpls *mpls_key; + int i, n; + n = flow_count_mpls_labels(flow, NULL); + if (export_mask) { + n = MIN(n, parms->support.max_mpls_depth); + } mpls_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_MPLS, - sizeof *mpls_key); - mpls_key->mpls_lse = data->mpls_lse; + n * sizeof *mpls_key); + for (i = 0; i < n; i++) { + mpls_key[i].mpls_lse = data->mpls_lse[i]; + } } if (is_ip_any(flow) && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) { if (flow->nw_proto == IPPROTO_TCP) { - struct ovs_key_tcp *tcp_key; + union ovs_key_tp *tcp_key; tcp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_TCP, sizeof *tcp_key); - tcp_key->tcp_src = data->tp_src; - tcp_key->tcp_dst = data->tp_dst; + get_tp_key(data, tcp_key); + if (data->tcp_flags) { + nl_msg_put_be16(buf, OVS_KEY_ATTR_TCP_FLAGS, data->tcp_flags); + } } else if (flow->nw_proto == IPPROTO_UDP) { - struct ovs_key_udp *udp_key; + union ovs_key_tp *udp_key; udp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_UDP, sizeof *udp_key); - udp_key->udp_src = data->tp_src; - udp_key->udp_dst = data->tp_dst; + get_tp_key(data, udp_key); } else if (flow->nw_proto == IPPROTO_SCTP) { - struct ovs_key_sctp *sctp_key; + union ovs_key_tp *sctp_key; sctp_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_SCTP, sizeof *sctp_key); - sctp_key->sctp_src = data->tp_src; - sctp_key->sctp_dst = data->tp_dst; + get_tp_key(data, sctp_key); } else if (flow->dl_type == htons(ETH_TYPE_IP) && flow->nw_proto == IPPROTO_ICMP) { struct ovs_key_icmp *icmp_key; @@ -2590,11 +3753,11 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, 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)) && - (!is_mask || (data->tp_src == htons(0xffff) && - data->tp_dst == htons(0xffff)))) { + 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)))) { struct ovs_key_nd *nd_key; @@ -2602,8 +3765,8 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, 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_sll = data->arp_sha; + nd_key->nd_tll = data->arp_tha; } } } @@ -2615,33 +3778,126 @@ unencap: } /* 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. */ void -odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow, - odp_port_t odp_in_port) +odp_flow_key_from_flow(const struct odp_flow_key_parms *parms, + struct ofpbuf *buf) { - odp_flow_key_from_flow__(buf, flow, flow, odp_in_port); + 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. */ void -odp_flow_key_from_mask(struct ofpbuf *buf, const struct flow *mask, - const struct flow *flow, uint32_t odp_in_port_mask) +odp_flow_key_from_mask(const struct odp_flow_key_parms *parms, + struct ofpbuf *buf) +{ + 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_flow_key_from_flow__(buf, mask, flow, u32_to_odp(odp_in_port_mask)); + nl_msg_put_u32(buf, OVS_KEY_ATTR_PRIORITY, md->skb_priority); + + if (md->tunnel.ip_dst) { + 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); + } + } + + /* 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); + } +} + +/* 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) +{ + const struct nlattr *nla; + size_t left; + uint32_t wanted_attrs = 1u << OVS_KEY_ATTR_PRIORITY | + 1u << OVS_KEY_ATTR_SKB_MARK | 1u << OVS_KEY_ATTR_TUNNEL | + 1u << OVS_KEY_ATTR_IN_PORT; + + pkt_metadata_init(md, ODPP_NONE); + + NL_ATTR_FOR_EACH (nla, left, key, key_len) { + uint16_t type = nl_attr_type(nla); + 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); + + if (len != expected_len && expected_len >= 0) { + continue; + } + + switch (type) { + case OVS_KEY_ATTR_RECIRC_ID: + md->recirc_id = nl_attr_get_u32(nla); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_RECIRC_ID); + break; + case OVS_KEY_ATTR_DP_HASH: + md->dp_hash = nl_attr_get_u32(nla); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_DP_HASH); + break; + case OVS_KEY_ATTR_PRIORITY: + md->skb_priority = nl_attr_get_u32(nla); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_PRIORITY); + break; + case OVS_KEY_ATTR_SKB_MARK: + md->pkt_mark = nl_attr_get_u32(nla); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_SKB_MARK); + break; + case OVS_KEY_ATTR_CT_STATE: + md->ct_state = odp_to_ovs_ct_state(nl_attr_get_u32(nla)); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_STATE); + break; + case OVS_KEY_ATTR_CT_ZONE: + md->ct_zone = nl_attr_get_u16(nla); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_CT_ZONE); + break; + case OVS_KEY_ATTR_TUNNEL: { + enum odp_key_fitness res; + + res = odp_tun_key_from_attr(nla, true, &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; + default: + break; + } + + if (!wanted_attrs) { + return; /* Have everything. */ + } + } } uint32_t @@ -2684,23 +3940,23 @@ log_odp_key_attributes(struct vlog_rate_limit *rl, const char *title, ds_destroy(&s); } -static bool -odp_to_ovs_frag(uint8_t odp_frag, struct flow *flow) +static uint8_t +odp_to_ovs_frag(uint8_t odp_frag, bool is_mask) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + if (is_mask) { + return odp_frag ? FLOW_NW_FRAG_MASK : 0; + } + if (odp_frag > OVS_FRAG_TYPE_LATER) { VLOG_ERR_RL(&rl, "invalid frag %"PRIu8" in flow key", odp_frag); - return false; + return 0xff; /* Error. */ } - if (odp_frag != OVS_FRAG_TYPE_NONE) { - flow->nw_frag |= FLOW_NW_FRAG_ANY; - if (odp_frag == OVS_FRAG_TYPE_LATER) { - flow->nw_frag |= FLOW_NW_FRAG_LATER; - } - } - return true; + return (odp_frag == OVS_FRAG_TYPE_NONE) ? 0 + : (odp_frag == OVS_FRAG_TYPE_FIRST) ? FLOW_NW_FRAG_ANY + : FLOW_NW_FRAG_ANY | FLOW_NW_FRAG_LATER; } static bool @@ -2719,12 +3975,13 @@ parse_flow_nlattrs(const struct nlattr *key, size_t key_len, NL_ATTR_FOR_EACH (nla, left, key, key_len) { uint16_t type = nl_attr_type(nla); size_t len = nl_attr_get_size(nla); - int expected_len = odp_flow_key_attr_len(type); + int expected_len = odp_key_attr_len(ovs_flow_key_attr_lens, + OVS_KEY_ATTR_MAX, type); if (len != expected_len && expected_len >= 0) { char namebuf[OVS_KEY_ATTR_BUFSIZE]; - VLOG_ERR_RL(&rl, "attribute %s has length %zu but should have " + VLOG_ERR_RL(&rl, "attribute %s has length %"PRIuSIZE" but should have " "length %d", ovs_key_attr_to_string(type, namebuf, sizeof namebuf), len, expected_len); @@ -2829,21 +4086,45 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], enum ovs_key_attr expected_bit = 0xff; if (eth_type_mpls(src_flow->dl_type)) { - if (!is_mask) { + if (!is_mask || present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS)) { expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS); + } + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS)) { + size_t size = nl_attr_get_size(attrs[OVS_KEY_ATTR_MPLS]); + const ovs_be32 *mpls_lse = nl_attr_get(attrs[OVS_KEY_ATTR_MPLS]); + int n = size / sizeof(ovs_be32); + int i; - if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS))) { - return ODP_FIT_TOO_LITTLE; + if (!size || size % sizeof(ovs_be32)) { + return ODP_FIT_ERROR; } - flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]); - } else if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS)) { - flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]); - - if (flow->mpls_lse != 0 && flow->dl_type != htons(0xffff)) { + if (flow->mpls_lse[0] && flow->dl_type != htons(0xffff)) { return ODP_FIT_ERROR; } - expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS); + + for (i = 0; i < n && i < FLOW_MAX_MPLS_LABELS; i++) { + flow->mpls_lse[i] = mpls_lse[i]; + } + if (n > FLOW_MAX_MPLS_LABELS) { + return ODP_FIT_TOO_MUCH; + } + + if (!is_mask) { + /* BOS may be set only in the innermost label. */ + for (i = 0; i < n - 1; i++) { + if (flow->mpls_lse[i] & htonl(MPLS_BOS_MASK)) { + return ODP_FIT_ERROR; + } + } + + /* BOS must be set in the innermost label. */ + if (n < FLOW_MAX_MPLS_LABELS + && !(flow->mpls_lse[n - 1] & htonl(MPLS_BOS_MASK))) { + return ODP_FIT_TOO_LITTLE; + } + } } + goto done; } else if (src_flow->dl_type == htons(ETH_TYPE_IP)) { if (!is_mask) { @@ -2853,18 +4134,14 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], const struct ovs_key_ipv4 *ipv4_key; ipv4_key = nl_attr_get(attrs[OVS_KEY_ATTR_IPV4]); - flow->nw_src = ipv4_key->ipv4_src; - flow->nw_dst = ipv4_key->ipv4_dst; - flow->nw_proto = ipv4_key->ipv4_proto; - flow->nw_tos = ipv4_key->ipv4_tos; - flow->nw_ttl = ipv4_key->ipv4_ttl; + put_ipv4_key(ipv4_key, flow, is_mask); + if (flow->nw_frag > FLOW_NW_FRAG_MASK) { + return ODP_FIT_ERROR; + } if (is_mask) { - flow->nw_frag = ipv4_key->ipv4_frag; check_start = ipv4_key; check_len = sizeof *ipv4_key; expected_bit = OVS_KEY_ATTR_IPV4; - } else if (!odp_to_ovs_frag(ipv4_key->ipv4_frag, flow)) { - return ODP_FIT_ERROR; } } } else if (src_flow->dl_type == htons(ETH_TYPE_IPV6)) { @@ -2875,19 +4152,14 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], const struct ovs_key_ipv6 *ipv6_key; ipv6_key = nl_attr_get(attrs[OVS_KEY_ATTR_IPV6]); - memcpy(&flow->ipv6_src, ipv6_key->ipv6_src, sizeof flow->ipv6_src); - memcpy(&flow->ipv6_dst, ipv6_key->ipv6_dst, sizeof flow->ipv6_dst); - flow->ipv6_label = ipv6_key->ipv6_label; - flow->nw_proto = ipv6_key->ipv6_proto; - flow->nw_tos = ipv6_key->ipv6_tclass; - flow->nw_ttl = ipv6_key->ipv6_hlimit; + put_ipv6_key(ipv6_key, flow, is_mask); + if (flow->nw_frag > FLOW_NW_FRAG_MASK) { + return ODP_FIT_ERROR; + } if (is_mask) { - flow->nw_frag = ipv6_key->ipv6_frag; check_start = ipv6_key; check_len = sizeof *ipv6_key; expected_bit = OVS_KEY_ATTR_IPV6; - } else if (!odp_to_ovs_frag(ipv6_key->ipv6_frag, flow)) { - return ODP_FIT_ERROR; } } } else if (src_flow->dl_type == htons(ETH_TYPE_ARP) || @@ -2899,17 +4171,12 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], const struct ovs_key_arp *arp_key; arp_key = nl_attr_get(attrs[OVS_KEY_ATTR_ARP]); - flow->nw_src = arp_key->arp_sip; - flow->nw_dst = arp_key->arp_tip; if (!is_mask && (arp_key->arp_op & htons(0xff00))) { VLOG_ERR_RL(&rl, "unsupported ARP opcode %"PRIu16" in flow " "key", ntohs(arp_key->arp_op)); return ODP_FIT_ERROR; } - flow->nw_proto = ntohs(arp_key->arp_op); - memcpy(flow->arp_sha, arp_key->arp_sha, ETH_ADDR_LEN); - memcpy(flow->arp_tha, arp_key->arp_tha, ETH_ADDR_LEN); - + put_arp_key(arp_key, flow); if (is_mask) { check_start = arp_key; check_len = sizeof *arp_key; @@ -2919,7 +4186,7 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], } else { goto done; } - if (is_mask) { + if (check_len > 0) { /* Happens only when 'is_mask'. */ if (!is_all_zeros(check_start, check_len) && flow->dl_type != htons(0xffff)) { return ODP_FIT_ERROR; @@ -2937,13 +4204,16 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_TCP; } if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_TCP)) { - const struct ovs_key_tcp *tcp_key; + const union ovs_key_tp *tcp_key; tcp_key = nl_attr_get(attrs[OVS_KEY_ATTR_TCP]); - flow->tp_src = tcp_key->tcp_src; - flow->tp_dst = tcp_key->tcp_dst; + put_tp_key(tcp_key, flow); expected_bit = OVS_KEY_ATTR_TCP; } + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_TCP_FLAGS)) { + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_TCP_FLAGS; + flow->tcp_flags = nl_attr_get_be16(attrs[OVS_KEY_ATTR_TCP_FLAGS]); + } } else if (src_flow->nw_proto == IPPROTO_UDP && (src_flow->dl_type == htons(ETH_TYPE_IP) || src_flow->dl_type == htons(ETH_TYPE_IPV6)) @@ -2952,26 +4222,24 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_UDP; } if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_UDP)) { - const struct ovs_key_udp *udp_key; + const union ovs_key_tp *udp_key; udp_key = nl_attr_get(attrs[OVS_KEY_ATTR_UDP]); - flow->tp_src = udp_key->udp_src; - flow->tp_dst = udp_key->udp_dst; + put_tp_key(udp_key, flow); expected_bit = OVS_KEY_ATTR_UDP; } - } else if (flow->nw_proto == IPPROTO_SCTP - && (flow->dl_type == htons(ETH_TYPE_IP) || - flow->dl_type == htons(ETH_TYPE_IPV6)) - && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) { + } else if (src_flow->nw_proto == IPPROTO_SCTP + && (src_flow->dl_type == htons(ETH_TYPE_IP) || + src_flow->dl_type == htons(ETH_TYPE_IPV6)) + && !(src_flow->nw_frag & FLOW_NW_FRAG_LATER)) { if (!is_mask) { expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_SCTP; } if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_SCTP)) { - const struct ovs_key_sctp *sctp_key; + const union ovs_key_tp *sctp_key; sctp_key = nl_attr_get(attrs[OVS_KEY_ATTR_SCTP]); - flow->tp_src = sctp_key->sctp_src; - flow->tp_dst = sctp_key->sctp_dst; + put_tp_key(sctp_key, flow); expected_bit = OVS_KEY_ATTR_SCTP; } } else if (src_flow->nw_proto == IPPROTO_ICMP @@ -3013,11 +4281,10 @@ parse_l2_5_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], 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->arp_sha = nd_key->nd_sll; + flow->arp_tha = nd_key->nd_tll; if (is_mask) { - if (!is_all_zeros((const uint8_t *) nd_key, - sizeof *nd_key) && + if (!is_all_zeros(nd_key, sizeof *nd_key) && (flow->tp_src != htons(0xffff) || flow->tp_dst != htons(0xffff))) { return ODP_FIT_ERROR; @@ -3058,7 +4325,6 @@ parse_8021q_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], ? attrs[OVS_KEY_ATTR_ENCAP] : NULL); enum odp_key_fitness encap_fitness; enum odp_key_fitness fitness; - ovs_be16 tci; /* Calculate fitness of outer attributes. */ if (!is_mask) { @@ -3075,33 +4341,32 @@ parse_8021q_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], fitness = check_expectations(present_attrs, out_of_range_attr, expected_attrs, key, key_len); - /* Get the VLAN TCI value. */ - if (!is_mask && !(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN))) { - return ODP_FIT_TOO_LITTLE; - } else { - tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]); - if (!is_mask) { - if (tci == htons(0)) { - /* Corner case for a truncated 802.1Q header. */ - if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap)) { - return ODP_FIT_TOO_MUCH; - } - return fitness; - } else if (!(tci & htons(VLAN_CFI))) { - VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is nonzero " - "but CFI bit is not set", ntohs(tci)); - return ODP_FIT_ERROR; + /* Set vlan_tci. + * Remove the TPID from dl_type since it's not the real Ethertype. */ + flow->dl_type = htons(0); + flow->vlan_tci = (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN) + ? nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]) + : htons(0)); + if (!is_mask) { + if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN))) { + return ODP_FIT_TOO_LITTLE; + } else if (flow->vlan_tci == htons(0)) { + /* Corner case for a truncated 802.1Q header. */ + if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap)) { + return ODP_FIT_TOO_MUCH; } + return fitness; + } else if (!(flow->vlan_tci & htons(VLAN_CFI))) { + VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is nonzero " + "but CFI bit is not set", ntohs(flow->vlan_tci)); + return ODP_FIT_ERROR; + } + } else { + if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) { + return fitness; } - /* Set vlan_tci. - * Remove the TPID from dl_type since it's not the real Ethertype. */ - flow->dl_type = htons(0); - flow->vlan_tci = tci; } - if (is_mask && !(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) { - return fitness; - } /* Now parse the encapsulated attributes. */ if (!parse_flow_nlattrs(nl_attr_get(encap), nl_attr_get_size(encap), attrs, &present_attrs, &out_of_range_attr)) { @@ -3122,7 +4387,9 @@ parse_8021q_onward(const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1], static enum odp_key_fitness odp_flow_key_to_flow__(const struct nlattr *key, size_t key_len, - struct flow *flow, const struct flow *src_flow) + const struct nlattr *src_key, size_t src_key_len, + struct flow *flow, const struct flow *src_flow, + bool udpif) { const struct nlattr *attrs[OVS_KEY_ATTR_MAX + 1]; uint64_t expected_attrs; @@ -3140,6 +4407,18 @@ odp_flow_key_to_flow__(const struct nlattr *key, size_t key_len, expected_attrs = 0; /* Metadata. */ + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_RECIRC_ID)) { + flow->recirc_id = nl_attr_get_u32(attrs[OVS_KEY_ATTR_RECIRC_ID]); + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_RECIRC_ID; + } else if (is_mask) { + /* Always exact match recirc_id if it is not specified. */ + flow->recirc_id = UINT32_MAX; + } + + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_DP_HASH)) { + flow->dp_hash = nl_attr_get_u32(attrs[OVS_KEY_ATTR_DP_HASH]); + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_DP_HASH; + } if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_PRIORITY)) { flow->skb_priority = nl_attr_get_u32(attrs[OVS_KEY_ATTR_PRIORITY]); expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_PRIORITY; @@ -3150,10 +4429,24 @@ odp_flow_key_to_flow__(const struct nlattr *key, size_t key_len, 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_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 ? src_key : NULL, + src_key_len, &src_flow->tunnel, + &flow->tunnel, udpif); if (res == ODP_FIT_ERROR) { return ODP_FIT_ERROR; } else if (res == ODP_FIT_PERFECT) { @@ -3174,8 +4467,7 @@ odp_flow_key_to_flow__(const struct nlattr *key, size_t key_len, const struct ovs_key_ethernet *eth_key; eth_key = nl_attr_get(attrs[OVS_KEY_ATTR_ETHERNET]); - memcpy(flow->dl_src, eth_key->eth_src, ETH_ADDR_LEN); - memcpy(flow->dl_dst, eth_key->eth_dst, ETH_ADDR_LEN); + put_ethernet_key(eth_key, flow); if (is_mask) { expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_ETHERNET; } @@ -3190,12 +4482,14 @@ odp_flow_key_to_flow__(const struct nlattr *key, size_t key_len, return ODP_FIT_ERROR; } - if ((is_mask && (src_flow->vlan_tci & htons(VLAN_CFI))) || - (!is_mask && src_flow->dl_type == htons(ETH_TYPE_VLAN))) { + if (is_mask + ? (src_flow->vlan_tci & htons(VLAN_CFI)) != 0 + : src_flow->dl_type == htons(ETH_TYPE_VLAN)) { return parse_8021q_onward(attrs, present_attrs, out_of_range_attr, expected_attrs, flow, key, key_len, src_flow); } if (is_mask) { + /* A missing VLAN mask means exact match on vlan_tci 0 (== no VLAN). */ flow->vlan_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]); @@ -3225,18 +4519,46 @@ enum odp_key_fitness odp_flow_key_to_flow(const struct nlattr *key, size_t key_len, struct flow *flow) { - return odp_flow_key_to_flow__(key, key_len, flow, flow); + return odp_flow_key_to_flow__(key, key_len, NULL, 0, flow, flow, false); } -/* 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, +odp_flow_key_to_mask(const struct nlattr *mask_key, size_t mask_key_len, + const struct nlattr *flow_key, size_t flow_key_len, struct flow *mask, const struct flow *flow) { - return odp_flow_key_to_flow__(key, key_len, mask, flow); + return odp_flow_key_to_flow__(mask_key, mask_key_len, flow_key, flow_key_len, + mask, flow, false); +} + +/* These functions are similar to their non-"_udpif" variants but output a + * 'flow' that is suitable for fast-path packet processing. + * + * Some fields have different representation for flow setup and per- + * packet processing (i.e. different between ofproto-dpif and userspace + * datapath). In particular, with the non-"_udpif" functions, struct + * tun_metadata is in the per-flow format (using 'present.map' and 'opts.u8'); + * with these functions, struct tun_metadata is in the per-packet format + * (using 'present.len' and 'opts.gnv'). */ +enum odp_key_fitness +odp_flow_key_to_flow_udpif(const struct nlattr *key, size_t key_len, + struct flow *flow) +{ + return odp_flow_key_to_flow__(key, key_len, NULL, 0, flow, flow, true); +} + +enum odp_key_fitness +odp_flow_key_to_mask_udpif(const struct nlattr *mask_key, size_t mask_key_len, + const struct nlattr *flow_key, size_t flow_key_len, + struct flow *mask, const struct flow *flow) +{ + return odp_flow_key_to_flow__(mask_key, mask_key_len, flow_key, flow_key_len, + mask, flow, true); } /* Returns 'fitness' as a string, for use in debug messages. */ @@ -3265,6 +4587,8 @@ odp_key_fitness_to_string(enum odp_key_fitness fitness) size_t 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; @@ -3274,11 +4598,30 @@ odp_put_userspace_action(uint32_t pid, nl_msg_put_u32(odp_actions, OVS_USERSPACE_ATTR_PID, pid); if (userdata) { userdata_ofs = odp_actions->size + NLA_HDRLEN; - nl_msg_put_unspec(odp_actions, OVS_USERSPACE_ATTR_USERDATA, - userdata, userdata_size); + + /* The OVS kernel module before OVS 1.11 and the upstream Linux kernel + * module before Linux 3.10 required the userdata to be exactly 8 bytes + * long: + * + * - The kernel rejected shorter userdata with -ERANGE. + * + * - The kernel silently dropped userdata beyond the first 8 bytes. + * + * Thus, for maximum compatibility, always put at least 8 bytes. (We + * separately disable features that required more than 8 bytes.) */ + memcpy(nl_msg_put_unspec_zero(odp_actions, OVS_USERSPACE_ATTR_USERDATA, + MAX(8, userdata_size)), + userdata, userdata_size); } else { userdata_ofs = 0; } + if (tunnel_out_port != ODPP_NONE) { + 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; @@ -3289,9 +4632,20 @@ 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); } + +void +odp_put_tnl_push_action(struct ofpbuf *odp_actions, + struct ovs_action_push_tnl *data) +{ + int size = offsetof(struct ovs_action_push_tnl, header); + + size += data->header_len; + nl_msg_put_unspec(odp_actions, OVS_ACTION_ATTR_TUNNEL_PUSH, data, size); +} + /* The commit_odp_actions() function and its helpers. */ @@ -3304,12 +4658,25 @@ commit_set_action(struct ofpbuf *odp_actions, enum ovs_key_attr key_type, nl_msg_end_nested(odp_actions, offset); } +/* Masked set actions have a mask following the data within the netlink + * attribute. The unmasked bits in the data will be cleared as the data + * is copied to the action. */ void -odp_put_pkt_mark_action(const uint32_t pkt_mark, - struct ofpbuf *odp_actions) +commit_masked_set_action(struct ofpbuf *odp_actions, + enum ovs_key_attr key_type, + const void *key_, const void *mask_, size_t key_size) { - commit_set_action(odp_actions, OVS_KEY_ATTR_SKB_MARK, &pkt_mark, - sizeof(pkt_mark)); + size_t offset = nl_msg_start_nested(odp_actions, + OVS_ACTION_ATTR_SET_MASKED); + char *data = nl_msg_put_unspec_uninit(odp_actions, key_type, key_size * 2); + const char *key = key_, *mask = mask_; + + memcpy(data + key_size, mask, key_size); + /* Clear unmasked bits while copying. */ + while (key_size--) { + *data++ = *key++ & *mask++; + } + nl_msg_end_nested(odp_actions, offset); } /* If any of the flow key data that ODP actions can modify are different in @@ -3332,45 +4699,86 @@ commit_odp_tunnel_action(const struct flow *flow, struct flow *base, } } -static void -commit_set_ether_addr_action(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, - struct flow_wildcards *wc) +static bool +commit(enum ovs_key_attr attr, bool use_masked_set, + const void *key, void *base, void *mask, size_t size, + struct ofpbuf *odp_actions) { - struct ovs_key_ethernet eth_key; + if (memcmp(key, base, size)) { + bool fully_masked = odp_mask_is_exact(attr, mask, size); - if (eth_addr_equals(base->dl_src, flow->dl_src) && - eth_addr_equals(base->dl_dst, flow->dl_dst)) { - return; + if (use_masked_set && !fully_masked) { + commit_masked_set_action(odp_actions, attr, key, mask, size); + } else { + if (!fully_masked) { + memset(mask, 0xff, size); + } + commit_set_action(odp_actions, attr, key, size); + } + memcpy(base, key, size); + return true; + } else { + /* Mask bits are set when we have either read or set the corresponding + * values. Masked bits will be exact-matched, no need to set them + * if the value did not actually change. */ + return false; } +} - memset(&wc->masks.dl_src, 0xff, sizeof wc->masks.dl_src); - memset(&wc->masks.dl_dst, 0xff, sizeof wc->masks.dl_dst); - - memcpy(base->dl_src, flow->dl_src, ETH_ADDR_LEN); - memcpy(base->dl_dst, flow->dl_dst, ETH_ADDR_LEN); - - memcpy(eth_key.eth_src, base->dl_src, ETH_ADDR_LEN); - memcpy(eth_key.eth_dst, base->dl_dst, ETH_ADDR_LEN); +static void +get_ethernet_key(const struct flow *flow, struct ovs_key_ethernet *eth) +{ + eth->eth_src = flow->dl_src; + eth->eth_dst = flow->dl_dst; +} - commit_set_action(odp_actions, OVS_KEY_ATTR_ETHERNET, - ð_key, sizeof(eth_key)); +static void +put_ethernet_key(const struct ovs_key_ethernet *eth, struct flow *flow) +{ + flow->dl_src = eth->eth_src; + flow->dl_dst = eth->eth_dst; } static void -commit_vlan_action(ovs_be16 vlan_tci, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc) +commit_set_ether_addr_action(const struct flow *flow, struct flow *base_flow, + struct ofpbuf *odp_actions, + struct flow_wildcards *wc, + bool use_masked) { - if (base->vlan_tci == vlan_tci) { - return; + struct ovs_key_ethernet key, base, mask; + + get_ethernet_key(flow, &key); + get_ethernet_key(base_flow, &base); + get_ethernet_key(&wc->masks, &mask); + + if (commit(OVS_KEY_ATTR_ETHERNET, use_masked, + &key, &base, &mask, sizeof key, odp_actions)) { + put_ethernet_key(&base, base_flow); + put_ethernet_key(&mask, &wc->masks); } +} +static void +pop_vlan(struct flow *base, + struct ofpbuf *odp_actions, struct flow_wildcards *wc) +{ memset(&wc->masks.vlan_tci, 0xff, sizeof wc->masks.vlan_tci); if (base->vlan_tci & htons(VLAN_CFI)) { nl_msg_put_flag(odp_actions, OVS_ACTION_ATTR_POP_VLAN); + base->vlan_tci = 0; + } +} + +static void +commit_vlan_action(ovs_be16 vlan_tci, struct flow *base, + struct ofpbuf *odp_actions, struct flow_wildcards *wc) +{ + if (base->vlan_tci == vlan_tci) { + return; } + pop_vlan(base, odp_actions, wc); if (vlan_tci & htons(VLAN_CFI)) { struct ovs_action_push_vlan vlan; @@ -3382,158 +4790,256 @@ commit_vlan_action(ovs_be16 vlan_tci, struct flow *base, base->vlan_tci = vlan_tci; } +/* Wildcarding already done at action translation time. */ static void commit_mpls_action(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc, - int *mpls_depth_delta) + struct ofpbuf *odp_actions) { - if (flow->mpls_lse == base->mpls_lse && !*mpls_depth_delta) { - return; + int base_n = flow_count_mpls_labels(base, NULL); + int flow_n = flow_count_mpls_labels(flow, NULL); + int common_n = flow_count_common_mpls_labels(flow, flow_n, base, base_n, + NULL); + + while (base_n > common_n) { + if (base_n - 1 == common_n && flow_n > common_n) { + /* If there is only one more LSE in base than there are common + * between base and flow; and flow has at least one more LSE than + * is common then the topmost LSE of base may be updated using + * set */ + struct ovs_key_mpls mpls_key; + + mpls_key.mpls_lse = flow->mpls_lse[flow_n - base_n]; + commit_set_action(odp_actions, OVS_KEY_ATTR_MPLS, + &mpls_key, sizeof mpls_key); + flow_set_mpls_lse(base, 0, mpls_key.mpls_lse); + common_n++; + } else { + /* Otherwise, if there more LSEs in base than are common between + * base and flow then pop the topmost one. */ + ovs_be16 dl_type; + bool popped; + + /* If all the LSEs are to be popped and this is not the outermost + * LSE then use ETH_TYPE_MPLS as the ethertype parameter of the + * POP_MPLS action instead of flow->dl_type. + * + * This is because the POP_MPLS action requires its ethertype + * argument to be an MPLS ethernet type but in this case + * flow->dl_type will be a non-MPLS ethernet type. + * + * When the final POP_MPLS action occurs it use flow->dl_type and + * the and the resulting packet will have the desired dl_type. */ + if ((!eth_type_mpls(flow->dl_type)) && base_n > 1) { + dl_type = htons(ETH_TYPE_MPLS); + } else { + dl_type = flow->dl_type; + } + nl_msg_put_be16(odp_actions, OVS_ACTION_ATTR_POP_MPLS, dl_type); + popped = flow_pop_mpls(base, base_n, flow->dl_type, NULL); + ovs_assert(popped); + base_n--; + } } - memset(&wc->masks.mpls_lse, 0xff, sizeof wc->masks.mpls_lse); - - switch (*mpls_depth_delta) { - case -1: - nl_msg_put_be16(odp_actions, OVS_ACTION_ATTR_POP_MPLS, flow->dl_type); - break; - case 1: { + /* If, after the above popping and setting, there are more LSEs in flow + * than base then some LSEs need to be pushed. */ + while (base_n < flow_n) { struct ovs_action_push_mpls *mpls; - mpls = nl_msg_put_unspec_uninit(odp_actions, OVS_ACTION_ATTR_PUSH_MPLS, - sizeof *mpls); - memset(mpls, 0, sizeof *mpls); + mpls = nl_msg_put_unspec_zero(odp_actions, + OVS_ACTION_ATTR_PUSH_MPLS, + sizeof *mpls); mpls->mpls_ethertype = flow->dl_type; - mpls->mpls_lse = flow->mpls_lse; - break; - } - case 0: { - struct ovs_key_mpls mpls_key; - - mpls_key.mpls_lse = flow->mpls_lse; - commit_set_action(odp_actions, OVS_KEY_ATTR_MPLS, - &mpls_key, sizeof(mpls_key)); - break; + mpls->mpls_lse = flow->mpls_lse[flow_n - base_n - 1]; + flow_push_mpls(base, base_n, mpls->mpls_ethertype, NULL); + flow_set_mpls_lse(base, 0, mpls->mpls_lse); + base_n++; } - default: - NOT_REACHED(); - } - - base->dl_type = flow->dl_type; - base->mpls_lse = flow->mpls_lse; - *mpls_depth_delta = 0; } static void -commit_set_ipv4_action(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc) +get_ipv4_key(const struct flow *flow, struct ovs_key_ipv4 *ipv4, bool is_mask) { - struct ovs_key_ipv4 ipv4_key; - - if (base->nw_src == flow->nw_src && - base->nw_dst == flow->nw_dst && - base->nw_tos == flow->nw_tos && - base->nw_ttl == flow->nw_ttl && - base->nw_frag == flow->nw_frag) { - return; - } + ipv4->ipv4_src = flow->nw_src; + ipv4->ipv4_dst = flow->nw_dst; + ipv4->ipv4_proto = flow->nw_proto; + ipv4->ipv4_tos = flow->nw_tos; + ipv4->ipv4_ttl = flow->nw_ttl; + ipv4->ipv4_frag = ovs_to_odp_frag(flow->nw_frag, is_mask); +} - memset(&wc->masks.nw_src, 0xff, sizeof wc->masks.nw_src); - memset(&wc->masks.nw_dst, 0xff, sizeof wc->masks.nw_dst); - memset(&wc->masks.nw_tos, 0xff, sizeof wc->masks.nw_tos); - memset(&wc->masks.nw_ttl, 0xff, sizeof wc->masks.nw_ttl); - memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto); - memset(&wc->masks.nw_frag, 0xff, sizeof wc->masks.nw_frag); +static void +put_ipv4_key(const struct ovs_key_ipv4 *ipv4, struct flow *flow, bool is_mask) +{ + flow->nw_src = ipv4->ipv4_src; + flow->nw_dst = ipv4->ipv4_dst; + flow->nw_proto = ipv4->ipv4_proto; + flow->nw_tos = ipv4->ipv4_tos; + flow->nw_ttl = ipv4->ipv4_ttl; + flow->nw_frag = odp_to_ovs_frag(ipv4->ipv4_frag, is_mask); +} - ipv4_key.ipv4_src = base->nw_src = flow->nw_src; - ipv4_key.ipv4_dst = base->nw_dst = flow->nw_dst; - ipv4_key.ipv4_tos = base->nw_tos = flow->nw_tos; - ipv4_key.ipv4_ttl = base->nw_ttl = flow->nw_ttl; - ipv4_key.ipv4_proto = base->nw_proto; - ipv4_key.ipv4_frag = ovs_to_odp_frag(base->nw_frag); +static void +commit_set_ipv4_action(const struct flow *flow, struct flow *base_flow, + struct ofpbuf *odp_actions, struct flow_wildcards *wc, + bool use_masked) +{ + struct ovs_key_ipv4 key, mask, base; + + /* Check that nw_proto and nw_frag remain unchanged. */ + ovs_assert(flow->nw_proto == base_flow->nw_proto && + flow->nw_frag == base_flow->nw_frag); + + get_ipv4_key(flow, &key, false); + get_ipv4_key(base_flow, &base, false); + get_ipv4_key(&wc->masks, &mask, true); + mask.ipv4_proto = 0; /* Not writeable. */ + mask.ipv4_frag = 0; /* Not writable. */ + + if (commit(OVS_KEY_ATTR_IPV4, use_masked, &key, &base, &mask, sizeof key, + odp_actions)) { + put_ipv4_key(&base, base_flow, false); + if (mask.ipv4_proto != 0) { /* Mask was changed by commit(). */ + put_ipv4_key(&mask, &wc->masks, true); + } + } +} - commit_set_action(odp_actions, OVS_KEY_ATTR_IPV4, - &ipv4_key, sizeof(ipv4_key)); +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_label = flow->ipv6_label; + ipv6->ipv6_proto = flow->nw_proto; + ipv6->ipv6_tclass = flow->nw_tos; + ipv6->ipv6_hlimit = flow->nw_ttl; + ipv6->ipv6_frag = ovs_to_odp_frag(flow->nw_frag, is_mask); } static void -commit_set_ipv6_action(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc) +put_ipv6_key(const struct ovs_key_ipv6 *ipv6, struct flow *flow, bool is_mask) { - struct ovs_key_ipv6 ipv6_key; + memcpy(&flow->ipv6_src, ipv6->ipv6_src, sizeof flow->ipv6_src); + memcpy(&flow->ipv6_dst, ipv6->ipv6_dst, sizeof flow->ipv6_dst); + flow->ipv6_label = ipv6->ipv6_label; + flow->nw_proto = ipv6->ipv6_proto; + flow->nw_tos = ipv6->ipv6_tclass; + flow->nw_ttl = ipv6->ipv6_hlimit; + flow->nw_frag = odp_to_ovs_frag(ipv6->ipv6_frag, is_mask); +} - if (ipv6_addr_equals(&base->ipv6_src, &flow->ipv6_src) && - ipv6_addr_equals(&base->ipv6_dst, &flow->ipv6_dst) && - base->ipv6_label == flow->ipv6_label && - base->nw_tos == flow->nw_tos && - base->nw_ttl == flow->nw_ttl && - base->nw_frag == flow->nw_frag) { - return; +static void +commit_set_ipv6_action(const struct flow *flow, struct flow *base_flow, + struct ofpbuf *odp_actions, struct flow_wildcards *wc, + bool use_masked) +{ + struct ovs_key_ipv6 key, mask, base; + + /* Check that nw_proto and nw_frag remain unchanged. */ + ovs_assert(flow->nw_proto == base_flow->nw_proto && + flow->nw_frag == base_flow->nw_frag); + + get_ipv6_key(flow, &key, false); + get_ipv6_key(base_flow, &base, false); + get_ipv6_key(&wc->masks, &mask, true); + mask.ipv6_proto = 0; /* Not writeable. */ + mask.ipv6_frag = 0; /* Not writable. */ + + if (commit(OVS_KEY_ATTR_IPV6, use_masked, &key, &base, &mask, sizeof key, + odp_actions)) { + put_ipv6_key(&base, base_flow, false); + if (mask.ipv6_proto != 0) { /* Mask was changed by commit(). */ + put_ipv6_key(&mask, &wc->masks, true); + } } +} - memset(&wc->masks.ipv6_src, 0xff, sizeof wc->masks.ipv6_src); - memset(&wc->masks.ipv6_dst, 0xff, sizeof wc->masks.ipv6_dst); - memset(&wc->masks.ipv6_label, 0xff, sizeof wc->masks.ipv6_label); - memset(&wc->masks.nw_tos, 0xff, sizeof wc->masks.nw_tos); - memset(&wc->masks.nw_ttl, 0xff, sizeof wc->masks.nw_ttl); - memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto); - memset(&wc->masks.nw_frag, 0xff, sizeof wc->masks.nw_frag); - - base->ipv6_src = flow->ipv6_src; - memcpy(&ipv6_key.ipv6_src, &base->ipv6_src, sizeof(ipv6_key.ipv6_src)); - base->ipv6_dst = flow->ipv6_dst; - memcpy(&ipv6_key.ipv6_dst, &base->ipv6_dst, sizeof(ipv6_key.ipv6_dst)); - - ipv6_key.ipv6_label = base->ipv6_label = flow->ipv6_label; - ipv6_key.ipv6_tclass = base->nw_tos = flow->nw_tos; - ipv6_key.ipv6_hlimit = base->nw_ttl = flow->nw_ttl; - ipv6_key.ipv6_proto = base->nw_proto; - ipv6_key.ipv6_frag = ovs_to_odp_frag(base->nw_frag); +static void +get_arp_key(const struct flow *flow, struct ovs_key_arp *arp) +{ + /* ARP key has padding, clear it. */ + memset(arp, 0, sizeof *arp); + + arp->arp_sip = flow->nw_src; + arp->arp_tip = flow->nw_dst; + arp->arp_op = htons(flow->nw_proto); + arp->arp_sha = flow->arp_sha; + arp->arp_tha = flow->arp_tha; +} - commit_set_action(odp_actions, OVS_KEY_ATTR_IPV6, - &ipv6_key, sizeof(ipv6_key)); +static void +put_arp_key(const struct ovs_key_arp *arp, struct flow *flow) +{ + flow->nw_src = arp->arp_sip; + flow->nw_dst = arp->arp_tip; + flow->nw_proto = ntohs(arp->arp_op); + flow->arp_sha = arp->arp_sha; + flow->arp_tha = arp->arp_tha; } static enum slow_path_reason -commit_set_arp_action(const struct flow *flow, struct flow *base, +commit_set_arp_action(const struct flow *flow, struct flow *base_flow, struct ofpbuf *odp_actions, struct flow_wildcards *wc) { - struct ovs_key_arp arp_key; + struct ovs_key_arp key, mask, base; - if (base->nw_src == flow->nw_src && - base->nw_dst == flow->nw_dst && - base->nw_proto == flow->nw_proto && - eth_addr_equals(base->arp_sha, flow->arp_sha) && - eth_addr_equals(base->arp_tha, flow->arp_tha)) { - return 0; + get_arp_key(flow, &key); + get_arp_key(base_flow, &base); + get_arp_key(&wc->masks, &mask); + + if (commit(OVS_KEY_ATTR_ARP, true, &key, &base, &mask, sizeof key, + odp_actions)) { + put_arp_key(&base, base_flow); + put_arp_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_sll and nd_tll are stored in arp_sha and arp_tha, respectively */ + nd->nd_sll = flow->arp_sha; + nd->nd_tll = flow->arp_tha; +} - memset(&wc->masks.nw_src, 0xff, sizeof wc->masks.nw_src); - memset(&wc->masks.nw_dst, 0xff, sizeof wc->masks.nw_dst); - memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto); - memset(&wc->masks.arp_sha, 0xff, sizeof wc->masks.arp_sha); - memset(&wc->masks.arp_tha, 0xff, sizeof wc->masks.arp_tha); +static void +put_nd_key(const struct ovs_key_nd *nd, struct flow *flow) +{ + memcpy(&flow->nd_target, nd->nd_target, sizeof flow->nd_target); + /* nd_sll and nd_tll are stored in arp_sha and arp_tha, respectively */ + flow->arp_sha = nd->nd_sll; + flow->arp_tha = nd->nd_tll; +} - base->nw_src = flow->nw_src; - base->nw_dst = flow->nw_dst; - base->nw_proto = flow->nw_proto; - memcpy(base->arp_sha, flow->arp_sha, ETH_ADDR_LEN); - memcpy(base->arp_tha, flow->arp_tha, ETH_ADDR_LEN); +static enum slow_path_reason +commit_set_nd_action(const struct flow *flow, struct flow *base_flow, + struct ofpbuf *odp_actions, + struct flow_wildcards *wc, bool use_masked) +{ + struct ovs_key_nd key, mask, base; - arp_key.arp_sip = base->nw_src; - arp_key.arp_tip = base->nw_dst; - arp_key.arp_op = htons(base->nw_proto); - memcpy(arp_key.arp_sha, flow->arp_sha, ETH_ADDR_LEN); - memcpy(arp_key.arp_tha, flow->arp_tha, ETH_ADDR_LEN); + get_nd_key(flow, &key); + get_nd_key(base_flow, &base); + get_nd_key(&wc->masks, &mask); - commit_set_action(odp_actions, OVS_KEY_ATTR_ARP, &arp_key, sizeof arp_key); + if (commit(OVS_KEY_ATTR_ND, use_masked, &key, &base, &mask, sizeof key, + odp_actions)) { + put_nd_key(&base, base_flow); + put_nd_key(&mask, &wc->masks); + return SLOW_ACTION; + } - return SLOW_ACTION; + return 0; } static enum slow_path_reason commit_set_nw_action(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc) + struct ofpbuf *odp_actions, struct flow_wildcards *wc, + bool use_masked) { /* Check if 'flow' really has an L3 header. */ if (!flow->nw_proto) { @@ -3542,12 +5048,12 @@ commit_set_nw_action(const struct flow *flow, struct flow *base, switch (ntohs(base->dl_type)) { case ETH_TYPE_IP: - commit_set_ipv4_action(flow, base, odp_actions, wc); + commit_set_ipv4_action(flow, base, odp_actions, wc, use_masked); break; case ETH_TYPE_IPV6: - commit_set_ipv6_action(flow, base, odp_actions, wc); - break; + commit_set_ipv6_action(flow, base, odp_actions, wc, use_masked); + return commit_set_nd_action(flow, base, odp_actions, wc, use_masked); case ETH_TYPE_ARP: return commit_set_arp_action(flow, base, odp_actions, wc); @@ -3556,79 +5062,98 @@ commit_set_nw_action(const struct flow *flow, struct flow *base, return 0; } +/* 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 +get_tp_key(const struct flow *flow, union ovs_key_tp *tp) +{ + tp->tcp.tcp_src = flow->tp_src; + tp->tcp.tcp_dst = flow->tp_dst; +} + +static void +put_tp_key(const union ovs_key_tp *tp, struct flow *flow) +{ + flow->tp_src = tp->tcp.tcp_src; + flow->tp_dst = tp->tcp.tcp_dst; +} + static void -commit_set_port_action(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc) +commit_set_port_action(const struct flow *flow, struct flow *base_flow, + struct ofpbuf *odp_actions, struct flow_wildcards *wc, + bool use_masked) { - if (!is_ip_any(base) || (!base->tp_src && !base->tp_dst)) { + enum ovs_key_attr key_type; + union ovs_key_tp key, mask, base; + + /* Check if 'flow' really has an L3 header. */ + if (!flow->nw_proto) { return; } - if (base->tp_src == flow->tp_src && - base->tp_dst == flow->tp_dst) { + if (!is_ip_any(base_flow)) { return; } - memset(&wc->masks.tp_src, 0xff, sizeof wc->masks.tp_src); - memset(&wc->masks.tp_dst, 0xff, sizeof wc->masks.tp_dst); - if (flow->nw_proto == IPPROTO_TCP) { - struct ovs_key_tcp port_key; - - port_key.tcp_src = base->tp_src = flow->tp_src; - port_key.tcp_dst = base->tp_dst = flow->tp_dst; - - commit_set_action(odp_actions, OVS_KEY_ATTR_TCP, - &port_key, sizeof(port_key)); - + key_type = OVS_KEY_ATTR_TCP; } else if (flow->nw_proto == IPPROTO_UDP) { - struct ovs_key_udp port_key; - - port_key.udp_src = base->tp_src = flow->tp_src; - port_key.udp_dst = base->tp_dst = flow->tp_dst; - - commit_set_action(odp_actions, OVS_KEY_ATTR_UDP, - &port_key, sizeof(port_key)); + key_type = OVS_KEY_ATTR_UDP; } else if (flow->nw_proto == IPPROTO_SCTP) { - struct ovs_key_sctp port_key; + key_type = OVS_KEY_ATTR_SCTP; + } else { + return; + } - port_key.sctp_src = base->tp_src = flow->tp_src; - port_key.sctp_dst = base->tp_dst = flow->tp_dst; + get_tp_key(flow, &key); + get_tp_key(base_flow, &base); + get_tp_key(&wc->masks, &mask); - commit_set_action(odp_actions, OVS_KEY_ATTR_SCTP, - &port_key, sizeof(port_key)); + if (commit(key_type, use_masked, &key, &base, &mask, sizeof key, + odp_actions)) { + put_tp_key(&base, base_flow); + put_tp_key(&mask, &wc->masks); } } static void -commit_set_priority_action(const struct flow *flow, struct flow *base, +commit_set_priority_action(const struct flow *flow, struct flow *base_flow, struct ofpbuf *odp_actions, - struct flow_wildcards *wc) + struct flow_wildcards *wc, + bool use_masked) { - if (base->skb_priority == flow->skb_priority) { - return; - } + uint32_t key, mask, base; - memset(&wc->masks.skb_priority, 0xff, sizeof wc->masks.skb_priority); - base->skb_priority = flow->skb_priority; + key = flow->skb_priority; + base = base_flow->skb_priority; + mask = wc->masks.skb_priority; - commit_set_action(odp_actions, OVS_KEY_ATTR_PRIORITY, - &base->skb_priority, sizeof(base->skb_priority)); + if (commit(OVS_KEY_ATTR_PRIORITY, use_masked, &key, &base, &mask, + sizeof key, odp_actions)) { + base_flow->skb_priority = base; + wc->masks.skb_priority = mask; + } } static void -commit_set_pkt_mark_action(const struct flow *flow, struct flow *base, +commit_set_pkt_mark_action(const struct flow *flow, struct flow *base_flow, struct ofpbuf *odp_actions, - struct flow_wildcards *wc) + struct flow_wildcards *wc, + bool use_masked) { - if (base->pkt_mark == flow->pkt_mark) { - return; - } + uint32_t key, mask, base; - memset(&wc->masks.pkt_mark, 0xff, sizeof wc->masks.pkt_mark); - base->pkt_mark = flow->pkt_mark; + key = flow->pkt_mark; + base = base_flow->pkt_mark; + mask = wc->masks.pkt_mark; - odp_put_pkt_mark_action(base->pkt_mark, odp_actions); + if (commit(OVS_KEY_ATTR_SKB_MARK, use_masked, &key, &base, &mask, + sizeof key, odp_actions)) { + base_flow->pkt_mark = base; + wc->masks.pkt_mark = mask; + } } /* If any of the flow key data that ODP actions can modify are different in @@ -3643,21 +5168,17 @@ commit_set_pkt_mark_action(const struct flow *flow, struct flow *base, enum slow_path_reason commit_odp_actions(const struct flow *flow, struct flow *base, struct ofpbuf *odp_actions, struct flow_wildcards *wc, - int *mpls_depth_delta) + bool use_masked) { enum slow_path_reason slow; - commit_set_ether_addr_action(flow, base, odp_actions, wc); + commit_set_ether_addr_action(flow, base, odp_actions, wc, use_masked); + slow = 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); - slow = commit_set_nw_action(flow, base, odp_actions, wc); - commit_set_port_action(flow, base, odp_actions, wc); - /* Committing MPLS actions should occur after committing nw and port - * actions. This is because committing MPLS actions may alter a packet so - * that it is no longer IP and thus nw and port actions are no longer valid. - */ - commit_mpls_action(flow, base, odp_actions, wc, mpls_depth_delta); - commit_set_priority_action(flow, base, odp_actions, wc); - commit_set_pkt_mark_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; }