X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fconnmgr.c;h=69534c3d6935c3ba05bbed77d38931b9544bca3d;hb=67e96a5dca90225358936b1392bba8b3207805b1;hp=887080acbbad9fc592af5c228d96c86f276116af;hpb=f0fd1a1772665ea57662281d9cccadb0f0146196;p=openvswitch diff --git a/ofproto/connmgr.c b/ofproto/connmgr.c index 887080ac..69534c3d 100644 --- a/ofproto/connmgr.c +++ b/ofproto/connmgr.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011 Nicira Networks. + * Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -43,10 +43,21 @@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); /* An OpenFlow connection. */ struct ofconn { - struct connmgr *connmgr; /* Connection's manager. */ +/* Configuration that persists from one connection to the next. */ + struct list node; /* In struct connmgr's "all_conns" list. */ + struct hmap_node hmap_node; /* In struct connmgr's "controllers" map. */ + + struct connmgr *connmgr; /* Connection's manager. */ struct rconn *rconn; /* OpenFlow connection. */ enum ofconn_type type; /* Type. */ + enum ofproto_band band; /* In-band or out-of-band? */ + bool enable_async_msgs; /* Initially enable async messages? */ + +/* State that should be cleared from one connection to the next. */ + + /* OpenFlow state. */ + enum nx_role role; /* Role. */ enum nx_flow_format flow_format; /* Currently selected flow format. */ enum nx_packet_in_format packet_in_format; /* OFPT_PACKET_IN format. */ bool flow_mod_table_id; /* NXT_FLOW_MOD_TABLE_ID enabled? */ @@ -62,6 +73,7 @@ struct ofconn { struct pinsched *schedulers[N_SCHEDULERS]; struct pktbuf *pktbuf; /* OpenFlow packet buffers. */ int miss_send_len; /* Bytes to send of buffered packets. */ + uint16_t controller_id; /* Connection controller ID. */ /* Number of OpenFlow messages queued on 'rconn' as replies to OpenFlow * requests, and the maximum number before we stop reading OpenFlow @@ -69,17 +81,18 @@ struct ofconn { #define OFCONN_REPLY_MAX 100 struct rconn_packet_counter *reply_counter; - /* type == OFCONN_PRIMARY only. */ - enum nx_role role; /* Role. */ - bool invalid_ttl_to_controller; /* Send packets with invalid TTL - to the controller. */ - struct hmap_node hmap_node; /* In struct connmgr's "controllers" map. */ - enum ofproto_band band; /* In-band or out-of-band? */ + /* Asynchronous message configuration in each possible roles. + * + * A 1-bit enables sending an asynchronous message for one possible reason + * that the message might be generated, a 0-bit disables it. */ + uint32_t master_async_config[OAM_N_TYPES]; /* master, other */ + uint32_t slave_async_config[OAM_N_TYPES]; /* slave */ }; static struct ofconn *ofconn_create(struct connmgr *, struct rconn *, - enum ofconn_type); + enum ofconn_type, bool enable_async_msgs); static void ofconn_destroy(struct ofconn *); +static void ofconn_flush(struct ofconn *); static void ofconn_reconfigure(struct ofconn *, const struct ofproto_controller *); @@ -94,8 +107,6 @@ static char *ofconn_make_name(const struct connmgr *, const char *target); static void ofconn_set_rate_limit(struct ofconn *, int rate, int burst); -static bool ofconn_receives_async_msgs(const struct ofconn *); - static void ofconn_send(const struct ofconn *, struct ofpbuf *, struct rconn_packet_counter *); @@ -111,6 +122,7 @@ struct ofservice { int probe_interval; /* Max idle time before probing, in seconds. */ int rate_limit; /* Max packet-in rate in packets per second. */ int burst_limit; /* Limit on accumulating packet credits. */ + bool enable_async_msgs; /* Initially enable async messages? */ }; static void ofservice_reconfigure(struct ofservice *, @@ -274,7 +286,8 @@ connmgr_run(struct connmgr *mgr, rconn_connect_unreliably(rconn, vconn, name); free(name); - ofconn = ofconn_create(mgr, rconn, OFCONN_SERVICE); + ofconn = ofconn_create(mgr, rconn, OFCONN_SERVICE, + ofservice->enable_async_msgs); ofconn_set_rate_limit(ofconn, ofservice->rate_limit, ofservice->burst_limit); } else if (retval != EAGAIN) { @@ -552,9 +565,8 @@ add_controller(struct connmgr *mgr, const char *target) char *name = ofconn_make_name(mgr, target); struct ofconn *ofconn; - ofconn = ofconn_create(mgr, rconn_create(5, 8), OFCONN_PRIMARY); + ofconn = ofconn_create(mgr, rconn_create(5, 8), OFCONN_PRIMARY, true); ofconn->pktbuf = pktbuf_create(); - ofconn->miss_send_len = OFP_DEFAULT_MISS_SEND_LEN; rconn_connect(ofconn->rconn, target, name); hmap_insert(&mgr->controllers, &ofconn->hmap_node, hash_string(target, 0)); @@ -757,15 +769,21 @@ ofconn_set_role(struct ofconn *ofconn, enum nx_role role) } void -ofconn_set_invalid_ttl_to_controller(struct ofconn *ofconn, bool val) +ofconn_set_invalid_ttl_to_controller(struct ofconn *ofconn, bool enable) { - ofconn->invalid_ttl_to_controller = val; + uint32_t bit = 1u << OFPR_INVALID_TTL; + if (enable) { + ofconn->master_async_config[OAM_PACKET_IN] |= bit; + } else { + ofconn->master_async_config[OAM_PACKET_IN] &= ~bit; + } } bool ofconn_get_invalid_ttl_to_controller(struct ofconn *ofconn) { - return ofconn->invalid_ttl_to_controller; + uint32_t bit = 1u << OFPR_INVALID_TTL; + return (ofconn->master_async_config[OAM_PACKET_IN] & bit) != 0; } /* Returns the currently configured flow format for 'ofconn', one of NXFF_*. @@ -803,6 +821,16 @@ ofconn_set_packet_in_format(struct ofconn *ofconn, ofconn->packet_in_format = packet_in_format; } +/* Sets the controller connection ID for 'ofconn' to 'controller_id'. + * + * The connection controller ID is used for OFPP_CONTROLLER and + * NXAST_CONTROLLER actions. See "struct nx_action_controller" for details. */ +void +ofconn_set_controller_id(struct ofconn *ofconn, uint16_t controller_id) +{ + ofconn->controller_id = controller_id; +} + /* Returns true if the NXT_FLOW_MOD_TABLE_ID extension is enabled, false * otherwise. * @@ -835,6 +863,16 @@ ofconn_set_miss_send_len(struct ofconn *ofconn, int miss_send_len) ofconn->miss_send_len = miss_send_len; } +void +ofconn_set_async_config(struct ofconn *ofconn, + const uint32_t master_masks[OAM_N_TYPES], + const uint32_t slave_masks[OAM_N_TYPES]) +{ + size_t size = sizeof ofconn->master_async_config; + memcpy(ofconn->master_async_config, master_masks, size); + memcpy(ofconn->slave_async_config, slave_masks, size); +} + /* Sends 'msg' on 'ofconn', accounting it as a reply. (If there is a * sufficient number of OpenFlow replies in-flight on a single ofconn, then the * connmgr will stop accepting new OpenFlow requests on that ofconn until the @@ -929,40 +967,99 @@ ofconn_get_target(const struct ofconn *ofconn) } static struct ofconn * -ofconn_create(struct connmgr *mgr, struct rconn *rconn, enum ofconn_type type) +ofconn_create(struct connmgr *mgr, struct rconn *rconn, enum ofconn_type type, + bool enable_async_msgs) { - struct ofconn *ofconn = xzalloc(sizeof *ofconn); + struct ofconn *ofconn; + + ofconn = xzalloc(sizeof *ofconn); ofconn->connmgr = mgr; list_push_back(&mgr->all_conns, &ofconn->node); ofconn->rconn = rconn; ofconn->type = type; - ofconn->flow_format = NXFF_OPENFLOW10; - ofconn->packet_in_format = NXPIF_OPENFLOW10; - ofconn->flow_mod_table_id = false; + ofconn->enable_async_msgs = enable_async_msgs; + list_init(&ofconn->opgroups); - ofconn->role = NX_ROLE_OTHER; - ofconn->packet_in_counter = rconn_packet_counter_create (); - ofconn->pktbuf = NULL; - ofconn->miss_send_len = 0; - ofconn->reply_counter = rconn_packet_counter_create (); - ofconn->invalid_ttl_to_controller = false; + + ofconn_flush(ofconn); + return ofconn; } -/* Disassociates 'ofconn' from all of the ofopgroups that it initiated that - * have not yet completed. (Those ofopgroups will still run to completion in - * the usual way, but any errors that they run into will not be reported on any - * OpenFlow channel.) - * - * Also discards any blocked operation on 'ofconn'. */ +/* Clears all of the state in 'ofconn' that should not persist from one + * connection to the next. */ static void ofconn_flush(struct ofconn *ofconn) { + int i; + + ofconn->role = NX_ROLE_OTHER; + ofconn->flow_format = NXFF_OPENFLOW10; + ofconn->packet_in_format = NXPIF_OPENFLOW10; + ofconn->flow_mod_table_id = false; + + /* Disassociate 'ofconn' from all of the ofopgroups that it initiated that + * have not yet completed. (Those ofopgroups will still run to completion + * in the usual way, but any errors that they run into will not be reported + * on any OpenFlow channel.) + * + * Also discard any blocked operation on 'ofconn'. */ while (!list_is_empty(&ofconn->opgroups)) { list_init(list_pop_front(&ofconn->opgroups)); } ofpbuf_delete(ofconn->blocked); ofconn->blocked = NULL; + + rconn_packet_counter_destroy(ofconn->packet_in_counter); + ofconn->packet_in_counter = rconn_packet_counter_create(); + for (i = 0; i < N_SCHEDULERS; i++) { + if (ofconn->schedulers[i]) { + int rate, burst; + + pinsched_get_limits(ofconn->schedulers[i], &rate, &burst); + pinsched_destroy(ofconn->schedulers[i]); + ofconn->schedulers[i] = pinsched_create(rate, burst); + } + } + if (ofconn->pktbuf) { + pktbuf_destroy(ofconn->pktbuf); + ofconn->pktbuf = pktbuf_create(); + } + ofconn->miss_send_len = (ofconn->type == OFCONN_PRIMARY + ? OFP_DEFAULT_MISS_SEND_LEN + : 0); + ofconn->controller_id = 0; + + rconn_packet_counter_destroy(ofconn->reply_counter); + ofconn->reply_counter = rconn_packet_counter_create(); + + if (ofconn->enable_async_msgs) { + uint32_t *master = ofconn->master_async_config; + uint32_t *slave = ofconn->slave_async_config; + + /* "master" and "other" roles get all asynchronous messages by default, + * except that the controller needs to enable nonstandard "packet-in" + * reasons itself. */ + master[OAM_PACKET_IN] = (1u << OFPR_NO_MATCH) | (1u << OFPR_ACTION); + master[OAM_PORT_STATUS] = ((1u << OFPPR_ADD) + | (1u << OFPPR_DELETE) + | (1u << OFPPR_MODIFY)); + master[OAM_FLOW_REMOVED] = ((1u << OFPRR_IDLE_TIMEOUT) + | (1u << OFPRR_HARD_TIMEOUT) + | (1u << OFPRR_DELETE)); + + /* "slave" role gets port status updates by default. */ + slave[OAM_PACKET_IN] = 0; + slave[OAM_PORT_STATUS] = ((1u << OFPPR_ADD) + | (1u << OFPPR_DELETE) + | (1u << OFPPR_MODIFY)); + slave[OAM_FLOW_REMOVED] = 0; + } else { + memset(ofconn->master_async_config, 0, + sizeof ofconn->master_async_config); + memset(ofconn->slave_async_config, 0, + sizeof ofconn->slave_async_config); + } } static void @@ -1067,42 +1164,42 @@ ofconn_wait(struct ofconn *ofconn, bool handling_openflow) } } -/* Returns true if 'ofconn' should receive asynchronous messages. */ +/* Returns true if 'ofconn' should receive asynchronous messages of the given + * OAM_* 'type' and 'reason', which should be a OFPR_* value for OAM_PACKET_IN, + * a OFPPR_* value for OAM_PORT_STATUS, or an OFPRR_* value for + * OAM_FLOW_REMOVED. Returns false if the message should not be sent on + * 'ofconn'. */ static bool -ofconn_receives_async_msgs__(const struct ofconn *ofconn) +ofconn_receives_async_msg(const struct ofconn *ofconn, + enum ofconn_async_msg_type type, + unsigned int reason) { - if (ofconn->type == OFCONN_PRIMARY) { - /* Primary controllers always get asynchronous messages unless they - * have configured themselves as "slaves". */ - return ofconn->role != NX_ROLE_SLAVE; - } else { - /* Service connections don't get asynchronous messages unless they have - * explicitly asked for them by setting a nonzero miss send length. */ - return ofconn->miss_send_len > 0; - } -} + const uint32_t *async_config; + + assert(reason < 32); + assert((unsigned int) type < OAM_N_TYPES); -static bool -ofconn_receives_async_msgs(const struct ofconn *ofconn) -{ if (!rconn_is_connected(ofconn->rconn)) { return false; - } else { - return ofconn_receives_async_msgs__(ofconn); } -} -static bool -ofconn_interested_in_packet(const struct ofconn *ofconn, - const struct ofputil_packet_in *pin) -{ - if (!rconn_is_connected(ofconn->rconn)) { + /* Keep the following code in sync with the documentation in the + * "Asynchronous Messages" section in DESIGN. */ + + if (ofconn->type == OFCONN_SERVICE && !ofconn->miss_send_len) { + /* Service connections don't get asynchronous messages unless they have + * explicitly asked for them by setting a nonzero miss send length. */ return false; - } else if (pin->reason == OFPR_INVALID_TTL) { - return ofconn->invalid_ttl_to_controller; - } else { - return ofconn_receives_async_msgs__(ofconn); } + + async_config = (ofconn->role == NX_ROLE_SLAVE + ? ofconn->slave_async_config + : ofconn->master_async_config); + if (!(async_config[type] & (1u << reason))) { + return false; + } + + return true; } /* Returns a human-readable name for an OpenFlow connection between 'mgr' and @@ -1162,20 +1259,15 @@ connmgr_send_port_status(struct connmgr *mgr, const struct ofp_phy_port *opp, struct ofconn *ofconn; LIST_FOR_EACH (ofconn, node, &mgr->all_conns) { - struct ofp_port_status *ops; - struct ofpbuf *b; - - /* Primary controllers, even slaves, should always get port status - updates. Otherwise obey ofconn_receives_async_msgs(). */ - if (ofconn->type != OFCONN_PRIMARY - && !ofconn_receives_async_msgs(ofconn)) { - continue; + if (ofconn_receives_async_msg(ofconn, OAM_PORT_STATUS, reason)) { + struct ofp_port_status *ops; + struct ofpbuf *b; + + ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b); + ops->reason = reason; + ops->desc = *opp; + ofconn_send(ofconn, b, NULL); } - - ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b); - ops->reason = reason; - ops->desc = *opp; - ofconn_send(ofconn, b, NULL); } } @@ -1188,19 +1280,17 @@ connmgr_send_flow_removed(struct connmgr *mgr, struct ofconn *ofconn; LIST_FOR_EACH (ofconn, node, &mgr->all_conns) { - struct ofpbuf *msg; - - if (!ofconn_receives_async_msgs(ofconn)) { - continue; + if (ofconn_receives_async_msg(ofconn, OAM_FLOW_REMOVED, fr->reason)) { + struct ofpbuf *msg; + + /* Account flow expirations as replies to OpenFlow requests. That + * works because preventing OpenFlow requests from being processed + * also prevents new flows from being added (and expiring). (It + * also prevents processing OpenFlow requests that would not add + * new flows, so it is imperfect.) */ + msg = ofputil_encode_flow_removed(fr, ofconn->flow_format); + ofconn_send_reply(ofconn, msg); } - - /* Account flow expirations as replies to OpenFlow requests. That - * works because preventing OpenFlow requests from being processed also - * prevents new flows from being added (and expiring). (It also - * prevents processing OpenFlow requests that would not add new flows, - * so it is imperfect.) */ - msg = ofputil_encode_flow_removed(fr, ofconn->flow_format); - ofconn_send_reply(ofconn, msg); } } @@ -1214,7 +1304,8 @@ connmgr_send_packet_in(struct connmgr *mgr, struct ofconn *ofconn; LIST_FOR_EACH (ofconn, node, &mgr->all_conns) { - if (ofconn_interested_in_packet(ofconn, pin)) { + if (ofconn_receives_async_msg(ofconn, OAM_PACKET_IN, pin->reason) + && ofconn->controller_id == pin->controller_id) { schedule_packet_in(ofconn, *pin, flow); } } @@ -1532,6 +1623,7 @@ ofservice_reconfigure(struct ofservice *ofservice, ofservice->probe_interval = c->probe_interval; ofservice->rate_limit = c->rate_limit; ofservice->burst_limit = c->burst_limit; + ofservice->enable_async_msgs = c->enable_async_msgs; } /* Finds and returns the ofservice within 'mgr' that has the given