X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Flearning-switch.c;h=19a90dbc9eb3f59ab639e9bdf8e44086f1d796f9;hb=8f79bb4d3999d993424e9578342b4130d10a556c;hp=c1cd909f5ed47586b1c14c2c779e082f32c6d30a;hpb=125ee67317fcaa2fd11ab1671c268015105d191d;p=cascardo%2Fovs.git diff --git a/lib/learning-switch.c b/lib/learning-switch.c index c1cd909f5..19a90dbc9 100644 --- a/lib/learning-switch.c +++ b/lib/learning-switch.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012 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,14 +42,14 @@ #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); struct lswitch_port { struct hmap_node hmap_node; /* Hash node for port number. */ - uint16_t port_no; /* OpenFlow port number, in host byte order. */ + ofp_port_t port_no; /* OpenFlow port number. */ uint32_t queue_id; /* OpenFlow queue number. */ }; @@ -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,15 +240,19 @@ lswitch_handshake(struct lswitch *sw) error = rconn_send(sw->rconn, msg, NULL); } } + 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); + } - 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); - } - - if (error) { - VLOG_INFO_RL(&rl, "%s: failed to queue default flows (%s)", - rconn_get_name(sw->rconn), strerror(error)); + if (error) { + VLOG_INFO_RL(&rl, "%s: failed to queue default flows (%s)", + rconn_get_name(sw->rconn), ovs_strerror(error)); + } + } else { + VLOG_INFO_RL(&rl, "%s: failed to set usable protocol", + rconn_get_name(sw->rconn)); } } sw->protocol = protocol; @@ -233,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); } @@ -247,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); @@ -279,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); @@ -306,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; @@ -319,63 +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_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_ASYNC_CONFIG: - 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: - 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); } } @@ -383,20 +380,19 @@ static void send_features_request(struct lswitch *sw) { struct ofpbuf *b; - struct ofp_switch_config *osc; int ofp_version = rconn_get_version(sw->rconn); - assert(ofp_version > 0 && ofp_version < 0xff); + ovs_assert(ofp_version > 0 && ofp_version < 0xff); /* Send OFPT_FEATURES_REQUEST. */ b = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, ofp_version, 0); 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 @@ -410,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)); } } } @@ -420,10 +416,9 @@ process_switch_features(struct lswitch *sw, struct ofp_header *oh) { struct ofputil_switch_features features; struct ofputil_phy_port port; - enum ofperr error; - struct ofpbuf b; - error = ofputil_decode_switch_features(oh, &features, &b); + struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length)); + enum ofperr error = ofputil_pull_switch_features(&b, &features); if (error) { VLOG_ERR("received invalid switch feature reply (%s)", ofperr_to_string(error)); @@ -437,28 +432,34 @@ 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(lp->port_no, 0)); + hash_ofp_port(lp->port_no)); } } return 0; } -static uint16_t +static ofp_port_t lswitch_choose_destination(struct lswitch *sw, const struct flow *flow) { - uint16_t out_port; + 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.i != flow->in_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); - - mac->port.i = flow->in_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. */ @@ -470,14 +471,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.i; - if (out_port == flow->in_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. */ @@ -489,11 +493,11 @@ lswitch_choose_destination(struct lswitch *sw, const struct flow *flow) } static uint32_t -get_queue_id(const struct lswitch *sw, uint16_t in_port) +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(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; @@ -507,8 +511,9 @@ static void process_packet_in(struct lswitch *sw, const struct ofp_header *oh) { struct ofputil_packet_in pi; + uint32_t buffer_id; uint32_t queue_id; - uint16_t out_port; + ofp_port_t out_port; uint64_t ofpacts_stub[64 / 8]; struct ofpbuf ofpacts; @@ -516,10 +521,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; - error = ofputil_decode_packet_in(&pi, oh); + error = ofputil_decode_packet_in(oh, true, &pi, NULL, &buffer_id, NULL); if (error) { VLOG_WARN_RL(&rl, "failed to decode packet-in: %s", ofperr_to_string(error)); @@ -533,70 +538,72 @@ 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); - flow_extract(&pkt, 0, pi.fmd.tun_id, pi.fmd.in_port, &flow); + /* Extract flow data from 'pi' into 'flow'. */ + 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. */ - } else if (queue_id == UINT32_MAX || out_port >= OFPP_MAX) { + } else if (queue_id == UINT32_MAX + || ofp_to_u16(out_port) >= ofp_to_u16(OFPP_MAX)) { ofpact_put_OUTPUT(&ofpacts)->port = out_port; } else { struct ofpact_enqueue *enqueue = ofpact_put_ENQUEUE(&ofpacts); 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); - cls_rule_init(&flow, &sw->wc, 0, &fm.cr); - ofputil_normalize_rule_quiet(&fm.cr); - 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 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); + + 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) { - queue_tx(sw, ofputil_encode_packet_out(&po)); + 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) { - queue_tx(sw, ofputil_encode_packet_out(&po)); + if (buffer_id != UINT32_MAX || out_port != OFPP_NONE) { + queue_tx(sw, ofputil_encode_packet_out(&po, sw->protocol)); } } } @@ -606,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); +}