X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnx-match.c;h=e111000fc7be580682b4380402577aba186cf942;hb=ec9f40dce11c7e81bc41d42e3bbfaaf8287165ce;hp=0f676926d96b0d76a985862b0875dc2eb175eb97;hpb=e878338bf1409f0dd6d23cb57822a2c4c1a69e0f;p=sliver-openvswitch.git diff --git a/lib/nx-match.c b/lib/nx-match.c index 0f676926d..e111000fc 100644 --- a/lib/nx-match.c +++ b/lib/nx-match.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010, 2011, 2012 Nicira, Inc. + * Copyright (c) 2010, 2011, 2012, 2013 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -90,17 +90,40 @@ nx_entry_ok(const void *p, unsigned int match_len) return header; } +/* Given NXM/OXM value 'value' and mask 'mask', each 'width' bytes long, + * checks for any 1-bit in the value where there is a 0-bit in the mask. If it + * finds one, logs a warning. */ +static void +check_mask_consistency(const uint8_t *p, const struct mf_field *mf) +{ + unsigned int width = mf->n_bytes; + const uint8_t *value = p + 4; + const uint8_t *mask = p + 4 + width; + unsigned int i; + + for (i = 0; i < width; i++) { + if (value[i] & ~mask[i]) { + if (!VLOG_DROP_WARN(&rl)) { + char *s = nx_match_to_string(p, width * 2 + 4); + VLOG_WARN_RL(&rl, "NXM/OXM entry %s has 1-bits in value for " + "bits wildcarded by the mask. (Future versions " + "of OVS may report this as an OpenFlow error.)", + s); + break; + } + } + } +} + static enum ofperr -nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, - uint16_t priority, struct cls_rule *rule, - ovs_be64 *cookie, ovs_be64 *cookie_mask) +nx_pull_raw(const uint8_t *p, unsigned int match_len, bool strict, + struct match *match, ovs_be64 *cookie, ovs_be64 *cookie_mask) { uint32_t header; - uint8_t *p; - assert((cookie != NULL) == (cookie_mask != NULL)); + ovs_assert((cookie != NULL) == (cookie_mask != NULL)); - cls_rule_init_catchall(rule, priority); + match_init_catchall(match); if (cookie) { *cookie = *cookie_mask = htonll(0); } @@ -108,14 +131,6 @@ nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, return 0; } - p = ofpbuf_try_pull(b, ROUND_UP(match_len, 8)); - if (!p) { - VLOG_DBG_RL(&rl, "nx_match length %u, rounded up to a " - "multiple of 8, is longer than space in message (max " - "length %zu)", match_len, b->size); - return OFPERR_OFPBMC_BAD_LEN; - } - for (; (header = nx_entry_ok(p, match_len)) != 0; p += 4 + NXM_LENGTH(header), match_len -= 4 + NXM_LENGTH(header)) { @@ -129,11 +144,11 @@ nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, } else { continue; } - } else if (!mf_are_prereqs_ok(mf, &rule->flow)) { + } else if (!mf_are_prereqs_ok(mf, &match->flow)) { error = OFPERR_OFPBMC_BAD_PREREQ; - } else if (!mf_is_all_wild(mf, &rule->wc)) { + } else if (!mf_is_all_wild(mf, &match->wc)) { error = OFPERR_OFPBMC_DUP_FIELD; - } else if (header != OXM_OF_IN_PORT) { + } else { unsigned int width = mf->n_bytes; union mf_value value; @@ -142,7 +157,7 @@ nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, error = OFPERR_OFPBMC_BAD_VALUE; } else if (!NXM_HASMASK(header)) { error = 0; - mf_set_value(mf, &value, rule); + mf_set_value(mf, &value, match); } else { union mf_value mask; @@ -151,20 +166,10 @@ nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, error = OFPERR_OFPBMC_BAD_MASK; } else { error = 0; - mf_set(mf, &value, &mask, rule); + check_mask_consistency(p, mf); + mf_set(mf, &value, &mask, match); } } - } else { - /* Special case for 32bit ports when using OXM, - * ports are 16 bits wide otherwise. */ - ovs_be32 port_of11; - uint16_t port; - - memcpy(&port_of11, p + 4, sizeof port_of11); - error = ofputil_port_from_ofp11(port_of11, &port); - if (!error) { - cls_rule_set_in_port(rule, port); - } } /* Check if the match is for a cookie rather than a classifier rule. */ @@ -198,33 +203,101 @@ nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, return match_len ? OFPERR_OFPBMC_BAD_LEN : 0; } +static enum ofperr +nx_pull_match__(struct ofpbuf *b, unsigned int match_len, bool strict, + struct match *match, + ovs_be64 *cookie, ovs_be64 *cookie_mask) +{ + uint8_t *p = NULL; + + if (match_len) { + p = ofpbuf_try_pull(b, ROUND_UP(match_len, 8)); + if (!p) { + VLOG_DBG_RL(&rl, "nx_match length %u, rounded up to a " + "multiple of 8, is longer than space in message (max " + "length %zu)", match_len, b->size); + return OFPERR_OFPBMC_BAD_LEN; + } + } + + return nx_pull_raw(p, match_len, strict, match, cookie, cookie_mask); +} + /* Parses the nx_match formatted match description in 'b' with length - * 'match_len'. The results are stored in 'rule', which is initialized with - * 'priority'. If 'cookie' and 'cookie_mask' contain valid pointers, then the - * cookie and mask will be stored in them if a "NXM_NX_COOKIE*" match is - * defined. Otherwise, 0 is stored in both. + * 'match_len'. Stores the results in 'match'. If 'cookie' and 'cookie_mask' + * are valid pointers, then stores the cookie and mask in them if 'b' contains + * a "NXM_NX_COOKIE*" match. Otherwise, stores 0 in both. * - * Fails with an error when encountering unknown NXM headers. + * Fails with an error upon encountering an unknown NXM header. * * Returns 0 if successful, otherwise an OpenFlow error code. */ enum ofperr -nx_pull_match(struct ofpbuf *b, unsigned int match_len, - uint16_t priority, struct cls_rule *rule, +nx_pull_match(struct ofpbuf *b, unsigned int match_len, struct match *match, ovs_be64 *cookie, ovs_be64 *cookie_mask) { - return nx_pull_match__(b, match_len, true, priority, rule, cookie, - cookie_mask); + return nx_pull_match__(b, match_len, true, match, cookie, cookie_mask); } -/* Behaves the same as nx_pull_match() with one exception. Skips over unknown - * NXM headers instead of failing with an error when they are encountered. */ +/* Behaves the same as nx_pull_match(), but skips over unknown NXM headers, + * instead of failing with an error. */ enum ofperr nx_pull_match_loose(struct ofpbuf *b, unsigned int match_len, - uint16_t priority, struct cls_rule *rule, + struct match *match, ovs_be64 *cookie, ovs_be64 *cookie_mask) { - return nx_pull_match__(b, match_len, false, priority, rule, cookie, - cookie_mask); + return nx_pull_match__(b, match_len, false, match, cookie, cookie_mask); +} + +static enum ofperr +oxm_pull_match__(struct ofpbuf *b, bool strict, struct match *match) +{ + struct ofp11_match_header *omh = b->data; + uint8_t *p; + uint16_t match_len; + + if (b->size < sizeof *omh) { + return OFPERR_OFPBMC_BAD_LEN; + } + + match_len = ntohs(omh->length); + if (match_len < sizeof *omh) { + return OFPERR_OFPBMC_BAD_LEN; + } + + if (omh->type != htons(OFPMT_OXM)) { + return OFPERR_OFPBMC_BAD_TYPE; + } + + p = ofpbuf_try_pull(b, ROUND_UP(match_len, 8)); + if (!p) { + VLOG_DBG_RL(&rl, "oxm length %u, rounded up to a " + "multiple of 8, is longer than space in message (max " + "length %zu)", match_len, b->size); + return OFPERR_OFPBMC_BAD_LEN; + } + + return nx_pull_raw(p + sizeof *omh, match_len - sizeof *omh, + strict, match, NULL, NULL); +} + +/* Parses the oxm formatted match description preceded by a struct ofp11_match + * in 'b' with length 'match_len'. Stores the result in 'match'. + * + * Fails with an error when encountering unknown OXM headers. + * + * Returns 0 if successful, otherwise an OpenFlow error code. */ +enum ofperr +oxm_pull_match(struct ofpbuf *b, struct match *match) +{ + return oxm_pull_match__(b, true, match); +} + +/* Behaves the same as oxm_pull_match() with one exception. Skips over unknown + * PXM headers instead of failing with an error when they are encountered. */ +enum ofperr +oxm_pull_match_loose(struct ofpbuf *b, struct match *match) +{ + return oxm_pull_match__(b, false, match); } /* nx_put_match() and helpers. @@ -403,10 +476,10 @@ nxm_put_ipv6(struct ofpbuf *b, uint32_t header, } static void -nxm_put_frag(struct ofpbuf *b, const struct cls_rule *cr) +nxm_put_frag(struct ofpbuf *b, const struct match *match) { - uint8_t nw_frag = cr->flow.nw_frag; - uint8_t nw_frag_mask = cr->wc.nw_frag_mask; + uint8_t nw_frag = match->flow.nw_frag; + uint8_t nw_frag_mask = match->wc.masks.nw_frag; switch (nw_frag_mask) { case 0: @@ -424,79 +497,78 @@ nxm_put_frag(struct ofpbuf *b, const struct cls_rule *cr) } static void -nxm_put_ip(struct ofpbuf *b, const struct cls_rule *cr, +nxm_put_ip(struct ofpbuf *b, const struct match *match, uint8_t icmp_proto, uint32_t icmp_type, uint32_t icmp_code, bool oxm) { - const flow_wildcards_t wc = cr->wc.wildcards; - const struct flow *flow = &cr->flow; + const struct flow *flow = &match->flow; - nxm_put_frag(b, cr); + nxm_put_frag(b, match); - if (!(wc & FWW_NW_DSCP)) { - nxm_put_8(b, oxm ? OXM_OF_IP_DSCP : NXM_OF_IP_TOS, - flow->nw_tos & IP_DSCP_MASK); + if (match->wc.masks.nw_tos & IP_DSCP_MASK) { + if (oxm) { + nxm_put_8(b, OXM_OF_IP_DSCP, flow->nw_tos >> 2); + } else { + nxm_put_8(b, NXM_OF_IP_TOS, flow->nw_tos & IP_DSCP_MASK); + } } - if (!(wc & FWW_NW_ECN)) { + if (match->wc.masks.nw_tos & IP_ECN_MASK) { nxm_put_8(b, oxm ? OXM_OF_IP_ECN : NXM_NX_IP_ECN, flow->nw_tos & IP_ECN_MASK); } - if (!oxm && !(wc & FWW_NW_TTL)) { + if (!oxm && match->wc.masks.nw_ttl) { nxm_put_8(b, NXM_NX_IP_TTL, flow->nw_ttl); } - if (!(wc & FWW_NW_PROTO)) { + if (match->wc.masks.nw_proto) { nxm_put_8(b, oxm ? OXM_OF_IP_PROTO : NXM_OF_IP_PROTO, flow->nw_proto); if (flow->nw_proto == IPPROTO_TCP) { nxm_put_16m(b, oxm ? OXM_OF_TCP_SRC : NXM_OF_TCP_SRC, - flow->tp_src, cr->wc.tp_src_mask); + flow->tp_src, match->wc.masks.tp_src); nxm_put_16m(b, oxm ? OXM_OF_TCP_DST : NXM_OF_TCP_DST, - flow->tp_dst, cr->wc.tp_dst_mask); + flow->tp_dst, match->wc.masks.tp_dst); } else if (flow->nw_proto == IPPROTO_UDP) { nxm_put_16m(b, oxm ? OXM_OF_UDP_SRC : NXM_OF_UDP_SRC, - flow->tp_src, cr->wc.tp_src_mask); + flow->tp_src, match->wc.masks.tp_src); nxm_put_16m(b, oxm ? OXM_OF_UDP_DST : NXM_OF_UDP_DST, - flow->tp_dst, cr->wc.tp_dst_mask); + flow->tp_dst, match->wc.masks.tp_dst); } else if (flow->nw_proto == icmp_proto) { - if (cr->wc.tp_src_mask) { + if (match->wc.masks.tp_src) { nxm_put_8(b, icmp_type, ntohs(flow->tp_src)); } - if (cr->wc.tp_dst_mask) { + if (match->wc.masks.tp_dst) { nxm_put_8(b, icmp_code, ntohs(flow->tp_dst)); } } } } -/* Appends to 'b' the nx_match format that expresses 'cr' (except for - * 'cr->priority', because priority is not part of nx_match), plus enough - * zero bytes to pad the nx_match out to a multiple of 8. For Flow Mod - * and Flow Stats Requests messages, a 'cookie' and 'cookie_mask' may be - * supplied. Otherwise, 'cookie_mask' should be zero. +/* Appends to 'b' the nx_match format that expresses 'match'. For Flow Mod and + * Flow Stats Requests messages, a 'cookie' and 'cookie_mask' may be supplied. + * Otherwise, 'cookie_mask' should be zero. * * This function can cause 'b''s data to be reallocated. * * Returns the number of bytes appended to 'b', excluding padding. * - * If 'cr' is a catch-all rule that matches every packet, then this function + * If 'match' is a catch-all rule that matches every packet, then this function * appends nothing to 'b' and returns 0. */ -int -nx_put_match(struct ofpbuf *b, bool oxm, const struct cls_rule *cr, - ovs_be64 cookie, ovs_be64 cookie_mask) +static int +nx_put_raw(struct ofpbuf *b, bool oxm, const struct match *match, + ovs_be64 cookie, ovs_be64 cookie_mask) { - const flow_wildcards_t wc = cr->wc.wildcards; - const struct flow *flow = &cr->flow; + const struct flow *flow = &match->flow; const size_t start_len = b->size; int match_len; int i; - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 14); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); /* Metadata. */ - if (!(wc & FWW_IN_PORT)) { + if (match->wc.masks.in_port) { uint16_t in_port = flow->in_port; if (oxm) { nxm_put_32(b, OXM_OF_IN_PORT, ofputil_port_to_ofp11(in_port)); @@ -507,91 +579,177 @@ nx_put_match(struct ofpbuf *b, bool oxm, const struct cls_rule *cr, /* Ethernet. */ nxm_put_eth_masked(b, oxm ? OXM_OF_ETH_SRC : NXM_OF_ETH_SRC, - flow->dl_src, cr->wc.dl_src_mask); + flow->dl_src, match->wc.masks.dl_src); nxm_put_eth_masked(b, oxm ? OXM_OF_ETH_DST : NXM_OF_ETH_DST, - flow->dl_dst, cr->wc.dl_dst_mask); - if (!(wc & FWW_DL_TYPE)) { - nxm_put_16(b, oxm ? OXM_OF_ETH_TYPE : NXM_OF_ETH_TYPE, - ofputil_dl_type_to_openflow(flow->dl_type)); + flow->dl_dst, match->wc.masks.dl_dst); + nxm_put_16m(b, oxm ? OXM_OF_ETH_TYPE : NXM_OF_ETH_TYPE, + ofputil_dl_type_to_openflow(flow->dl_type), + match->wc.masks.dl_type); + + /* 802.1Q. */ + if (oxm) { + ovs_be16 VID_CFI_MASK = htons(VLAN_VID_MASK | VLAN_CFI); + ovs_be16 vid = flow->vlan_tci & VID_CFI_MASK; + ovs_be16 mask = match->wc.masks.vlan_tci & VID_CFI_MASK; + + if (mask == htons(VLAN_VID_MASK | VLAN_CFI)) { + nxm_put_16(b, OXM_OF_VLAN_VID, vid); + } else if (mask) { + nxm_put_16m(b, OXM_OF_VLAN_VID, vid, mask); + } + + if (vid && vlan_tci_to_pcp(match->wc.masks.vlan_tci)) { + nxm_put_8(b, OXM_OF_VLAN_PCP, vlan_tci_to_pcp(flow->vlan_tci)); + } + + } else { + nxm_put_16m(b, NXM_OF_VLAN_TCI, flow->vlan_tci, + match->wc.masks.vlan_tci); } - /* 802.1Q. - * - * XXX missing OXM support */ - nxm_put_16m(b, NXM_OF_VLAN_TCI, flow->vlan_tci, cr->wc.vlan_tci_mask); + /* MPLS. */ + if (eth_type_mpls(flow->dl_type)) { + if (match->wc.masks.mpls_lse & htonl(MPLS_TC_MASK)) { + nxm_put_8(b, OXM_OF_MPLS_TC, mpls_lse_to_tc(flow->mpls_lse)); + } + + if (match->wc.masks.mpls_lse & htonl(MPLS_BOS_MASK)) { + nxm_put_8(b, OXM_OF_MPLS_BOS, mpls_lse_to_bos(flow->mpls_lse)); + } + + if (match->wc.masks.mpls_lse & htonl(MPLS_LABEL_MASK)) { + nxm_put_32(b, OXM_OF_MPLS_LABEL, + htonl(mpls_lse_to_label(flow->mpls_lse))); + } + } /* L3. */ - if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_IP)) { + if (flow->dl_type == htons(ETH_TYPE_IP)) { /* IP. */ nxm_put_32m(b, oxm ? OXM_OF_IPV4_SRC : NXM_OF_IP_SRC, - flow->nw_src, cr->wc.nw_src_mask); + flow->nw_src, match->wc.masks.nw_src); nxm_put_32m(b, oxm ? OXM_OF_IPV4_DST : NXM_OF_IP_DST, - flow->nw_dst, cr->wc.nw_dst_mask); - nxm_put_ip(b, cr, IPPROTO_ICMP, + flow->nw_dst, match->wc.masks.nw_dst); + nxm_put_ip(b, match, IPPROTO_ICMP, oxm ? OXM_OF_ICMPV4_TYPE : NXM_OF_ICMP_TYPE, oxm ? OXM_OF_ICMPV4_CODE : NXM_OF_ICMP_CODE, oxm); - } else if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_IPV6)) { + } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) { /* IPv6. */ nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_SRC : NXM_NX_IPV6_SRC, - &flow->ipv6_src, &cr->wc.ipv6_src_mask); + &flow->ipv6_src, &match->wc.masks.ipv6_src); nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_DST : NXM_NX_IPV6_DST, - &flow->ipv6_dst, &cr->wc.ipv6_dst_mask); - nxm_put_ip(b, cr, IPPROTO_ICMPV6, + &flow->ipv6_dst, &match->wc.masks.ipv6_dst); + nxm_put_ip(b, match, IPPROTO_ICMPV6, oxm ? OXM_OF_ICMPV6_TYPE : NXM_NX_ICMPV6_TYPE, oxm ? OXM_OF_ICMPV6_CODE : NXM_NX_ICMPV6_CODE, oxm); nxm_put_32m(b, oxm ? OXM_OF_IPV6_FLABEL : NXM_NX_IPV6_LABEL, - flow->ipv6_label, cr->wc.ipv6_label_mask); + flow->ipv6_label, match->wc.masks.ipv6_label); if (flow->nw_proto == IPPROTO_ICMPV6 && (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) || flow->tp_src == htons(ND_NEIGHBOR_ADVERT))) { nxm_put_ipv6(b, oxm ? OXM_OF_IPV6_ND_TARGET : NXM_NX_ND_TARGET, - &flow->nd_target, &cr->wc.nd_target_mask); + &flow->nd_target, &match->wc.masks.nd_target); if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)) { nxm_put_eth_masked(b, oxm ? OXM_OF_IPV6_ND_SLL : NXM_NX_ND_SLL, - flow->arp_sha, cr->wc.arp_sha_mask); + flow->arp_sha, match->wc.masks.arp_sha); } if (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) { nxm_put_eth_masked(b, oxm ? OXM_OF_IPV6_ND_TLL : NXM_NX_ND_TLL, - flow->arp_tha, cr->wc.arp_tha_mask); + flow->arp_tha, match->wc.masks.arp_tha); } } - } else if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_ARP)) { + } else if (flow->dl_type == htons(ETH_TYPE_ARP) || + flow->dl_type == htons(ETH_TYPE_RARP)) { /* ARP. */ - if (!(wc & FWW_NW_PROTO)) { + if (match->wc.masks.nw_proto) { nxm_put_16(b, oxm ? OXM_OF_ARP_OP : NXM_OF_ARP_OP, htons(flow->nw_proto)); } nxm_put_32m(b, oxm ? OXM_OF_ARP_SPA : NXM_OF_ARP_SPA, - flow->nw_src, cr->wc.nw_src_mask); + flow->nw_src, match->wc.masks.nw_src); nxm_put_32m(b, oxm ? OXM_OF_ARP_TPA : NXM_OF_ARP_TPA, - flow->nw_dst, cr->wc.nw_dst_mask); + flow->nw_dst, match->wc.masks.nw_dst); nxm_put_eth_masked(b, oxm ? OXM_OF_ARP_SHA : NXM_NX_ARP_SHA, - flow->arp_sha, cr->wc.arp_sha_mask); + flow->arp_sha, match->wc.masks.arp_sha); nxm_put_eth_masked(b, oxm ? OXM_OF_ARP_THA : NXM_NX_ARP_THA, - flow->arp_tha, cr->wc.arp_tha_mask); + flow->arp_tha, match->wc.masks.arp_tha); } /* Tunnel ID. */ - nxm_put_64m(b, NXM_NX_TUN_ID, flow->tun_id, cr->wc.tun_id_mask); + nxm_put_64m(b, oxm ? OXM_OF_TUNNEL_ID : NXM_NX_TUN_ID, + flow->tunnel.tun_id, match->wc.masks.tunnel.tun_id); + + /* Other tunnel metadata. */ + nxm_put_32m(b, NXM_NX_TUN_IPV4_SRC, + flow->tunnel.ip_src, match->wc.masks.tunnel.ip_src); + nxm_put_32m(b, NXM_NX_TUN_IPV4_DST, + flow->tunnel.ip_dst, match->wc.masks.tunnel.ip_dst); /* Registers. */ for (i = 0; i < FLOW_N_REGS; i++) { nxm_put_32m(b, NXM_NX_REG(i), - htonl(flow->regs[i]), htonl(cr->wc.reg_masks[i])); + htonl(flow->regs[i]), htonl(match->wc.masks.regs[i])); } /* OpenFlow 1.1+ Metadata. */ - nxm_put_64m(b, OXM_OF_METADATA, flow->metadata, cr->wc.metadata_mask); + nxm_put_64m(b, OXM_OF_METADATA, flow->metadata, match->wc.masks.metadata); /* Cookie. */ nxm_put_64m(b, NXM_NX_COOKIE, cookie, cookie_mask); match_len = b->size - start_len; + return match_len; +} + +/* Appends to 'b' the nx_match format that expresses 'match', plus enough zero + * bytes to pad the nx_match out to a multiple of 8. For Flow Mod and Flow + * Stats Requests messages, a 'cookie' and 'cookie_mask' may be supplied. + * Otherwise, 'cookie_mask' should be zero. + * + * This function can cause 'b''s data to be reallocated. + * + * Returns the number of bytes appended to 'b', excluding padding. The return + * value can be zero if it appended nothing at all to 'b' (which happens if + * 'cr' is a catch-all rule that matches every packet). */ +int +nx_put_match(struct ofpbuf *b, const struct match *match, + ovs_be64 cookie, ovs_be64 cookie_mask) +{ + int match_len = nx_put_raw(b, false, match, cookie, cookie_mask); + ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); return match_len; } + + +/* Appends to 'b' an struct ofp11_match_header followed by the oxm format that + * expresses 'cr', plus enough zero bytes to pad the data appended out to a + * multiple of 8. + * + * This function can cause 'b''s data to be reallocated. + * + * Returns the number of bytes appended to 'b', excluding the padding. Never + * returns zero. */ +int +oxm_put_match(struct ofpbuf *b, const struct match *match) +{ + int match_len; + struct ofp11_match_header *omh; + size_t start_len = b->size; + ovs_be64 cookie = htonll(0), cookie_mask = htonll(0); + + ofpbuf_put_uninit(b, sizeof *omh); + match_len = nx_put_raw(b, true, match, cookie, cookie_mask) + sizeof *omh; + ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); + + omh = (struct ofp11_match_header *)((char *)b->data + start_len); + omh->type = htons(OFPMT_OXM); + omh->length = htons(match_len); + + return match_len; +} /* nx_match_to_string() and helpers. */ @@ -648,6 +806,43 @@ nx_match_to_string(const uint8_t *p, unsigned int match_len) return ds_steal_cstr(&s); } +char * +oxm_match_to_string(const uint8_t *p, unsigned int match_len) +{ + const struct ofp11_match_header *omh = (struct ofp11_match_header *)p; + uint16_t match_len_; + struct ds s; + + ds_init(&s); + + if (match_len < sizeof *omh) { + ds_put_format(&s, "", match_len); + goto err; + } + + if (omh->type != htons(OFPMT_OXM)) { + ds_put_format(&s, "", ntohs(omh->type)); + goto err; + } + + match_len_ = ntohs(omh->length); + if (match_len_ < sizeof *omh) { + ds_put_format(&s, "", match_len_); + goto err; + } + + if (match_len_ != match_len) { + ds_put_format(&s, "", + match_len_, match_len); + goto err; + } + + return nx_match_to_string(p + sizeof *omh, match_len - sizeof *omh); + +err: + return ds_steal_cstr(&s); +} + static void format_nxm_field_name(struct ds *s, uint32_t header) { @@ -724,12 +919,11 @@ parse_nxm_field_name(const char *name, int name_len) /* nx_match_from_string(). */ -int -nx_match_from_string(const char *s, struct ofpbuf *b) +static int +nx_match_from_string_raw(const char *s, struct ofpbuf *b) { const char *full_s = s; const size_t start_len = b->size; - int match_len; if (!strcmp(s, "")) { /* Ensure that 'b->data' isn't actually null. */ @@ -781,8 +975,32 @@ nx_match_from_string(const char *s, struct ofpbuf *b) s++; } - match_len = b->size - start_len; + return b->size - start_len; +} + +int +nx_match_from_string(const char *s, struct ofpbuf *b) +{ + int match_len = nx_match_from_string_raw(s, b); + ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); + return match_len; +} + +int +oxm_match_from_string(const char *s, struct ofpbuf *b) +{ + int match_len; + struct ofp11_match_header *omh; + size_t start_len = b->size; + + ofpbuf_put_uninit(b, sizeof *omh); + match_len = nx_match_from_string_raw(s, b) + sizeof *omh; ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len); + + omh = (struct ofp11_match_header *)((char *)b->data + start_len); + omh->type = htons(OFPMT_OXM); + omh->length = htons(match_len); + return match_len; } @@ -812,8 +1030,8 @@ void nxm_parse_reg_load(struct ofpact_reg_load *load, const char *s) { const char *full_s = s; + uint64_t value = strtoull(s, (char **) &s, 0); - load->value = strtoull(s, (char **) &s, 0); if (strncmp(s, "->", 2)) { ovs_fatal(0, "%s: missing `->' following value", full_s); } @@ -823,10 +1041,13 @@ nxm_parse_reg_load(struct ofpact_reg_load *load, const char *s) ovs_fatal(0, "%s: trailing garbage following destination", full_s); } - if (load->dst.n_bits < 64 && (load->value >> load->dst.n_bits) != 0) { + if (load->dst.n_bits < 64 && (value >> load->dst.n_bits) != 0) { ovs_fatal(0, "%s: value %"PRIu64" does not fit into %d bits", - full_s, load->value, load->dst.n_bits); + full_s, value, load->dst.n_bits); } + + load->subvalue.be64[0] = htonll(0); + load->subvalue.be64[1] = htonll(value); } /* nxm_format_reg_move(), nxm_format_reg_load(). */ @@ -840,11 +1061,38 @@ nxm_format_reg_move(const struct ofpact_reg_move *move, struct ds *s) mf_format_subfield(&move->dst, s); } +static void +set_field_format(const struct ofpact_reg_load *load, struct ds *s) +{ + const struct mf_field *mf = load->dst.field; + union mf_value value; + + ovs_assert(load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD); + ds_put_format(s, "set_field:"); + memset(&value, 0, sizeof value); + bitwise_copy(&load->subvalue, sizeof load->subvalue, 0, + &value, mf->n_bytes, 0, load->dst.n_bits); + mf_format(mf, &value, NULL, s); + ds_put_format(s, "->%s", mf->name); +} + +static void +load_format(const struct ofpact_reg_load *load, struct ds *s) +{ + ds_put_cstr(s, "load:"); + mf_format_subvalue(&load->subvalue, s); + ds_put_cstr(s, "->"); + mf_format_subfield(&load->dst, s); +} + void nxm_format_reg_load(const struct ofpact_reg_load *load, struct ds *s) { - ds_put_format(s, "load:%#"PRIx64"->", load->value); - mf_format_subfield(&load->dst, s); + if (load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD) { + set_field_format(load, s); + } else { + load_format(load, s); + } } enum ofperr @@ -874,16 +1122,49 @@ nxm_reg_load_from_openflow(const struct nx_action_reg_load *narl, load->dst.field = mf_from_nxm_header(ntohl(narl->dst)); load->dst.ofs = nxm_decode_ofs(narl->ofs_nbits); load->dst.n_bits = nxm_decode_n_bits(narl->ofs_nbits); - load->value = ntohll(narl->value); + load->subvalue.be64[1] = narl->value; /* Reject 'narl' if a bit numbered 'n_bits' or higher is set to 1 in * narl->value. */ - if (load->dst.n_bits < 64 && load->value >> load->dst.n_bits) { + if (load->dst.n_bits < 64 && + ntohll(narl->value) >> load->dst.n_bits) { return OFPERR_OFPBAC_BAD_ARGUMENT; } return nxm_reg_load_check(load, NULL); } + +enum ofperr +nxm_reg_load_from_openflow12_set_field( + const struct ofp12_action_set_field * oasf, struct ofpbuf *ofpacts) +{ + uint16_t oasf_len = ntohs(oasf->len); + uint32_t oxm_header = ntohl(oasf->dst); + uint8_t oxm_length = NXM_LENGTH(oxm_header); + struct ofpact_reg_load *load; + const struct mf_field *mf; + + /* ofp12_action_set_field is padded to 64 bits by zero */ + if (oasf_len != ROUND_UP(sizeof(*oasf) + oxm_length, 8)) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + if (!is_all_zeros((const uint8_t *)(oasf) + sizeof *oasf + oxm_length, + oasf_len - oxm_length - sizeof *oasf)) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + + if (NXM_HASMASK(oxm_header)) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + mf = mf_from_nxm_header(oxm_header); + if (!mf) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + load = ofpact_put_REG_LOAD(ofpacts); + ofpact_set_field_init(load, mf, oasf + 1); + + return nxm_reg_load_check(load, NULL); +} enum ofperr nxm_reg_move_check(const struct ofpact_reg_move *move, const struct flow *flow) @@ -918,16 +1199,80 @@ nxm_reg_move_to_nxast(const struct ofpact_reg_move *move, narm->dst = htonl(move->dst.field->nxm_header); } -void -nxm_reg_load_to_nxast(const struct ofpact_reg_load *load, - struct ofpbuf *openflow) +static void +reg_load_to_nxast(const struct ofpact_reg_load *load, struct ofpbuf *openflow) { struct nx_action_reg_load *narl; narl = ofputil_put_NXAST_REG_LOAD(openflow); narl->ofs_nbits = nxm_encode_ofs_nbits(load->dst.ofs, load->dst.n_bits); narl->dst = htonl(load->dst.field->nxm_header); - narl->value = htonll(load->value); + narl->value = load->subvalue.be64[1]; +} + +static void +set_field_to_ofast(const struct ofpact_reg_load *load, + struct ofpbuf *openflow) +{ + const struct mf_field *mf = load->dst.field; + uint16_t padded_value_len = ROUND_UP(mf->n_bytes, 8); + struct ofp12_action_set_field *oasf; + char *value; + + /* Set field is the only action of variable length (so far), + * so handling the variable length portion is open-coded here */ + oasf = ofputil_put_OFPAT12_SET_FIELD(openflow); + oasf->dst = htonl(mf->oxm_header); + oasf->len = htons(ntohs(oasf->len) + padded_value_len); + + value = ofpbuf_put_zeros(openflow, padded_value_len); + bitwise_copy(&load->subvalue, sizeof load->subvalue, load->dst.ofs, + value, mf->n_bytes, load->dst.ofs, load->dst.n_bits); +} + +void +nxm_reg_load_to_nxast(const struct ofpact_reg_load *load, + struct ofpbuf *openflow) +{ + + if (load->ofpact.compat == OFPUTIL_OFPAT12_SET_FIELD) { + struct ofp_header *oh = (struct ofp_header *)openflow->l2; + + switch(oh->version) { + case OFP13_VERSION: + case OFP12_VERSION: + set_field_to_ofast(load, openflow); + break; + + case OFP11_VERSION: + case OFP10_VERSION: + if (load->dst.n_bits < 64) { + reg_load_to_nxast(load, openflow); + } else { + /* Split into 64bit chunks */ + int chunk, ofs; + for (ofs = 0; ofs < load->dst.n_bits; ofs += chunk) { + struct ofpact_reg_load subload = *load; + + chunk = MIN(load->dst.n_bits - ofs, 64); + + subload.dst.field = load->dst.field; + subload.dst.ofs = load->dst.ofs + ofs; + subload.dst.n_bits = chunk; + bitwise_copy(&load->subvalue, sizeof load->subvalue, ofs, + &subload.subvalue, sizeof subload.subvalue, 0, + chunk); + reg_load_to_nxast(&subload, openflow); + } + } + break; + + default: + NOT_REACHED(); + } + } else { + reg_load_to_nxast(load, openflow); + } } /* nxm_execute_reg_move(), nxm_execute_reg_load(). */ @@ -950,20 +1295,164 @@ nxm_execute_reg_move(const struct ofpact_reg_move *move, void nxm_execute_reg_load(const struct ofpact_reg_load *load, struct flow *flow) { - nxm_reg_load(&load->dst, load->value, flow); + mf_write_subfield_flow(&load->dst, &load->subvalue, flow); } void nxm_reg_load(const struct mf_subfield *dst, uint64_t src_data, struct flow *flow) { - union mf_value dst_value; - union mf_value src_value; + union mf_subvalue src_subvalue; + ovs_be64 src_data_be = htonll(src_data); - mf_get_value(dst->field, flow, &dst_value); - src_value.be64 = htonll(src_data); - bitwise_copy(&src_value, sizeof src_value.be64, 0, - &dst_value, dst->field->n_bytes, dst->ofs, - dst->n_bits); - mf_set_flow_value(dst->field, &dst_value, flow); + bitwise_copy(&src_data_be, sizeof src_data_be, 0, + &src_subvalue, sizeof src_subvalue, 0, + sizeof src_data_be * 8); + mf_write_subfield_flow(dst, &src_subvalue, flow); +} + +/* nxm_parse_stack_action, works for both push() and pop(). */ +void +nxm_parse_stack_action(struct ofpact_stack *stack_action, const char *s) +{ + s = mf_parse_subfield(&stack_action->subfield, s); + if (*s != '\0') { + ovs_fatal(0, "%s: trailing garbage following push or pop", s); + } +} + +void +nxm_format_stack_push(const struct ofpact_stack *push, struct ds *s) +{ + ds_put_cstr(s, "push:"); + mf_format_subfield(&push->subfield, s); +} + +void +nxm_format_stack_pop(const struct ofpact_stack *pop, struct ds *s) +{ + ds_put_cstr(s, "pop:"); + mf_format_subfield(&pop->subfield, s); +} + +/* Common set for both push and pop actions. */ +static void +stack_action_from_openflow__(const struct nx_action_stack *nasp, + struct ofpact_stack *stack_action) +{ + stack_action->subfield.field = mf_from_nxm_header(ntohl(nasp->field)); + stack_action->subfield.ofs = ntohs(nasp->offset); + stack_action->subfield.n_bits = ntohs(nasp->n_bits); +} + +static void +nxm_stack_to_nxast__(const struct ofpact_stack *stack_action, + struct nx_action_stack *nasp) +{ + nasp->offset = htons(stack_action->subfield.ofs); + nasp->n_bits = htons(stack_action->subfield.n_bits); + nasp->field = htonl(stack_action->subfield.field->nxm_header); +} + +enum ofperr +nxm_stack_push_from_openflow(const struct nx_action_stack *nasp, + struct ofpbuf *ofpacts) +{ + struct ofpact_stack *push; + + push = ofpact_put_STACK_PUSH(ofpacts); + stack_action_from_openflow__(nasp, push); + + return nxm_stack_push_check(push, NULL); +} + +enum ofperr +nxm_stack_pop_from_openflow(const struct nx_action_stack *nasp, + struct ofpbuf *ofpacts) +{ + struct ofpact_stack *pop; + + pop = ofpact_put_STACK_POP(ofpacts); + stack_action_from_openflow__(nasp, pop); + + return nxm_stack_pop_check(pop, NULL); +} + +enum ofperr +nxm_stack_push_check(const struct ofpact_stack *push, + const struct flow *flow) +{ + return mf_check_src(&push->subfield, flow); +} + +enum ofperr +nxm_stack_pop_check(const struct ofpact_stack *pop, + const struct flow *flow) +{ + return mf_check_dst(&pop->subfield, flow); +} + +void +nxm_stack_push_to_nxast(const struct ofpact_stack *stack, + struct ofpbuf *openflow) +{ + nxm_stack_to_nxast__(stack, ofputil_put_NXAST_STACK_PUSH(openflow)); +} + +void +nxm_stack_pop_to_nxast(const struct ofpact_stack *stack, + struct ofpbuf *openflow) +{ + nxm_stack_to_nxast__(stack, ofputil_put_NXAST_STACK_POP(openflow)); +} + +/* nxm_execute_stack_push(), nxm_execute_stack_pop(). */ +static void +nx_stack_push(struct ofpbuf *stack, union mf_subvalue *v) +{ + ofpbuf_put(stack, v, sizeof *v); +} + +static union mf_subvalue * +nx_stack_pop(struct ofpbuf *stack) +{ + union mf_subvalue *v = NULL; + + if (stack->size) { + stack->size -= sizeof *v; + v = (union mf_subvalue *) ofpbuf_tail(stack); + } + + return v; +} + +void +nxm_execute_stack_push(const struct ofpact_stack *push, + const struct flow *flow, struct ofpbuf *stack) +{ + union mf_subvalue dst_value; + + mf_read_subfield(&push->subfield, flow, &dst_value); + nx_stack_push(stack, &dst_value); +} + +void +nxm_execute_stack_pop(const struct ofpact_stack *pop, + struct flow *flow, struct ofpbuf *stack) +{ + union mf_subvalue *src_value; + + src_value = nx_stack_pop(stack); + + /* Only pop if stack is not empty. Otherwise, give warning. */ + if (src_value) { + mf_write_subfield_flow(&pop->subfield, src_value, flow); + } else { + if (!VLOG_DROP_WARN(&rl)) { + char *flow_str = flow_to_string(flow); + VLOG_WARN_RL(&rl, "Failed to pop from an empty stack. On flow \n" + " %s", flow_str); + free(flow_str); + } + } }