X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Flearning-switch.c;h=35c3feffdefdecc22218358d1697eb791f69a506;hb=9f6e20b70e1117037dda056bda39b02c769aa8cd;hp=76ec3e13ef79b7b1ead1f5c56d0799ec80ece942;hpb=918f2b827076f3af4ae6c3f0c20b93233947cf4c;p=cascardo%2Fovs.git diff --git a/lib/learning-switch.c b/lib/learning-switch.c index 76ec3e13e..35c3feffd 100644 --- a/lib/learning-switch.c +++ b/lib/learning-switch.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,6 +25,7 @@ #include "byte-order.h" #include "classifier.h" +#include "dp-packet.h" #include "flow.h" #include "hmap.h" #include "mac-learning.h" @@ -41,8 +42,8 @@ #include "shash.h" #include "simap.h" #include "timeval.h" -#include "vconn.h" -#include "vlog.h" +#include "openvswitch/vconn.h" +#include "openvswitch/vlog.h" VLOG_DEFINE_THIS_MODULE(learning_switch); @@ -105,6 +106,13 @@ static enum ofperr process_switch_features(struct lswitch *, static void process_packet_in(struct lswitch *, const struct ofp_header *); static void process_echo_request(struct lswitch *, const struct ofp_header *); +static ofp_port_t get_mac_entry_ofp_port(const struct mac_learning *ml, + const struct mac_entry *) + OVS_REQ_RDLOCK(ml->rwlock); +static void set_mac_entry_ofp_port(struct mac_learning *ml, + struct mac_entry *, ofp_port_t) + OVS_REQ_WRLOCK(ml->rwlock); + /* Creates and returns a new learning switch whose configuration is given by * 'cfg'. * @@ -173,10 +181,43 @@ static void lswitch_handshake(struct lswitch *sw) { enum ofputil_protocol protocol; + enum ofp_version version; send_features_request(sw); - protocol = ofputil_protocol_from_ofp_version(rconn_get_version(sw->rconn)); + version = rconn_get_version(sw->rconn); + protocol = ofputil_protocol_from_ofp_version(version); + if (version >= OFP13_VERSION) { + /* OpenFlow 1.3 and later by default drop packets that miss in the flow + * table. Set up a flow to send packets to the controller by + * default. */ + struct ofpact_output output; + struct ofpbuf *msg; + int error; + + ofpact_init_OUTPUT(&output); + output.port = OFPP_CONTROLLER; + output.max_len = OFP_DEFAULT_MISS_SEND_LEN; + + struct ofputil_flow_mod fm = { + .match = MATCH_CATCHALL_INITIALIZER, + .priority = 0, + .table_id = 0, + .command = OFPFC_ADD, + .buffer_id = UINT32_MAX, + .out_port = OFPP_NONE, + .out_group = OFPG_ANY, + .ofpacts = &output.ofpact, + .ofpacts_len = sizeof output, + }; + + msg = ofputil_encode_flow_mod(&fm, protocol); + error = rconn_send(sw->rconn, msg, NULL); + if (error) { + VLOG_INFO_RL(&rl, "%s: failed to add default flow (%s)", + rconn_get_name(sw->rconn), ovs_strerror(error)); + } + } if (sw->default_flows) { struct ofpbuf *msg = NULL; int error = 0; @@ -313,12 +354,9 @@ lswitch_process_packet(struct lswitch *sw, const struct ofpbuf *msg) return; } - switch (type) { - case OFPTYPE_ECHO_REQUEST: + if (type == OFPTYPE_ECHO_REQUEST) { process_echo_request(sw, msg->data); - break; - - case OFPTYPE_FEATURES_REPLY: + } else if (type == OFPTYPE_FEATURES_REPLY) { if (sw->state == S_FEATURES_REPLY) { if (!process_switch_features(sw, msg->data)) { sw->state = S_SWITCHING; @@ -326,84 +364,15 @@ lswitch_process_packet(struct lswitch *sw, const struct ofpbuf *msg) rconn_disconnect(sw->rconn); } } - break; - - case OFPTYPE_PACKET_IN: + } else if (type == OFPTYPE_PACKET_IN) { process_packet_in(sw, msg->data); - break; - - case OFPTYPE_FLOW_REMOVED: + } else if (type == OFPTYPE_FLOW_REMOVED) { /* Nothing to do. */ - break; - - case OFPTYPE_HELLO: - case OFPTYPE_ERROR: - case OFPTYPE_ECHO_REPLY: - case OFPTYPE_FEATURES_REQUEST: - case OFPTYPE_GET_CONFIG_REQUEST: - case OFPTYPE_GET_CONFIG_REPLY: - case OFPTYPE_SET_CONFIG: - case OFPTYPE_PORT_STATUS: - case OFPTYPE_PACKET_OUT: - case OFPTYPE_FLOW_MOD: - case OFPTYPE_GROUP_MOD: - case OFPTYPE_PORT_MOD: - case OFPTYPE_TABLE_MOD: - case OFPTYPE_BARRIER_REQUEST: - case OFPTYPE_BARRIER_REPLY: - case OFPTYPE_QUEUE_GET_CONFIG_REQUEST: - case OFPTYPE_QUEUE_GET_CONFIG_REPLY: - case OFPTYPE_DESC_STATS_REQUEST: - case OFPTYPE_DESC_STATS_REPLY: - case OFPTYPE_FLOW_STATS_REQUEST: - case OFPTYPE_FLOW_STATS_REPLY: - case OFPTYPE_AGGREGATE_STATS_REQUEST: - case OFPTYPE_AGGREGATE_STATS_REPLY: - case OFPTYPE_TABLE_STATS_REQUEST: - case OFPTYPE_TABLE_STATS_REPLY: - case OFPTYPE_PORT_STATS_REQUEST: - case OFPTYPE_PORT_STATS_REPLY: - case OFPTYPE_QUEUE_STATS_REQUEST: - case OFPTYPE_QUEUE_STATS_REPLY: - case OFPTYPE_PORT_DESC_STATS_REQUEST: - case OFPTYPE_PORT_DESC_STATS_REPLY: - case OFPTYPE_ROLE_REQUEST: - case OFPTYPE_ROLE_REPLY: - case OFPTYPE_SET_FLOW_FORMAT: - case OFPTYPE_FLOW_MOD_TABLE_ID: - case OFPTYPE_SET_PACKET_IN_FORMAT: - case OFPTYPE_FLOW_AGE: - case OFPTYPE_SET_CONTROLLER_ID: - case OFPTYPE_FLOW_MONITOR_STATS_REQUEST: - case OFPTYPE_FLOW_MONITOR_STATS_REPLY: - case OFPTYPE_FLOW_MONITOR_CANCEL: - case OFPTYPE_FLOW_MONITOR_PAUSED: - case OFPTYPE_FLOW_MONITOR_RESUMED: - case OFPTYPE_GET_ASYNC_REQUEST: - case OFPTYPE_GET_ASYNC_REPLY: - case OFPTYPE_SET_ASYNC_CONFIG: - case OFPTYPE_METER_MOD: - case OFPTYPE_GROUP_STATS_REQUEST: - case OFPTYPE_GROUP_STATS_REPLY: - case OFPTYPE_GROUP_DESC_STATS_REQUEST: - case OFPTYPE_GROUP_DESC_STATS_REPLY: - case OFPTYPE_GROUP_FEATURES_STATS_REQUEST: - case OFPTYPE_GROUP_FEATURES_STATS_REPLY: - case OFPTYPE_METER_STATS_REQUEST: - case OFPTYPE_METER_STATS_REPLY: - case OFPTYPE_METER_CONFIG_STATS_REQUEST: - case OFPTYPE_METER_CONFIG_STATS_REPLY: - case OFPTYPE_METER_FEATURES_STATS_REQUEST: - case OFPTYPE_METER_FEATURES_STATS_REPLY: - case OFPTYPE_TABLE_FEATURES_STATS_REQUEST: - case OFPTYPE_TABLE_FEATURES_STATS_REPLY: - default: - if (VLOG_IS_DBG_ENABLED()) { - char *s = ofp_to_string(msg->data, msg->size, 2); - VLOG_DBG_RL(&rl, "%016llx: OpenFlow packet ignored: %s", - sw->datapath_id, s); - free(s); - } + } else if (VLOG_IS_DBG_ENABLED()) { + char *s = ofp_to_string(msg->data, msg->size, 2); + VLOG_DBG_RL(&rl, "%016llx: OpenFlow packet ignored: %s", + sw->datapath_id, s); + free(s); } } @@ -411,7 +380,6 @@ static void send_features_request(struct lswitch *sw) { struct ofpbuf *b; - struct ofp_switch_config *osc; int ofp_version = rconn_get_version(sw->rconn); ovs_assert(ofp_version > 0 && ofp_version < 0xff); @@ -421,10 +389,10 @@ send_features_request(struct lswitch *sw) queue_tx(sw, b); /* Send OFPT_SET_CONFIG. */ - b = ofpraw_alloc(OFPRAW_OFPT_SET_CONFIG, ofp_version, sizeof *osc); - osc = ofpbuf_put_zeros(b, sizeof *osc); - osc->miss_send_len = htons(OFP_DEFAULT_MISS_SEND_LEN); - queue_tx(sw, b); + struct ofputil_switch_config config = { + .miss_send_len = OFP_DEFAULT_MISS_SEND_LEN + }; + queue_tx(sw, ofputil_encode_set_config(&config, ofp_version)); } static void @@ -477,19 +445,23 @@ lswitch_choose_destination(struct lswitch *sw, const struct flow *flow) ofp_port_t out_port; /* Learn the source MAC. */ - ovs_rwlock_wrlock(&sw->ml->rwlock); - if (mac_learning_may_learn(sw->ml, flow->dl_src, 0)) { - struct mac_entry *mac = mac_learning_insert(sw->ml, flow->dl_src, 0); - if (mac->port.ofp_port != flow->in_port.ofp_port) { - VLOG_DBG_RL(&rl, "%016llx: learned that "ETH_ADDR_FMT" is on " - "port %"PRIu16, sw->datapath_id, - ETH_ADDR_ARGS(flow->dl_src), flow->in_port.ofp_port); - - mac->port.ofp_port = flow->in_port.ofp_port; - mac_learning_changed(sw->ml); + if (sw->ml) { + ovs_rwlock_wrlock(&sw->ml->rwlock); + if (mac_learning_may_learn(sw->ml, flow->dl_src, 0)) { + struct mac_entry *mac = mac_learning_insert(sw->ml, flow->dl_src, + 0); + if (get_mac_entry_ofp_port(sw->ml, mac) + != flow->in_port.ofp_port) { + VLOG_DBG_RL(&rl, "%016llx: learned that "ETH_ADDR_FMT" is on " + "port %"PRIu16, sw->datapath_id, + ETH_ADDR_ARGS(flow->dl_src), + flow->in_port.ofp_port); + + set_mac_entry_ofp_port(sw->ml, mac, flow->in_port.ofp_port); + } } + ovs_rwlock_unlock(&sw->ml->rwlock); } - ovs_rwlock_unlock(&sw->ml->rwlock); /* Drop frames for reserved multicast addresses. */ if (eth_addr_is_reserved(flow->dl_dst)) { @@ -503,7 +475,7 @@ lswitch_choose_destination(struct lswitch *sw, const struct flow *flow) ovs_rwlock_rdlock(&sw->ml->rwlock); mac = mac_learning_lookup(sw->ml, flow->dl_dst, 0); if (mac) { - out_port = mac->port.ofp_port; + out_port = get_mac_entry_ofp_port(sw->ml, mac); if (out_port == flow->in_port.ofp_port) { /* Don't send a packet back out its input port. */ ovs_rwlock_unlock(&sw->ml->rwlock); @@ -540,6 +512,8 @@ static void process_packet_in(struct lswitch *sw, const struct ofp_header *oh) { struct ofputil_packet_in pi; + size_t total_len; + uint32_t buffer_id; uint32_t queue_id; ofp_port_t out_port; @@ -549,11 +523,10 @@ process_packet_in(struct lswitch *sw, const struct ofp_header *oh) struct ofputil_packet_out po; enum ofperr error; - struct ofpbuf pkt; + struct dp_packet pkt; struct flow flow; - union flow_in_port in_port_; - error = ofputil_decode_packet_in(&pi, oh); + error = ofputil_decode_packet_in(oh, &pi, &total_len, &buffer_id); if (error) { VLOG_WARN_RL(&rl, "failed to decode packet-in: %s", ofperr_to_string(error)); @@ -567,17 +540,17 @@ process_packet_in(struct lswitch *sw, const struct ofp_header *oh) return; } - /* Extract flow data from 'opi' into 'flow'. */ - ofpbuf_use_const(&pkt, pi.packet, pi.packet_len); - in_port_.ofp_port = pi.fmd.in_port; - flow_extract(&pkt, 0, 0, NULL, &in_port_, &flow); - flow.tunnel.tun_id = pi.fmd.tun_id; + /* Extract flow data from 'pi' into 'flow'. */ + dp_packet_use_const(&pkt, pi.packet, pi.len); + flow_extract(&pkt, &flow); + flow.in_port.ofp_port = pi.flow_metadata.flow.in_port.ofp_port; + flow.tunnel.tun_id = pi.flow_metadata.flow.tunnel.tun_id; /* Choose output port. */ out_port = lswitch_choose_destination(sw, &flow); /* Make actions. */ - queue_id = get_queue_id(sw, pi.fmd.in_port); + queue_id = get_queue_id(sw, pi.flow_metadata.flow.in_port.ofp_port); ofpbuf_use_stack(&ofpacts, ofpacts_stub, sizeof ofpacts_stub); if (out_port == OFPP_NONE) { /* No actions. */ @@ -589,51 +562,49 @@ process_packet_in(struct lswitch *sw, const struct ofp_header *oh) enqueue->port = out_port; enqueue->queue = queue_id; } - ofpact_pad(&ofpacts); /* Prepare packet_out in case we need one. */ - po.buffer_id = pi.buffer_id; - if (po.buffer_id == UINT32_MAX) { - po.packet = pkt.data; - po.packet_len = pkt.size; + po.buffer_id = buffer_id; + if (buffer_id == UINT32_MAX) { + po.packet = dp_packet_data(&pkt); + po.packet_len = dp_packet_size(&pkt); } else { po.packet = NULL; po.packet_len = 0; } - po.in_port = pi.fmd.in_port; + po.in_port = pi.flow_metadata.flow.in_port.ofp_port; po.ofpacts = ofpacts.data; po.ofpacts_len = ofpacts.size; /* Send the packet, and possibly the whole flow, to the output port. */ if (sw->max_idle >= 0 && (!sw->ml || out_port != OFPP_FLOOD)) { - struct ofputil_flow_mod fm; - struct ofpbuf *buffer; - /* The output port is known, or we always flood everything, so add a * new flow. */ - memset(&fm, 0, sizeof fm); + struct ofputil_flow_mod fm = { + .priority = 1, /* Must be > 0 because of table-miss flow entry. */ + .table_id = 0xff, + .command = OFPFC_ADD, + .idle_timeout = sw->max_idle, + .buffer_id = buffer_id, + .out_port = OFPP_NONE, + .ofpacts = ofpacts.data, + .ofpacts_len = ofpacts.size, + }; match_init(&fm.match, &flow, &sw->wc); ofputil_normalize_match_quiet(&fm.match); - fm.priority = 0; - fm.table_id = 0xff; - fm.command = OFPFC_ADD; - fm.idle_timeout = sw->max_idle; - fm.buffer_id = pi.buffer_id; - fm.out_port = OFPP_NONE; - fm.ofpacts = ofpacts.data; - fm.ofpacts_len = ofpacts.size; - buffer = ofputil_encode_flow_mod(&fm, sw->protocol); + + struct ofpbuf *buffer = ofputil_encode_flow_mod(&fm, sw->protocol); queue_tx(sw, buffer); /* If the switch didn't buffer the packet, we need to send a copy. */ - if (pi.buffer_id == UINT32_MAX && out_port != OFPP_NONE) { + if (buffer_id == UINT32_MAX && out_port != OFPP_NONE) { queue_tx(sw, ofputil_encode_packet_out(&po, sw->protocol)); } } else { /* We don't know that MAC, or we don't set up flows. Send along the * packet without setting up a flow. */ - if (pi.buffer_id != UINT32_MAX || out_port != OFPP_NONE) { + if (buffer_id != UINT32_MAX || out_port != OFPP_NONE) { queue_tx(sw, ofputil_encode_packet_out(&po, sw->protocol)); } } @@ -644,3 +615,20 @@ process_echo_request(struct lswitch *sw, const struct ofp_header *rq) { queue_tx(sw, make_echo_reply(rq)); } + +static ofp_port_t +get_mac_entry_ofp_port(const struct mac_learning *ml, + const struct mac_entry *e) + OVS_REQ_RDLOCK(ml->rwlock) +{ + void *port = mac_entry_get_port(ml, e); + return (OVS_FORCE ofp_port_t) (uintptr_t) port; +} + +static void +set_mac_entry_ofp_port(struct mac_learning *ml, + struct mac_entry *e, ofp_port_t ofp_port) + OVS_REQ_WRLOCK(ml->rwlock) +{ + mac_entry_set_port(ml, e, (void *) (OVS_FORCE uintptr_t) ofp_port); +}