X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fflow.c;h=d899d260d6a29a8c580e61f334caa73b34e3c6a3;hb=2b13d312fc4d6e5eb1d0e3004fa523bb0c0ba544;hp=c2e99b7824f679a4c53016b7008c49ccb79742c2;hpb=3b21e3871731d30714890671164d491ebeef459d;p=sliver-openvswitch.git diff --git a/lib/flow.c b/lib/flow.c index c2e99b782..d899d260d 100644 --- a/lib/flow.c +++ b/lib/flow.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc. + * Copyright (c) 2008, 2009, 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. @@ -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 @@ -209,9 +229,8 @@ parse_ipv6(struct ofpbuf *packet, struct flow *flow) /* We only process the first fragment. */ if (frag_hdr->ip6f_offlg != htons(0)) { - if ((frag_hdr->ip6f_offlg & IP6F_OFF_MASK) == htons(0)) { - flow->nw_frag = FLOW_NW_FRAG_ANY; - } else { + flow->nw_frag = FLOW_NW_FRAG_ANY; + if ((frag_hdr->ip6f_offlg & IP6F_OFF_MASK) != htons(0)) { flow->nw_frag |= FLOW_NW_FRAG_LATER; nexthdr = IPPROTO_FRAGMENT; break; @@ -318,12 +337,14 @@ invalid: } /* Initializes 'flow' members from 'packet', 'skb_priority', 'tnl', and - * 'ofp_in_port'. + * 'in_port'. * * Initializes 'packet' header pointers as follows: * * - 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. @@ -336,7 +357,7 @@ invalid: */ void flow_extract(struct ofpbuf *packet, uint32_t skb_priority, uint32_t skb_mark, - const struct flow_tnl *tnl, uint16_t ofp_in_port, + const struct flow_tnl *tnl, const union flow_in_port *in_port, struct flow *flow) { struct ofpbuf b = *packet; @@ -347,17 +368,20 @@ 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; + if (in_port) { + flow->in_port = *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,6 +399,12 @@ flow_extract(struct ofpbuf *packet, uint32_t skb_priority, uint32_t skb_mark, } flow->dl_type = parse_ethertype(&b); + /* Parse mpls, copy l3 ttl. */ + if (eth_type_mpls(flow->dl_type)) { + packet->l2_5 = b.data; + parse_mpls(&b, flow); + } + /* Network layer. */ packet->l3 = b.data; if (flow->dl_type == htons(ETH_TYPE_IP)) { @@ -463,12 +493,14 @@ 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->tun_src = flow->tunnel.ip_src; + fmd->tun_dst = flow->tunnel.ip_dst; fmd->metadata = flow->metadata; memcpy(fmd->regs, flow->regs, sizeof fmd->regs); - fmd->in_port = flow->in_port; + fmd->in_port = flow->in_port.ofp_port; } char * @@ -529,7 +561,7 @@ flow_format(struct ds *ds, const struct flow *flow) struct match match; match_wc_init(&match, flow); - match_format(&match, ds, flow->skb_priority); + match_format(&match, ds, OFP_DEFAULT_PRIORITY); } void @@ -574,13 +606,13 @@ flow_wildcards_is_catchall(const struct flow_wildcards *wc) return true; } -/* Initializes 'dst' as the combination of wildcards in 'src1' and 'src2'. - * That is, a bit or a field is wildcarded in 'dst' if it is wildcarded in - * 'src1' or 'src2' or both. */ +/* Sets 'dst' as the bitwise AND of wildcards in 'src1' and 'src2'. + * That is, a bit or a field is wildcarded in 'dst' if it is wildcarded + * in 'src1' or 'src2' or both. */ void -flow_wildcards_combine(struct flow_wildcards *dst, - const struct flow_wildcards *src1, - const struct flow_wildcards *src2) +flow_wildcards_and(struct flow_wildcards *dst, + const struct flow_wildcards *src1, + const struct flow_wildcards *src2) { uint32_t *dst_u32 = (uint32_t *) &dst->masks; const uint32_t *src1_u32 = (const uint32_t *) &src1->masks; @@ -592,11 +624,56 @@ flow_wildcards_combine(struct flow_wildcards *dst, } } +/* Sets 'dst' as the bitwise OR of wildcards in 'src1' and 'src2'. That + * is, a bit or a field is wildcarded in 'dst' if it is neither + * wildcarded in 'src1' nor 'src2'. */ +void +flow_wildcards_or(struct flow_wildcards *dst, + const struct flow_wildcards *src1, + const struct flow_wildcards *src2) +{ + uint32_t *dst_u32 = (uint32_t *) &dst->masks; + const uint32_t *src1_u32 = (const uint32_t *) &src1->masks; + const uint32_t *src2_u32 = (const uint32_t *) &src2->masks; + size_t i; + + for (i = 0; i < FLOW_U32S; i++) { + dst_u32[i] = src1_u32[i] | src2_u32[i]; + } +} + +/* Perform a bitwise OR of miniflow 'src' flow data with the equivalent + * fields in 'dst', storing the result in 'dst'. */ +static void +flow_union_with_miniflow(struct flow *dst, const struct miniflow *src) +{ + uint32_t *dst_u32 = (uint32_t *) dst; + int ofs; + int i; + + ofs = 0; + for (i = 0; i < MINI_N_MAPS; i++) { + uint32_t map; + + for (map = src->map[i]; map; map = zero_rightmost_1bit(map)) { + dst_u32[raw_ctz(map) + i * 32] |= src->values[ofs++]; + } + } +} + +/* Fold minimask 'mask''s wildcard mask into 'wc's wildcard mask. */ +void +flow_wildcards_fold_minimask(struct flow_wildcards *wc, + const struct minimask *mask) +{ + flow_union_with_miniflow(&wc->masks, &mask->masks); +} + /* Returns a hash of the wildcards in 'wc'. */ uint32_t flow_wildcards_hash(const struct flow_wildcards *wc, uint32_t basis) { - return flow_hash(&wc->masks, basis);; + return flow_hash(&wc->masks, basis); } /* Returns true if 'a' and 'b' represent the same wildcards, false if they are @@ -699,7 +776,40 @@ 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); +} + +/* Masks the fields in 'wc' that are used by the flow hash 'fields'. */ +void +flow_mask_hash_fields(const struct flow *flow, struct flow_wildcards *wc, + enum nx_hash_fields fields) +{ + switch (fields) { + case NX_HASH_FIELDS_ETH_SRC: + memset(&wc->masks.dl_src, 0xff, sizeof wc->masks.dl_src); + break; + + case NX_HASH_FIELDS_SYMMETRIC_L4: + memset(&wc->masks.dl_src, 0xff, sizeof wc->masks.dl_src); + memset(&wc->masks.dl_dst, 0xff, sizeof wc->masks.dl_dst); + if (flow->dl_type == htons(ETH_TYPE_IP)) { + memset(&wc->masks.nw_src, 0xff, sizeof wc->masks.nw_src); + memset(&wc->masks.nw_dst, 0xff, sizeof wc->masks.nw_dst); + } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) { + memset(&wc->masks.ipv6_src, 0xff, sizeof wc->masks.ipv6_src); + memset(&wc->masks.ipv6_dst, 0xff, sizeof wc->masks.ipv6_dst); + } + if (is_ip_any(flow)) { + memset(&wc->masks.nw_proto, 0xff, sizeof wc->masks.nw_proto); + memset(&wc->masks.tp_src, 0xff, sizeof wc->masks.tp_src); + memset(&wc->masks.tp_dst, 0xff, sizeof wc->masks.tp_dst); + } + wc->masks.vlan_tci |= htons(VLAN_VID_MASK | VLAN_CFI); + break; + + default: + NOT_REACHED(); + } } /* Hashes the portions of 'flow' designated by 'fields'. */ @@ -710,7 +820,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); @@ -738,6 +848,24 @@ flow_hash_fields_valid(enum nx_hash_fields fields) || fields == NX_HASH_FIELDS_SYMMETRIC_L4; } +/* Returns a hash value for the bits of 'flow' that are active based on + * 'wc', given 'basis'. */ +uint32_t +flow_hash_in_wildcards(const struct flow *flow, + const struct flow_wildcards *wc, uint32_t basis) +{ + const uint32_t *wc_u32 = (const uint32_t *) &wc->masks; + const uint32_t *flow_u32 = (const uint32_t *) flow; + uint32_t hash; + size_t i; + + hash = basis; + for (i = 0; i < FLOW_U32S; i++) { + hash = mhash_add(hash, flow_u32[i] & wc_u32[i]); + } + return mhash_finish(hash, 4 * FLOW_U32S); +} + /* Sets the VLAN VID that 'flow' matches to 'vid', which is interpreted as an * OpenFlow 1.0 "dl_vlan" value: * @@ -787,6 +915,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'. * @@ -874,6 +1033,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. */ @@ -958,20 +1122,8 @@ miniflow_destroy(struct miniflow *flow) void miniflow_expand(const struct miniflow *src, struct flow *dst) { - uint32_t *dst_u32 = (uint32_t *) dst; - int ofs; - int i; - - memset(dst_u32, 0, sizeof *dst); - - ofs = 0; - for (i = 0; i < MINI_N_MAPS; i++) { - uint32_t map; - - for (map = src->map[i]; map; map = zero_rightmost_1bit(map)) { - dst_u32[raw_ctz(map) + i * 32] = src->values[ofs++]; - } - } + memset(dst, 0, sizeof *dst); + flow_union_with_miniflow(dst, src); } static const uint32_t * @@ -1125,7 +1277,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 @@ -1154,7 +1306,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'