X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fodp-util.c;h=af464a0409508a354fe1e16135dce342bfa2d424;hb=61abba807febc0954acc0d23aeb75b081ad9d77a;hp=247e5f6ff61136de55cc748fbdea842aeb56c31b;hpb=758c456df570a1af1d9e913d50a3478785663e66;p=sliver-openvswitch.git diff --git a/lib/odp-util.c b/lib/odp-util.c index 247e5f6ff..af464a040 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 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -79,6 +79,8 @@ odp_action_len(uint16_t type) case OVS_ACTION_ATTR_POP_VLAN: return 0; case OVS_ACTION_ATTR_PUSH_MPLS: return sizeof(struct ovs_action_push_mpls); case OVS_ACTION_ATTR_POP_MPLS: return sizeof(ovs_be16); + case OVS_ACTION_ATTR_RECIRC: return sizeof(uint32_t); + case OVS_ACTION_ATTR_HASH: return sizeof(struct ovs_action_hash); case OVS_ACTION_ATTR_SET: return -2; case OVS_ACTION_ATTR_SAMPLE: return -2; @@ -118,6 +120,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: @@ -149,9 +153,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; @@ -255,9 +258,9 @@ 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 }, }; struct nlattr *a[ARRAY_SIZE(ovs_userspace_policy)]; const struct nlattr *userdata_attr; @@ -353,21 +356,55 @@ 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) { - ovs_be32 key = mpls_key->mpls_lse; + if (n == 1) { + ovs_be32 key = mpls_key->mpls_lse; - if (mpls_mask == NULL) { - format_mpls_lse(ds, key); + if (mpls_mask == NULL) { + format_mpls_lse(ds, key); + } else { + ovs_be32 mask = mpls_mask->mpls_lse; + + ds_put_format(ds, "label=%"PRIu32"/0x%x,tc=%d/%x,ttl=%d/0x%x,bos=%d/%x", + mpls_lse_to_label(key), mpls_lse_to_label(mask), + mpls_lse_to_tc(key), mpls_lse_to_tc(mask), + mpls_lse_to_ttl(key), mpls_lse_to_ttl(mask), + mpls_lse_to_bos(key), mpls_lse_to_bos(mask)); + } } else { - ovs_be32 mask = mpls_mask->mpls_lse; + int i; + + for (i = 0; i < n; i++) { + ds_put_format(ds, "lse%d=%#"PRIx32, + i, ntohl(mpls_key[i].mpls_lse)); + if (mpls_mask) { + ds_put_format(ds, "/%#"PRIx32, ntohl(mpls_mask[i].mpls_lse)); + } + ds_put_char(ds, ','); + } + ds_chomp(ds, ','); + } +} - ds_put_format(ds, "label=%"PRIu32"/0x%x,tc=%d/%x,ttl=%d/0x%x,bos=%d/%x", - mpls_lse_to_label(key), mpls_lse_to_label(mask), - mpls_lse_to_tc(key), mpls_lse_to_tc(mask), - mpls_lse_to_ttl(key), mpls_lse_to_ttl(mask), - mpls_lse_to_bos(key), mpls_lse_to_bos(mask)); +static void +format_odp_recirc_action(struct ds *ds, uint32_t recirc_id) +{ + ds_put_format(ds, "recirc(%"PRIu32")", recirc_id); +} + +static void +format_odp_hash_action(struct ds *ds, const struct ovs_action_hash *hash_act) +{ + ds_put_format(ds, "hash("); + + if (hash_act->hash_alg == OVS_HASH_ALG_L4) { + ds_put_format(ds, "hash_l4(%"PRIu32")", hash_act->hash_basis); + } else { + ds_put_format(ds, "Unknown hash algorithm(%"PRIu32")", + hash_act->hash_alg); } + ds_put_format(ds, ")"); } static void @@ -392,6 +429,12 @@ format_odp_action(struct ds *ds, const struct nlattr *a) case OVS_ACTION_ATTR_USERSPACE: format_odp_userspace_action(ds, a); break; + case OVS_ACTION_ATTR_RECIRC: + format_odp_recirc_action(ds, nl_attr_get_u32(a)); + break; + case OVS_ACTION_ATTR_HASH: + format_odp_hash_action(ds, nl_attr_get(a)); + break; case OVS_ACTION_ATTR_SET: ds_put_cstr(ds, "set("); format_odp_key_attr(nl_attr_get(a), NULL, NULL, ds, true); @@ -573,7 +616,7 @@ parse_odp_action(const char *s, const struct simap *port_names, ofpbuf_init(&buf, 16); end = ofpbuf_put_hex(&buf, &s[n], NULL); if (end[0] == ')' && end[1] == ')') { - odp_put_userspace_action(pid, buf.data, buf.size, actions); + odp_put_userspace_action(pid, ofpbuf_data(&buf), ofpbuf_size(&buf), actions); ofpbuf_uninit(&buf); return (end + 2) - s; } @@ -683,7 +726,7 @@ odp_actions_from_string(const char *s, const struct simap *port_names, return 0; } - old_size = actions->size; + old_size = ofpbuf_size(actions); for (;;) { int retval; @@ -694,7 +737,7 @@ odp_actions_from_string(const char *s, const struct simap *port_names, retval = parse_odp_action(s, port_names, actions); if (retval < 0 || !strchr(delimiters, s[retval])) { - actions->size = old_size; + ofpbuf_set_size(actions, old_size); return -retval; } s += retval; @@ -717,12 +760,14 @@ odp_flow_key_attr_len(uint16_t 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_DP_HASH: return 4; + case OVS_KEY_ATTR_RECIRC_ID: return 4; case OVS_KEY_ATTR_TUNNEL: return -2; case OVS_KEY_ATTR_IN_PORT: return 4; case OVS_KEY_ATTR_ETHERNET: return sizeof(struct ovs_key_ethernet); case OVS_KEY_ATTR_VLAN: return sizeof(ovs_be16); case OVS_KEY_ATTR_ETHERTYPE: return 2; - case OVS_KEY_ATTR_MPLS: return sizeof(struct ovs_key_mpls); + case OVS_KEY_ATTR_MPLS: return -2; case OVS_KEY_ATTR_IPV4: return sizeof(struct ovs_key_ipv4); case OVS_KEY_ATTR_IPV6: return sizeof(struct ovs_key_ipv6); case OVS_KEY_ATTR_TCP: return sizeof(struct ovs_key_tcp); @@ -858,7 +903,8 @@ tun_key_to_attr(struct ofpbuf *a, const struct flow_tnl *tun_key) 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) { @@ -974,22 +1020,22 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, expected_len = odp_flow_key_attr_len(nl_attr_type(a)); if (expected_len != -2) { bool bad_key_len = nl_attr_get_size(a) != expected_len; - bool bad_mask_len = ma && nl_attr_get_size(a) != expected_len; + bool bad_mask_len = ma && nl_attr_get_size(ma) != expected_len; if (bad_key_len || bad_mask_len) { if (bad_key_len) { ds_put_format(ds, "(bad key length %"PRIuSIZE", expected %d)(", - nl_attr_get_size(a), - odp_flow_key_attr_len(nl_attr_type(a))); + nl_attr_get_size(a), expected_len); } format_generic_odp_key(a, ds); - if (bad_mask_len) { + if (ma) { ds_put_char(ds, '/'); - ds_put_format(ds, "(bad mask length %"PRIuSIZE", expected %d)(", - nl_attr_get_size(ma), - odp_flow_key_attr_len(nl_attr_type(ma))); + if (bad_mask_len) { + ds_put_format(ds, "(bad mask length %"PRIuSIZE", expected %d)(", + nl_attr_get_size(ma), expected_len); + } + format_generic_odp_key(ma, ds); } - format_generic_odp_key(ma, ds); ds_put_char(ds, ')'); return; } @@ -1011,6 +1057,8 @@ 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)); @@ -1116,10 +1164,23 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, case OVS_KEY_ATTR_MPLS: { const struct ovs_key_mpls *mpls_key = nl_attr_get(a); const struct ovs_key_mpls *mpls_mask = NULL; + size_t size = nl_attr_get_size(a); + + if (!size || size % sizeof *mpls_key) { + ds_put_format(ds, "(bad key length %"PRIuSIZE")", + nl_attr_get_size(a)); + return; + } if (!is_exact) { mpls_mask = nl_attr_get(ma); + if (nl_attr_get_size(a) != nl_attr_get_size(ma)) { + ds_put_format(ds, "(key length %"PRIuSIZE" != " + "mask length %"PRIuSIZE")", + nl_attr_get_size(a), nl_attr_get_size(ma)); + return; + } } - format_mpls(ds, mpls_key, mpls_mask); + format_mpls(ds, mpls_key, mpls_mask, size / sizeof *mpls_key); break; } @@ -1258,7 +1319,7 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, } else { const struct ovs_key_sctp *sctp_key = nl_attr_get(a); - ds_put_format(ds, "(src=%"PRIu16",dst=%"PRIu16")", + ds_put_format(ds, "src=%"PRIu16",dst=%"PRIu16, ntohs(sctp_key->sctp_src), ntohs(sctp_key->sctp_dst)); } break; @@ -1359,7 +1420,6 @@ format_odp_key_attr(const struct nlattr *a, const struct nlattr *ma, } break; } - case OVS_KEY_ATTR_UNSPEC: case __OVS_KEY_ATTR_MAX: default: @@ -1393,7 +1453,7 @@ generate_all_wildcard_mask(struct ofpbuf *ofp, const struct nlattr *key) nl_msg_end_nested(ofp, nested_mask); } - return ofp->base; + return ofpbuf_base(ofp); } /* Appends to 'ds' a string representation of the 'key_len' bytes of @@ -1591,6 +1651,36 @@ parse_odp_key_mask_attr(const char *s, const struct simap *port_names, } } + { + uint32_t recirc_id; + int n = -1; + + if (ovs_scan(s, "recirc_id(%"SCNi32")%n", &recirc_id, &n)) { + nl_msg_put_u32(key, OVS_KEY_ATTR_RECIRC_ID, recirc_id); + nl_msg_put_u32(mask, OVS_KEY_ATTR_RECIRC_ID, UINT32_MAX); + return n; + } + } + + { + uint32_t dp_hash; + uint32_t dp_hash_mask; + int n = -1; + + if (mask && ovs_scan(s, "dp_hash(%"SCNi32"/%"SCNi32")%n", &dp_hash, + &dp_hash_mask, &n)) { + nl_msg_put_u32(key, OVS_KEY_ATTR_DP_HASH, dp_hash); + nl_msg_put_u32(mask, OVS_KEY_ATTR_DP_HASH, dp_hash_mask); + return n; + } else if (ovs_scan(s, "dp_hash(%"SCNi32")%n", &dp_hash, &n)) { + nl_msg_put_u32(key, OVS_KEY_ATTR_DP_HASH, dp_hash); + if (mask) { + nl_msg_put_u32(mask, OVS_KEY_ATTR_DP_HASH, UINT32_MAX); + } + return n; + } + } + { uint64_t tun_id, tun_id_mask; struct flow_tnl tun_key, tun_key_mask; @@ -2351,7 +2441,7 @@ int odp_flow_from_string(const char *s, const struct simap *port_names, struct ofpbuf *key, struct ofpbuf *mask) { - const size_t old_size = key->size; + const size_t old_size = ofpbuf_size(key); for (;;) { int retval; @@ -2362,7 +2452,7 @@ odp_flow_from_string(const char *s, const struct simap *port_names, retval = parse_odp_key_mask_attr(s, port_names, key, mask); if (retval < 0) { - key->size = old_size; + ofpbuf_set_size(key, old_size); return -retval; } s += retval; @@ -2391,28 +2481,33 @@ ovs_to_odp_frag_mask(uint8_t nw_frag_mask) } static void -odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, - const struct flow *flow, odp_port_t odp_in_port) +odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *flow, + const struct flow *mask, odp_port_t odp_in_port, + size_t max_mpls_depth, bool export_mask) { - bool is_mask; struct ovs_key_ethernet *eth_key; size_t encap; - - /* We assume that if 'data' and 'flow' are not the same, we should - * treat 'data' as a mask. */ - is_mask = (data != flow); + const struct flow *data = export_mask ? mask : flow; nl_msg_put_u32(buf, OVS_KEY_ATTR_PRIORITY, data->skb_priority); - if (flow->tunnel.ip_dst || is_mask) { + if (flow->tunnel.ip_dst || export_mask) { tun_key_to_attr(buf, &data->tunnel); } nl_msg_put_u32(buf, OVS_KEY_ATTR_SKB_MARK, data->pkt_mark); + if (data->recirc_id || (mask && mask->recirc_id)) { + nl_msg_put_u32(buf, OVS_KEY_ATTR_RECIRC_ID, data->recirc_id); + } + + if (data->dp_hash || (mask && mask->dp_hash)) { + nl_msg_put_u32(buf, OVS_KEY_ATTR_DP_HASH, data->dp_hash); + } + /* Add an ingress port attribute if this is a mask or 'odp_in_port' * is not the magical value "ODPP_NONE". */ - if (is_mask || odp_in_port != ODPP_NONE) { + if (export_mask || odp_in_port != ODPP_NONE) { nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, odp_in_port); } @@ -2422,7 +2517,7 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, memcpy(eth_key->eth_dst, data->dl_dst, ETH_ADDR_LEN); if (flow->vlan_tci != htons(0) || flow->dl_type == htons(ETH_TYPE_VLAN)) { - if (is_mask) { + if (export_mask) { nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, OVS_BE16_MAX); } else { nl_msg_put_be16(buf, OVS_KEY_ATTR_ETHERTYPE, htons(ETH_TYPE_VLAN)); @@ -2448,7 +2543,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; @@ -2466,7 +2561,7 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, ipv4_key->ipv4_proto = data->nw_proto; ipv4_key->ipv4_tos = data->nw_tos; ipv4_key->ipv4_ttl = data->nw_ttl; - ipv4_key->ipv4_frag = is_mask ? ovs_to_odp_frag_mask(data->nw_frag) + ipv4_key->ipv4_frag = export_mask ? ovs_to_odp_frag_mask(data->nw_frag) : ovs_to_odp_frag(data->nw_frag); } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) { struct ovs_key_ipv6 *ipv6_key; @@ -2479,7 +2574,7 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, ipv6_key->ipv6_proto = data->nw_proto; ipv6_key->ipv6_tclass = data->nw_tos; ipv6_key->ipv6_hlimit = data->nw_ttl; - ipv6_key->ipv6_frag = is_mask ? ovs_to_odp_frag_mask(data->nw_frag) + ipv6_key->ipv6_frag = export_mask ? ovs_to_odp_frag_mask(data->nw_frag) : ovs_to_odp_frag(data->nw_frag); } else if (flow->dl_type == htons(ETH_TYPE_ARP) || flow->dl_type == htons(ETH_TYPE_RARP)) { @@ -2494,10 +2589,15 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, memcpy(arp_key->arp_tha, data->arp_tha, ETH_ADDR_LEN); } else if (eth_type_mpls(flow->dl_type)) { struct ovs_key_mpls *mpls_key; + int i, n; + n = flow_count_mpls_labels(flow, NULL); + n = MIN(n, max_mpls_depth); mpls_key = nl_msg_put_unspec_uninit(buf, OVS_KEY_ATTR_MPLS, - sizeof *mpls_key); - mpls_key->mpls_lse = data->mpls_lse; + n * sizeof *mpls_key); + for (i = 0; i < n; i++) { + mpls_key[i].mpls_lse = data->mpls_lse[i]; + } } if (is_ip_any(flow) && !(flow->nw_frag & FLOW_NW_FRAG_LATER)) { @@ -2546,7 +2646,7 @@ odp_flow_key_from_flow__(struct ofpbuf *buf, const struct flow *data, if (flow->tp_dst == htons(0) && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) || flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) && - (!is_mask || (data->tp_src == htons(0xffff) && + (!export_mask || (data->tp_src == htons(0xffff) && data->tp_dst == htons(0xffff)))) { struct ovs_key_nd *nd_key; @@ -2577,9 +2677,9 @@ unencap: * capable of being expanded to allow for that much space. */ void odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow, - odp_port_t odp_in_port) + const struct flow *mask, odp_port_t odp_in_port) { - odp_flow_key_from_flow__(buf, flow, flow, odp_in_port); + odp_flow_key_from_flow__(buf, flow, mask, odp_in_port, SIZE_MAX, false); } /* Appends a representation of 'mask' as OVS_KEY_ATTR_* attributes to @@ -2592,9 +2692,11 @@ odp_flow_key_from_flow(struct ofpbuf *buf, const struct flow *flow, * capable of being expanded to allow for that much space. */ void odp_flow_key_from_mask(struct ofpbuf *buf, const struct flow *mask, - const struct flow *flow, uint32_t odp_in_port_mask) + const struct flow *flow, uint32_t odp_in_port_mask, + size_t max_mpls_depth) { - odp_flow_key_from_flow__(buf, mask, flow, u32_to_odp(odp_in_port_mask)); + odp_flow_key_from_flow__(buf, flow, mask, + u32_to_odp(odp_in_port_mask), max_mpls_depth, true); } /* Generate ODP flow key from the given packet metadata */ @@ -2611,8 +2713,8 @@ odp_key_from_pkt_metadata(struct ofpbuf *buf, const struct pkt_metadata *md) /* Add an ingress port attribute if 'odp_in_port' is not the magical * value "ODPP_NONE". */ - if (md->in_port != ODPP_NONE) { - nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, md->in_port); + if (md->in_port.odp_port != ODPP_NONE) { + nl_msg_put_odp_port(buf, OVS_KEY_ATTR_IN_PORT, md->in_port.odp_port); } } @@ -2627,8 +2729,7 @@ odp_key_to_pkt_metadata(const struct nlattr *key, size_t key_len, 1u << OVS_KEY_ATTR_SKB_MARK | 1u << OVS_KEY_ATTR_TUNNEL | 1u << OVS_KEY_ATTR_IN_PORT; - memset(md, 0, sizeof *md); - md->in_port = ODPP_NONE; + *md = PKT_METADATA_INITIALIZER(ODPP_NONE); NL_ATTR_FOR_EACH (nla, left, key, key_len) { uint16_t type = nl_attr_type(nla); @@ -2639,13 +2740,24 @@ odp_key_to_pkt_metadata(const struct nlattr *key, size_t key_len, continue; } - if (type == OVS_KEY_ATTR_PRIORITY) { + switch (type) { + case OVS_KEY_ATTR_RECIRC_ID: + md->recirc_id = nl_attr_get_u32(nla); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_RECIRC_ID); + break; + case OVS_KEY_ATTR_DP_HASH: + md->dp_hash = nl_attr_get_u32(nla); + wanted_attrs &= ~(1u << OVS_KEY_ATTR_DP_HASH); + break; + case OVS_KEY_ATTR_PRIORITY: md->skb_priority = nl_attr_get_u32(nla); wanted_attrs &= ~(1u << OVS_KEY_ATTR_PRIORITY); - } else if (type == OVS_KEY_ATTR_SKB_MARK) { + break; + case OVS_KEY_ATTR_SKB_MARK: md->pkt_mark = nl_attr_get_u32(nla); wanted_attrs &= ~(1u << OVS_KEY_ATTR_SKB_MARK); - } else if (type == OVS_KEY_ATTR_TUNNEL) { + break; + case OVS_KEY_ATTR_TUNNEL: { enum odp_key_fitness res; res = odp_tun_key_from_attr(nla, &md->tunnel); @@ -2654,9 +2766,14 @@ odp_key_to_pkt_metadata(const struct nlattr *key, size_t key_len, } else if (res == ODP_FIT_PERFECT) { wanted_attrs &= ~(1u << OVS_KEY_ATTR_TUNNEL); } - } else if (type == OVS_KEY_ATTR_IN_PORT) { - md->in_port = nl_attr_get_odp_port(nla); + break; + } + case OVS_KEY_ATTR_IN_PORT: + md->in_port.odp_port = nl_attr_get_odp_port(nla); wanted_attrs &= ~(1u << OVS_KEY_ATTR_IN_PORT); + break; + default: + break; } if (!wanted_attrs) { @@ -2850,21 +2967,50 @@ 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)) { + size_t size = nl_attr_get_size(attrs[OVS_KEY_ATTR_MPLS]); + const ovs_be32 *mpls_lse = nl_attr_get(attrs[OVS_KEY_ATTR_MPLS]); + int n = size / sizeof(ovs_be32); + int i; + + if (!size || size % sizeof(ovs_be32)) { + return ODP_FIT_ERROR; + } + if (!is_mask) { expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS); if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS))) { return ODP_FIT_TOO_LITTLE; } - flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]); } else if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_MPLS)) { - flow->mpls_lse = nl_attr_get_be32(attrs[OVS_KEY_ATTR_MPLS]); - - if (flow->mpls_lse != 0 && flow->dl_type != htons(0xffff)) { + if (flow->mpls_lse[0] && flow->dl_type != htons(0xffff)) { return ODP_FIT_ERROR; } expected_attrs |= (UINT64_C(1) << OVS_KEY_ATTR_MPLS); } + + for (i = 0; i < n && i < FLOW_MAX_MPLS_LABELS; i++) { + flow->mpls_lse[i] = mpls_lse[i]; + } + if (n > FLOW_MAX_MPLS_LABELS) { + return ODP_FIT_TOO_MUCH; + } + + if (!is_mask) { + /* BOS may be set only in the innermost label. */ + for (i = 0; i < n - 1; i++) { + if (flow->mpls_lse[i] & htonl(MPLS_BOS_MASK)) { + return ODP_FIT_ERROR; + } + } + + /* BOS must be set in the innermost label. */ + if (n < FLOW_MAX_MPLS_LABELS + && !(flow->mpls_lse[n - 1] & htonl(MPLS_BOS_MASK))) { + return ODP_FIT_TOO_LITTLE; + } + } + goto done; } else if (src_flow->dl_type == htons(ETH_TYPE_IP)) { if (!is_mask) { @@ -3083,7 +3229,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) { @@ -3100,33 +3245,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; + /* Set vlan_tci. + * Remove the TPID from dl_type since it's not the real Ethertype. */ + flow->dl_type = htons(0); + flow->vlan_tci = (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN) + ? nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]) + : htons(0)); + if (!is_mask) { + if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_VLAN))) { + return ODP_FIT_TOO_LITTLE; + } else if (flow->vlan_tci == htons(0)) { + /* Corner case for a truncated 802.1Q header. */ + if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap)) { + return ODP_FIT_TOO_MUCH; + } + return fitness; + } else if (!(flow->vlan_tci & htons(VLAN_CFI))) { + VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is nonzero " + "but CFI bit is not set", ntohs(flow->vlan_tci)); + return ODP_FIT_ERROR; + } } else { - tci = nl_attr_get_be16(attrs[OVS_KEY_ATTR_VLAN]); - if (!is_mask) { - if (tci == htons(0)) { - /* Corner case for a truncated 802.1Q header. */ - if (fitness == ODP_FIT_PERFECT && nl_attr_get_size(encap)) { - return ODP_FIT_TOO_MUCH; - } - return fitness; - } else if (!(tci & htons(VLAN_CFI))) { - VLOG_ERR_RL(&rl, "OVS_KEY_ATTR_VLAN 0x%04"PRIx16" is nonzero " - "but CFI bit is not set", ntohs(tci)); - return ODP_FIT_ERROR; - } + if (!(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) { + return fitness; } - /* Set vlan_tci. - * Remove the TPID from dl_type since it's not the real Ethertype. */ - flow->dl_type = htons(0); - flow->vlan_tci = tci; } - if (is_mask && !(present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_ENCAP))) { - return fitness; - } /* Now parse the encapsulated attributes. */ if (!parse_flow_nlattrs(nl_attr_get(encap), nl_attr_get_size(encap), attrs, &present_attrs, &out_of_range_attr)) { @@ -3165,6 +3309,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 when datapath does not sepcify it. */ + flow->recirc_id = UINT32_MAX; + } + + if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_DP_HASH)) { + flow->dp_hash = nl_attr_get_u32(attrs[OVS_KEY_ATTR_DP_HASH]); + expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_DP_HASH; + } if (present_attrs & (UINT64_C(1) << OVS_KEY_ATTR_PRIORITY)) { flow->skb_priority = nl_attr_get_u32(attrs[OVS_KEY_ATTR_PRIORITY]); expected_attrs |= UINT64_C(1) << OVS_KEY_ATTR_PRIORITY; @@ -3215,8 +3371,9 @@ 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); } @@ -3298,7 +3455,7 @@ odp_put_userspace_action(uint32_t pid, offset = nl_msg_start_nested(odp_actions, OVS_ACTION_ATTR_USERSPACE); nl_msg_put_u32(odp_actions, OVS_USERSPACE_ATTR_PID, pid); if (userdata) { - userdata_ofs = odp_actions->size + NLA_HDRLEN; + userdata_ofs = ofpbuf_size(odp_actions) + NLA_HDRLEN; /* The OVS kernel module before OVS 1.11 and the upstream Linux kernel * module before Linux 3.10 required the userdata to be exactly 8 bytes @@ -3395,19 +3552,26 @@ commit_set_ether_addr_action(const struct flow *flow, struct flow *base, } static void -commit_vlan_action(ovs_be16 vlan_tci, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc) +pop_vlan(struct flow *base, + struct ofpbuf *odp_actions, struct flow_wildcards *wc) { - if (base->vlan_tci == vlan_tci) { - return; - } - memset(&wc->masks.vlan_tci, 0xff, sizeof wc->masks.vlan_tci); if (base->vlan_tci & htons(VLAN_CFI)) { nl_msg_put_flag(odp_actions, OVS_ACTION_ATTR_POP_VLAN); + base->vlan_tci = 0; } +} +static void +commit_vlan_action(ovs_be16 vlan_tci, struct flow *base, + struct ofpbuf *odp_actions, struct flow_wildcards *wc) +{ + if (base->vlan_tci == vlan_tci) { + return; + } + + pop_vlan(base, odp_actions, wc); if (vlan_tci & htons(VLAN_CFI)) { struct ovs_action_push_vlan vlan; @@ -3421,43 +3585,68 @@ commit_vlan_action(ovs_be16 vlan_tci, struct flow *base, static void commit_mpls_action(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc, - int *mpls_depth_delta) + struct ofpbuf *odp_actions, struct flow_wildcards *wc) { - if (flow->mpls_lse == base->mpls_lse && !*mpls_depth_delta) { - return; + int base_n = flow_count_mpls_labels(base, wc); + int flow_n = flow_count_mpls_labels(flow, wc); + int common_n = flow_count_common_mpls_labels(flow, flow_n, base, base_n, + wc); + + while (base_n > common_n) { + if (base_n - 1 == common_n && flow_n > common_n) { + /* If there is only one more LSE in base than there are common + * between base and flow; and flow has at least one more LSE than + * is common then the topmost LSE of base may be updated using + * set */ + struct ovs_key_mpls mpls_key; + + mpls_key.mpls_lse = flow->mpls_lse[flow_n - base_n]; + commit_set_action(odp_actions, OVS_KEY_ATTR_MPLS, + &mpls_key, sizeof mpls_key); + flow_set_mpls_lse(base, 0, mpls_key.mpls_lse); + common_n++; + } else { + /* Otherwise, if there more LSEs in base than are common between + * base and flow then pop the topmost one. */ + ovs_be16 dl_type; + bool popped; + + /* If all the LSEs are to be popped and this is not the outermost + * LSE then use ETH_TYPE_MPLS as the ethertype parameter of the + * POP_MPLS action instead of flow->dl_type. + * + * This is because the POP_MPLS action requires its ethertype + * argument to be an MPLS ethernet type but in this case + * flow->dl_type will be a non-MPLS ethernet type. + * + * When the final POP_MPLS action occurs it use flow->dl_type and + * the and the resulting packet will have the desired dl_type. */ + if ((!eth_type_mpls(flow->dl_type)) && base_n > 1) { + dl_type = htons(ETH_TYPE_MPLS); + } else { + dl_type = flow->dl_type; + } + nl_msg_put_be16(odp_actions, OVS_ACTION_ATTR_POP_MPLS, dl_type); + popped = flow_pop_mpls(base, base_n, flow->dl_type, wc); + ovs_assert(popped); + base_n--; + } } - memset(&wc->masks.mpls_lse, 0xff, sizeof wc->masks.mpls_lse); - - switch (*mpls_depth_delta) { - case -1: - nl_msg_put_be16(odp_actions, OVS_ACTION_ATTR_POP_MPLS, flow->dl_type); - break; - case 1: { + /* If, after the above popping and setting, there are more LSEs in flow + * than base then some LSEs need to be pushed. */ + while (base_n < flow_n) { struct ovs_action_push_mpls *mpls; - mpls = nl_msg_put_unspec_zero(odp_actions, OVS_ACTION_ATTR_PUSH_MPLS, + mpls = nl_msg_put_unspec_zero(odp_actions, + OVS_ACTION_ATTR_PUSH_MPLS, sizeof *mpls); mpls->mpls_ethertype = flow->dl_type; - mpls->mpls_lse = flow->mpls_lse; - break; + mpls->mpls_lse = flow->mpls_lse[flow_n - base_n - 1]; + flow_push_mpls(base, base_n, mpls->mpls_ethertype, wc); + flow_set_mpls_lse(base, 0, mpls->mpls_lse); + base_n++; } - case 0: { - struct ovs_key_mpls mpls_key; - - mpls_key.mpls_lse = flow->mpls_lse; - commit_set_action(odp_actions, OVS_KEY_ATTR_MPLS, - &mpls_key, sizeof(mpls_key)); - break; - } - default: - OVS_NOT_REACHED(); - } - - base->dl_type = flow->dl_type; - base->mpls_lse = flow->mpls_lse; - *mpls_depth_delta = 0; } static void @@ -3678,20 +3867,15 @@ commit_set_pkt_mark_action(const struct flow *flow, struct flow *base, * slow path, if there is one, otherwise 0. */ enum slow_path_reason commit_odp_actions(const struct flow *flow, struct flow *base, - struct ofpbuf *odp_actions, struct flow_wildcards *wc, - int *mpls_depth_delta) + struct ofpbuf *odp_actions, struct flow_wildcards *wc) { enum slow_path_reason slow; commit_set_ether_addr_action(flow, base, odp_actions, wc); - commit_vlan_action(flow->vlan_tci, base, odp_actions, wc); slow = commit_set_nw_action(flow, base, odp_actions, wc); commit_set_port_action(flow, base, odp_actions, wc); - /* Committing MPLS actions should occur after committing nw and port - * actions. This is because committing MPLS actions may alter a packet so - * that it is no longer IP and thus nw and port actions are no longer valid. - */ - commit_mpls_action(flow, base, odp_actions, wc, mpls_depth_delta); + commit_mpls_action(flow, base, odp_actions, wc); + commit_vlan_action(flow->vlan_tci, base, odp_actions, wc); commit_set_priority_action(flow, base, odp_actions, wc); commit_set_pkt_mark_action(flow, base, odp_actions, wc);