ovs-2.8.0 源码

/* * Copyright (c) 2008-2017 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <config.h> #include <ctype.h> #include <errno.h> #include <inttypes.h> #include <sys/types.h> #include <netinet/in.h> #include <netinet/icmp6.h> #include <stdlib.h> #include "bitmap.h" #include "bundle.h" #include "byte-order.h" #include "classifier.h" #include "learn.h" #include "multipath.h" #include "netdev.h" #include "nx-match.h" #include "id-pool.h" #include "openflow/netronome-ext.h" #include "openvswitch/dynamic-string.h" #include "openvswitch/json.h" #include "openvswitch/meta-flow.h" #include "openvswitch/ofp-actions.h" #include "openvswitch/ofp-errors.h" #include "openvswitch/ofp-msgs.h" #include "openvswitch/ofp-print.h" #include "openvswitch/ofp-prop.h" #include "openvswitch/ofp-util.h" #include "openvswitch/ofpbuf.h" #include "openvswitch/type-props.h" #include "openvswitch/vlog.h" #include "openflow/intel-ext.h" #include "packets.h" #include "random.h" #include "tun-metadata.h" #include "unaligned.h" #include "util.h" #include "uuid.h" VLOG_DEFINE_THIS_MODULE(ofp_util); /* Rate limit for OpenFlow message parse errors. These always indicate a bug * in the peer and so there's not much point in showing a lot of them. */ static struct vlog_rate_limit bad_ofmsg_rl = VLOG_RATE_LIMIT_INIT(1, 5); static enum ofputil_table_vacancy ofputil_decode_table_vacancy( ovs_be32 config, enum ofp_version); static enum ofputil_table_eviction ofputil_decode_table_eviction( ovs_be32 config, enum ofp_version); static ovs_be32 ofputil_encode_table_config(enum ofputil_table_miss, enum ofputil_table_eviction, enum ofputil_table_vacancy, enum ofp_version); /* Given the wildcard bit count in the least-significant 6 of 'wcbits', returns * an IP netmask with a 1 in each bit that must match and a 0 in each bit that * is wildcarded. * * The bits in 'wcbits' are in the format used in enum ofp_flow_wildcards: 0 * is exact match, 1 ignores the LSB, 2 ignores the 2 least-significant bits, * ..., 32 and higher wildcard the entire field. This is the *opposite* of the * usual convention where e.g. /24 indicates that 8 bits (not 24 bits) are * wildcarded. */ ovs_be32 ofputil_wcbits_to_netmask(int wcbits) { wcbits &= 0x3f; return wcbits < 32 ? htonl(~((1u << wcbits) - 1)) : 0; } /* Given the IP netmask 'netmask', returns the number of bits of the IP address * that it wildcards, that is, the number of 0-bits in 'netmask', a number * between 0 and 32 inclusive. * * If 'netmask' is not a CIDR netmask (see ip_is_cidr()), the return value will * still be in the valid range but isn't otherwise meaningful. */ int ofputil_netmask_to_wcbits(ovs_be32 netmask) { return 32 - ip_count_cidr_bits(netmask); } /* Converts the OpenFlow 1.0 wildcards in 'ofpfw' (OFPFW10_*) into a * flow_wildcards in 'wc' for use in struct match. It is the caller's * responsibility to handle the special case where the flow match's dl_vlan is * set to OFP_VLAN_NONE. */ void ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc) { BUILD_ASSERT_DECL(FLOW_WC_SEQ == 40); /* Initialize most of wc. */ flow_wildcards_init_catchall(wc); if (!(ofpfw & OFPFW10_IN_PORT)) { wc->masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX); } if (!(ofpfw & OFPFW10_NW_TOS)) { wc->masks.nw_tos |= IP_DSCP_MASK; } if (!(ofpfw & OFPFW10_NW_PROTO)) { wc->masks.nw_proto = UINT8_MAX; } wc->masks.nw_src = ofputil_wcbits_to_netmask(ofpfw >> OFPFW10_NW_SRC_SHIFT); wc->masks.nw_dst = ofputil_wcbits_to_netmask(ofpfw >> OFPFW10_NW_DST_SHIFT); if (!(ofpfw & OFPFW10_TP_SRC)) { wc->masks.tp_src = OVS_BE16_MAX; } if (!(ofpfw & OFPFW10_TP_DST)) { wc->masks.tp_dst = OVS_BE16_MAX; } if (!(ofpfw & OFPFW10_DL_SRC)) { WC_MASK_FIELD(wc, dl_src); } if (!(ofpfw & OFPFW10_DL_DST)) { WC_MASK_FIELD(wc, dl_dst); } if (!(ofpfw & OFPFW10_DL_TYPE)) { wc->masks.dl_type = OVS_BE16_MAX; } /* VLAN TCI mask. */ if (!(ofpfw & OFPFW10_DL_VLAN_PCP)) { wc->masks.vlans[0].tci |= htons(VLAN_PCP_MASK | VLAN_CFI); } if (!(ofpfw & OFPFW10_DL_VLAN)) { wc->masks.vlans[0].tci |= htons(VLAN_VID_MASK | VLAN_CFI); } } /* Converts the ofp10_match in 'ofmatch' into a struct match in 'match'. */ void ofputil_match_from_ofp10_match(const struct ofp10_match *ofmatch, struct match *match) { uint32_t ofpfw = ntohl(ofmatch->wildcards) & OFPFW10_ALL; /* Initialize match->wc. */ memset(&match->flow, 0, sizeof match->flow); ofputil_wildcard_from_ofpfw10(ofpfw, &match->wc); memset(&match->tun_md, 0, sizeof match->tun_md); /* If any fields, except in_port, are matched, then we also need to match * on the Ethernet packet_type. */ const uint32_t ofpfw_data_bits = (OFPFW10_NW_TOS | OFPFW10_NW_PROTO | OFPFW10_TP_SRC | OFPFW10_TP_DST | OFPFW10_DL_SRC | OFPFW10_DL_DST | OFPFW10_DL_TYPE | OFPFW10_DL_VLAN | OFPFW10_DL_VLAN_PCP); if ((ofpfw & ofpfw_data_bits) != ofpfw_data_bits || ofputil_wcbits_to_netmask(ofpfw >> OFPFW10_NW_SRC_SHIFT) || ofputil_wcbits_to_netmask(ofpfw >> OFPFW10_NW_DST_SHIFT)) { match_set_default_packet_type(match); } /* Initialize most of match->flow. */ match->flow.nw_src = ofmatch->nw_src; match->flow.nw_dst = ofmatch->nw_dst; match->flow.in_port.ofp_port = u16_to_ofp(ntohs(ofmatch->in_port)); match->flow.dl_type = ofputil_dl_type_from_openflow(ofmatch->dl_type); match->flow.tp_src = ofmatch->tp_src; match->flow.tp_dst = ofmatch->tp_dst; match->flow.dl_src = ofmatch->dl_src; match->flow.dl_dst = ofmatch->dl_dst; match->flow.nw_tos = ofmatch->nw_tos & IP_DSCP_MASK; match->flow.nw_proto = ofmatch->nw_proto; /* Translate VLANs. */ if (!(ofpfw & OFPFW10_DL_VLAN) && ofmatch->dl_vlan == htons(OFP10_VLAN_NONE)) { /* Match only packets without 802.1Q header. * * When OFPFW10_DL_VLAN_PCP is wildcarded, this is obviously correct. * * If OFPFW10_DL_VLAN_PCP is matched, the flow match is contradictory, * because we can't have a specific PCP without an 802.1Q header. * However, older versions of OVS treated this as matching packets * withut an 802.1Q header, so we do here too. */ match->flow.vlans[0].tci = htons(0); match->wc.masks.vlans[0].tci = htons(0xffff); } else { ovs_be16 vid, pcp, tci; uint16_t hpcp; vid = ofmatch->dl_vlan & htons(VLAN_VID_MASK); hpcp = (ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK; pcp = htons(hpcp); tci = vid | pcp | htons(VLAN_CFI); match->flow.vlans[0].tci = tci & match->wc.masks.vlans[0].tci; } /* Clean up. */ match_zero_wildcarded_fields(match); } /* Convert 'match' into the OpenFlow 1.0 match structure 'ofmatch'. */ void ofputil_match_to_ofp10_match(const struct match *match, struct ofp10