X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fflow.c;h=678b8f0d5d88f7eea69bfa31885a9fd58a327bd0;hb=2c57a420432de88b8a6f9ee54642c3841577ad7b;hp=a13519ef5fb7701fee85d23b31a75487dccf736d;hpb=85b20fd6ee585f462e012fbcc7f966a81edab2ed;p=sliver-openvswitch.git diff --git a/lib/flow.c b/lib/flow.c index a13519ef5..678b8f0d5 100644 --- a/lib/flow.c +++ b/lib/flow.c @@ -16,7 +16,6 @@ #include #include #include "flow.h" -#include #include #include #include @@ -31,6 +30,7 @@ #include "csum.h" #include "dynamic-string.h" #include "hash.h" +#include "jhash.h" #include "match.h" #include "ofpbuf.h" #include "openflow/openflow.h" @@ -93,6 +93,21 @@ pull_icmpv6(struct ofpbuf *packet) return ofpbuf_try_pull(packet, sizeof(struct icmp6_hdr)); } +static void +parse_mpls(struct ofpbuf *b, struct flow *flow) +{ + struct mpls_hdr *mh; + + while ((mh = ofpbuf_try_pull(b, sizeof *mh))) { + if (flow->mpls_depth++ == 0) { + flow->mpls_lse = mh->mpls_lse; + } + if (mh->mpls_lse & htonl(MPLS_BOS_MASK)) { + break; + } + } +} + static void parse_vlan(struct ofpbuf *b, struct flow *flow) { @@ -132,7 +147,12 @@ parse_ethertype(struct ofpbuf *b) } ofpbuf_pull(b, sizeof *llc); - return llc->snap.snap_type; + + if (ntohs(llc->snap.snap_type) >= ETH_TYPE_MIN) { + return llc->snap.snap_type; + } + + return htons(FLOW_DL_TYPE_NONE); } static int @@ -324,6 +344,8 @@ invalid: * * - packet->l2 to the start of the Ethernet header. * + * - packet->l2_5 to the start of the MPLS shim header. + * * - packet->l3 to just past the Ethernet header, or just past the * vlan_header if one is present, to the first byte of the payload of the * Ethernet frame. @@ -347,17 +369,18 @@ flow_extract(struct ofpbuf *packet, uint32_t skb_priority, uint32_t skb_mark, memset(flow, 0, sizeof *flow); if (tnl) { - assert(tnl != &flow->tunnel); + ovs_assert(tnl != &flow->tunnel); flow->tunnel = *tnl; } flow->in_port = ofp_in_port; flow->skb_priority = skb_priority; flow->skb_mark = skb_mark; - packet->l2 = b.data; - packet->l3 = NULL; - packet->l4 = NULL; - packet->l7 = NULL; + packet->l2 = b.data; + packet->l2_5 = NULL; + packet->l3 = NULL; + packet->l4 = NULL; + packet->l7 = NULL; if (b.size < sizeof *eth) { return; @@ -375,33 +398,15 @@ flow_extract(struct ofpbuf *packet, uint32_t skb_priority, uint32_t skb_mark, } flow->dl_type = parse_ethertype(&b); - packet->l3 = b.data; - flow_extract_l3_onwards(packet, flow, flow->dl_type); -} - -/* Initializes l3 and higher 'flow' members from 'packet' - * - * This should be called by or after flow_extract() - * - * Initializes 'packet' header pointers as follows: - * - * - packet->l4 to just past the IPv4 header, if one is present and has a - * correct length, and otherwise NULL. - * - * - packet->l7 to just past the TCP or UDP or ICMP header, if one is - * present and has a correct length, and otherwise NULL. - */ -void -flow_extract_l3_onwards(struct ofpbuf *packet, struct flow *flow, - ovs_be16 dl_type) -{ - struct ofpbuf b; - - ofpbuf_use_const(&b, packet->l3, packet->size - - (size_t)((char *)packet->l3 - (char *)packet->l2)); + /* Parse mpls, copy l3 ttl. */ + if (eth_type_mpls(flow->dl_type)) { + packet->l2_5 = b.data; + parse_mpls(&b, flow); + } /* Network layer. */ - if (dl_type == htons(ETH_TYPE_IP)) { + packet->l3 = b.data; + if (flow->dl_type == htons(ETH_TYPE_IP)) { const struct ip_header *nh = pull_ip(&b); if (nh) { packet->l4 = b.data; @@ -434,7 +439,7 @@ flow_extract_l3_onwards(struct ofpbuf *packet, struct flow *flow, } } } - } else if (dl_type == htons(ETH_TYPE_IPV6)) { + } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) { if (parse_ipv6(&b, flow)) { return; } @@ -449,8 +454,8 @@ flow_extract_l3_onwards(struct ofpbuf *packet, struct flow *flow, packet->l7 = b.data; } } - } else if (dl_type == htons(ETH_TYPE_ARP) || - dl_type == htons(ETH_TYPE_RARP)) { + } else if (flow->dl_type == htons(ETH_TYPE_ARP) || + flow->dl_type == htons(ETH_TYPE_RARP)) { const struct arp_eth_header *arp = pull_arp(&b); if (arp && arp->ar_hrd == htons(1) && arp->ar_pro == htons(ETH_TYPE_IP) @@ -487,7 +492,7 @@ flow_zero_wildcards(struct flow *flow, const struct flow_wildcards *wildcards) void flow_get_metadata(const struct flow *flow, struct flow_metadata *fmd) { - BUILD_ASSERT_DECL(FLOW_WC_SEQ == 18); + BUILD_ASSERT_DECL(FLOW_WC_SEQ == 20); fmd->tun_id = flow->tunnel.tun_id; fmd->metadata = flow->metadata; @@ -723,7 +728,7 @@ flow_hash_symmetric_l4(const struct flow *flow, uint32_t basis) fields.tp_port = flow->tp_src ^ flow->tp_dst; } } - return hash_bytes(&fields, sizeof fields, basis); + return jhash_bytes(&fields, sizeof fields, basis); } /* Hashes the portions of 'flow' designated by 'fields'. */ @@ -734,7 +739,7 @@ flow_hash_fields(const struct flow *flow, enum nx_hash_fields fields, switch (fields) { case NX_HASH_FIELDS_ETH_SRC: - return hash_bytes(flow->dl_src, sizeof flow->dl_src, basis); + return jhash_bytes(flow->dl_src, sizeof flow->dl_src, basis); case NX_HASH_FIELDS_SYMMETRIC_L4: return flow_hash_symmetric_l4(flow, basis); @@ -811,6 +816,37 @@ flow_set_vlan_pcp(struct flow *flow, uint8_t pcp) flow->vlan_tci |= htons((pcp << VLAN_PCP_SHIFT) | VLAN_CFI); } +/* Sets the MPLS Label that 'flow' matches to 'label', which is interpreted + * as an OpenFlow 1.1 "mpls_label" value. */ +void +flow_set_mpls_label(struct flow *flow, ovs_be32 label) +{ + set_mpls_lse_label(&flow->mpls_lse, label); +} + +/* Sets the MPLS TTL that 'flow' matches to 'ttl', which should be in the + * range 0...255. */ +void +flow_set_mpls_ttl(struct flow *flow, uint8_t ttl) +{ + set_mpls_lse_ttl(&flow->mpls_lse, ttl); +} + +/* Sets the MPLS TC that 'flow' matches to 'tc', which should be in the + * range 0...7. */ +void +flow_set_mpls_tc(struct flow *flow, uint8_t tc) +{ + set_mpls_lse_tc(&flow->mpls_lse, tc); +} + +/* Sets the MPLS BOS bit that 'flow' matches to which should be 0 or 1. */ +void +flow_set_mpls_bos(struct flow *flow, uint8_t bos) +{ + set_mpls_lse_bos(&flow->mpls_lse, bos); +} + /* Puts into 'b' a packet that flow_extract() would parse as having the given * 'flow'. * @@ -898,6 +934,11 @@ flow_compose(struct ofpbuf *b, const struct flow *flow) memcpy(arp->ar_tha, flow->arp_tha, ETH_ADDR_LEN); } } + + if (eth_type_mpls(flow->dl_type)) { + b->l2_5 = b->l3; + push_mpls(b, flow->dl_type, flow->mpls_lse); + } } /* Compressed flow. */ @@ -1149,7 +1190,7 @@ miniflow_hash_in_minimask(const struct miniflow *flow, } } - return mhash_finish(hash, p - mask->masks.values); + return mhash_finish(hash, (p - mask->masks.values) * 4); } /* Returns a hash value for the bits of 'flow' where there are 1-bits in @@ -1178,7 +1219,7 @@ flow_hash_in_minimask(const struct flow *flow, const struct minimask *mask, } } - return mhash_finish(hash, p - mask->masks.values); + return mhash_finish(hash, (p - mask->masks.values) * 4); } /* Initializes 'dst' as a copy of 'src'. The caller must eventually free 'dst'