X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Flearning-switch.c;h=2b764f6f7e74bd5e4d006508a0f0457b0bdeec41;hb=303721ee82a2e985435d9fc82f8644fcd38a6fe0;hp=e786913c6dbe77a7a0010d5d9adfd31d6945e8fe;hpb=4e022ec09e14ac89add74c1b4b8e3ff3873edbf0;p=cascardo%2Fovs.git diff --git a/lib/learning-switch.c b/lib/learning-switch.c index e786913c6..2b764f6f7 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); @@ -89,6 +90,7 @@ struct lswitch { * to set up the flow table. */ const struct ofputil_flow_mod *default_flows; size_t n_default_flows; + enum ofputil_protocol usable_protocols; }; /* The log messages here could actually be useful in debugging, so keep the @@ -104,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'. * @@ -161,6 +170,7 @@ lswitch_create(struct rconn *rconn, const struct lswitch_config *cfg) sw->default_flows = cfg->default_flows; sw->n_default_flows = cfg->n_default_flows; + sw->usable_protocols = cfg->usable_protocols; sw->queued = rconn_packet_counter_create(); @@ -171,12 +181,44 @@ 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) { - enum ofputil_protocol usable_protocols; struct ofpbuf *msg = NULL; int error = 0; size_t i; @@ -188,10 +230,8 @@ lswitch_handshake(struct lswitch *sw) * This could be improved by actually negotiating a mutually acceptable * flow format with the switch, but that would require an asynchronous * state machine. This version ought to work fine in practice. */ - usable_protocols = ofputil_flow_mod_usable_protocols( - sw->default_flows, sw->n_default_flows); - if (!(protocol & usable_protocols)) { - enum ofputil_protocol want = rightmost_1bit(usable_protocols); + if (!(protocol & sw->usable_protocols)) { + enum ofputil_protocol want = rightmost_1bit(sw->usable_protocols); while (!error) { msg = ofputil_encode_set_protocol(protocol, want, &protocol); if (!msg) { @@ -200,7 +240,7 @@ lswitch_handshake(struct lswitch *sw) error = rconn_send(sw->rconn, msg, NULL); } } - if (protocol & usable_protocols) { + if (protocol & sw->usable_protocols) { for (i = 0; !error && i < sw->n_default_flows; i++) { msg = ofputil_encode_flow_mod(&sw->default_flows[i], protocol); error = rconn_send(sw->rconn, msg, NULL); @@ -208,7 +248,7 @@ lswitch_handshake(struct lswitch *sw) if (error) { VLOG_INFO_RL(&rl, "%s: failed to queue default flows (%s)", - rconn_get_name(sw->rconn), strerror(error)); + rconn_get_name(sw->rconn), ovs_strerror(error)); } } else { VLOG_INFO_RL(&rl, "%s: failed to set usable protocol", @@ -237,7 +277,7 @@ lswitch_destroy(struct lswitch *sw) free(node); } shash_destroy(&sw->queue_names); - mac_learning_destroy(sw->ml); + mac_learning_unref(sw->ml); rconn_packet_counter_destroy(sw->queued); free(sw); } @@ -251,7 +291,9 @@ lswitch_run(struct lswitch *sw) int i; if (sw->ml) { - mac_learning_run(sw->ml, NULL); + ovs_rwlock_wrlock(&sw->ml->rwlock); + mac_learning_run(sw->ml); + ovs_rwlock_unlock(&sw->ml->rwlock); } rconn_run(sw->rconn); @@ -283,7 +325,9 @@ void lswitch_wait(struct lswitch *sw) { if (sw->ml) { + ovs_rwlock_rdlock(&sw->ml->rwlock); mac_learning_wait(sw->ml); + ovs_rwlock_unlock(&sw->ml->rwlock); } rconn_run_wait(sw->rconn); rconn_recv_wait(sw->rconn); @@ -310,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; @@ -323,82 +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_PORT_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_REQUEST: - case OFPTYPE_GROUP_REPLY: - case OFPTYPE_GROUP_DESC_REQUEST: - case OFPTYPE_GROUP_DESC_REPLY: - case OFPTYPE_GROUP_FEATURES_REQUEST: - case OFPTYPE_GROUP_FEATURES_REPLY: - case OFPTYPE_METER_REQUEST: - case OFPTYPE_METER_REPLY: - case OFPTYPE_METER_CONFIG_REQUEST: - case OFPTYPE_METER_CONFIG_REPLY: - case OFPTYPE_METER_FEATURES_REQUEST: - case OFPTYPE_METER_FEATURES_REPLY: - case OFPTYPE_TABLE_FEATURES_REQUEST: - case OFPTYPE_TABLE_FEATURES_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); } } @@ -406,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); @@ -416,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 @@ -433,7 +406,7 @@ queue_tx(struct lswitch *sw, struct ofpbuf *b) } else { VLOG_WARN_RL(&rl, "%016llx: %s: send: %s", sw->datapath_id, rconn_get_name(sw->rconn), - strerror(retval)); + ovs_strerror(retval)); } } } @@ -460,7 +433,7 @@ process_switch_features(struct lswitch *sw, struct ofp_header *oh) if (lp && hmap_node_is_null(&lp->hmap_node)) { lp->port_no = port.port_no; hmap_insert(&sw->queue_numbers, &lp->hmap_node, - hash_int(ofp_to_u16(lp->port_no), 0)); + hash_ofp_port(lp->port_no)); } } return 0; @@ -472,17 +445,22 @@ lswitch_choose_destination(struct lswitch *sw, const struct flow *flow) ofp_port_t out_port; /* Learn the source MAC. */ - 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_entry_is_new(mac) - || 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, mac); + 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); } /* Drop frames for reserved multicast addresses. */ @@ -494,14 +472,17 @@ lswitch_choose_destination(struct lswitch *sw, const struct flow *flow) if (sw->ml) { struct mac_entry *mac; - mac = mac_learning_lookup(sw->ml, flow->dl_dst, 0, NULL); + 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); return OFPP_NONE; } } + ovs_rwlock_unlock(&sw->ml->rwlock); } /* Check if we need to use "NORMAL" action. */ @@ -517,7 +498,7 @@ get_queue_id(const struct lswitch *sw, ofp_port_t in_port) { const struct lswitch_port *port; - HMAP_FOR_EACH_WITH_HASH (port, hmap_node, hash_int(ofp_to_u16(in_port), 0), + HMAP_FOR_EACH_WITH_HASH (port, hmap_node, hash_ofp_port(in_port), &sw->queue_numbers) { if (port->port_no == in_port) { return port->queue_id; @@ -540,9 +521,8 @@ 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); if (error) { @@ -559,16 +539,16 @@ process_packet_in(struct lswitch *sw, const struct ofp_header *oh) } /* 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; + dp_packet_use_const(&pkt, pi.packet, pi.packet_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. */ @@ -580,40 +560,38 @@ 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.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 = pi.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); @@ -635,3 +613,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); +}