X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fconnmgr.c;h=1f5fbed90bc2c0f30736db0e4fb8ad75f4f184ba;hb=2ed1202f141ecbda901c6531829273ea2ad8f1c8;hp=46d6d7962ff72561ea113746543b784ba946c39a;hpb=548349603423bea41ec2989583231c1a117f6a9e;p=sliver-openvswitch.git diff --git a/ofproto/connmgr.c b/ofproto/connmgr.c index 46d6d7962..1f5fbed90 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,13 +43,23 @@ 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 nx_flow_format flow_format; /* Currently selected flow format. */ + 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 ofputil_protocol protocol; /* Current protocol variant. */ enum nx_packet_in_format packet_in_format; /* OFPT_PACKET_IN format. */ - bool flow_mod_table_id; /* NXT_FLOW_MOD_TABLE_ID enabled? */ /* Asynchronous flow table operation support. */ struct list opgroups; /* Contains pending "ofopgroups", if any. */ @@ -62,6 +72,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,15 +80,18 @@ struct ofconn { #define OFCONN_REPLY_MAX 100 struct rconn_packet_counter *reply_counter; - /* type == OFCONN_PRIMARY only. */ - enum nx_role role; /* Role. */ - 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 *); @@ -92,8 +106,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 *); @@ -109,6 +121,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 *, @@ -262,7 +275,7 @@ connmgr_run(struct connmgr *mgr, struct vconn *vconn; int retval; - retval = pvconn_accept(ofservice->pvconn, OFP_VERSION, &vconn); + retval = pvconn_accept(ofservice->pvconn, OFP10_VERSION, &vconn); if (!retval) { struct rconn *rconn; char *name; @@ -272,7 +285,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) { @@ -284,7 +298,7 @@ connmgr_run(struct connmgr *mgr, struct vconn *vconn; int retval; - retval = pvconn_accept(mgr->snoops[i], OFP_VERSION, &vconn); + retval = pvconn_accept(mgr->snoops[i], OFP10_VERSION, &vconn); if (!retval) { add_snooper(mgr, vconn); } else if (retval != EAGAIN) { @@ -550,9 +564,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)); @@ -754,20 +767,41 @@ ofconn_set_role(struct ofconn *ofconn, enum nx_role role) ofconn->role = role; } -/* Returns the currently configured flow format for 'ofconn', one of NXFF_*. +void +ofconn_set_invalid_ttl_to_controller(struct ofconn *ofconn, bool enable) +{ + 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) +{ + uint32_t bit = 1u << OFPR_INVALID_TTL; + return (ofconn->master_async_config[OAM_PACKET_IN] & bit) != 0; +} + +/* Returns the currently configured protocol for 'ofconn', one of OFPUTIL_P_*. * - * The default, if no other format has been set, is NXFF_OPENFLOW10. */ -enum nx_flow_format -ofconn_get_flow_format(struct ofconn *ofconn) + * The default, if no other format has been set, is OFPUTIL_P_OPENFLOW10. */ +enum ofputil_protocol +ofconn_get_protocol(struct ofconn *ofconn) { - return ofconn->flow_format; + return ofconn->protocol; } -/* Sets the flow format for 'ofconn' to 'flow_format' (one of NXFF_*). */ +/* Sets the protocol for 'ofconn' to 'protocol' (one of OFPUTIL_P_*). + * + * (This doesn't actually send anything to accomplish this. Presumably the + * caller already did that.) */ void -ofconn_set_flow_format(struct ofconn *ofconn, enum nx_flow_format flow_format) +ofconn_set_protocol(struct ofconn *ofconn, enum ofputil_protocol protocol) { - ofconn->flow_format = flow_format; + ofconn->protocol = protocol; } /* Returns the currently configured packet in format for 'ofconn', one of @@ -789,22 +823,14 @@ ofconn_set_packet_in_format(struct ofconn *ofconn, ofconn->packet_in_format = packet_in_format; } -/* Returns true if the NXT_FLOW_MOD_TABLE_ID extension is enabled, false - * otherwise. +/* Sets the controller connection ID for 'ofconn' to 'controller_id'. * - * By default the extension is not enabled. */ -bool -ofconn_get_flow_mod_table_id(const struct ofconn *ofconn) -{ - return ofconn->flow_mod_table_id; -} - -/* Enables or disables (according to 'enable') the NXT_FLOW_MOD_TABLE_ID - * extension on 'ofconn'. */ + * The connection controller ID is used for OFPP_CONTROLLER and + * NXAST_CONTROLLER actions. See "struct nx_action_controller" for details. */ void -ofconn_set_flow_mod_table_id(struct ofconn *ofconn, bool enable) +ofconn_set_controller_id(struct ofconn *ofconn, uint16_t controller_id) { - ofconn->flow_mod_table_id = enable; + ofconn->controller_id = controller_id; } /* Returns the default miss send length for 'ofconn'. */ @@ -821,6 +847,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 @@ -844,24 +880,22 @@ ofconn_send_replies(const struct ofconn *ofconn, struct list *replies) } } -/* Sends 'error', which should be an OpenFlow error created with - * e.g. ofp_mkerr(), on 'ofconn', as a reply to 'request'. Only at most the +/* Sends 'error' on 'ofconn', as a reply to 'request'. Only at most the * first 64 bytes of 'request' are used. */ void ofconn_send_error(const struct ofconn *ofconn, - const struct ofp_header *request, int error) + const struct ofp_header *request, enum ofperr error) { - struct ofpbuf *msg; + struct ofpbuf *reply; - msg = ofputil_encode_error_msg(error, request); - if (msg) { + reply = ofperr_encode_reply(error, request); + if (reply) { static struct vlog_rate_limit err_rl = VLOG_RATE_LIMIT_INIT(10, 10); if (!VLOG_DROP_INFO(&err_rl)) { const struct ofputil_msg_type *type; const char *type_name; size_t request_len; - char *error_s; request_len = ntohs(request->length); type_name = (!ofputil_decode_msg_type_partial(request, @@ -870,17 +904,16 @@ ofconn_send_error(const struct ofconn *ofconn, ? ofputil_msg_type_name(type) : "invalid"); - error_s = ofputil_error_to_string(error); VLOG_INFO("%s: sending %s error reply to %s message", - rconn_get_name(ofconn->rconn), error_s, type_name); - free(error_s); + rconn_get_name(ofconn->rconn), ofperr_to_string(error), + type_name); } - ofconn_send_reply(ofconn, msg); + ofconn_send_reply(ofconn, reply); } } /* Same as pktbuf_retrieve(), using the pktbuf owned by 'ofconn'. */ -int +enum ofperr ofconn_pktbuf_retrieve(struct ofconn *ofconn, uint32_t id, struct ofpbuf **bufferp, uint16_t *in_port) { @@ -918,39 +951,98 @@ 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_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->protocol = OFPUTIL_P_OF10; + ofconn->packet_in_format = NXPIF_OPENFLOW10; + + /* 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 @@ -978,6 +1070,7 @@ ofconn_reconfigure(struct ofconn *ofconn, const struct ofproto_controller *c) int probe_interval; ofconn->band = c->band; + ofconn->enable_async_msgs = c->enable_async_msgs; rconn_set_max_backoff(ofconn->rconn, c->max_backoff); @@ -1055,21 +1148,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) { + const uint32_t *async_config; + + assert(reason < 32); + assert((unsigned int) type < OAM_N_TYPES); + if (!rconn_is_connected(ofconn->rconn)) { return false; - } else 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 { + } + + /* 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 ofconn->miss_send_len > 0; + return false; + } + + 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 @@ -1116,33 +1230,27 @@ ofconn_send(const struct ofconn *ofconn, struct ofpbuf *msg, /* Sending asynchronous messages. */ -static void schedule_packet_in(struct ofconn *, struct ofputil_packet_in, - const struct flow *); +static void schedule_packet_in(struct ofconn *, struct ofputil_packet_in); /* Sends an OFPT_PORT_STATUS message with 'opp' and 'reason' to appropriate * controllers managed by 'mgr'. */ void -connmgr_send_port_status(struct connmgr *mgr, const struct ofp_phy_port *opp, - uint8_t reason) +connmgr_send_port_status(struct connmgr *mgr, + const struct ofputil_phy_port *pp, uint8_t reason) { /* XXX Should limit the number of queued port status change messages. */ + struct ofputil_port_status ps; struct ofconn *ofconn; + ps.reason = reason; + ps.desc = *pp; LIST_FOR_EACH (ofconn, node, &mgr->all_conns) { - struct ofp_port_status *ops; - struct ofpbuf *b; + if (ofconn_receives_async_msg(ofconn, OAM_PORT_STATUS, reason)) { + struct ofpbuf *msg; - /* 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; + msg = ofputil_encode_port_status(&ps, ofconn->protocol); + ofconn_send(ofconn, msg, NULL); } - - ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b); - ops->reason = reason; - ops->desc = *opp; - ofconn_send(ofconn, b, NULL); } } @@ -1155,34 +1263,34 @@ 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->protocol); + 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); } } /* Given 'pin', sends an OFPT_PACKET_IN message to each OpenFlow controller as - * necessary according to their individual configurations. */ + * necessary according to their individual configurations. + * + * The caller doesn't need to fill in pin->buffer_id or pin->total_len. */ void connmgr_send_packet_in(struct connmgr *mgr, - const struct ofputil_packet_in *pin, - const struct flow *flow) + const struct ofputil_packet_in *pin) { struct ofconn *ofconn; LIST_FOR_EACH (ofconn, node, &mgr->all_conns) { - if (ofconn_receives_async_msgs(ofconn)) { - schedule_packet_in(ofconn, *pin, flow); + if (ofconn_receives_async_msg(ofconn, OAM_PACKET_IN, pin->reason) + && ofconn->controller_id == pin->controller_id) { + schedule_packet_in(ofconn, *pin); } } } @@ -1197,15 +1305,15 @@ do_send_packet_in(struct ofpbuf *ofp_packet_in, void *ofconn_) ofconn->packet_in_counter, 100); } -/* Takes 'pin', whose packet has the flow specified by 'flow', composes an - * OpenFlow packet-in message from it, and passes it to 'ofconn''s packet - * scheduler for sending. */ +/* Takes 'pin', composes an OpenFlow packet-in message from it, and passes it + * to 'ofconn''s packet scheduler for sending. */ static void -schedule_packet_in(struct ofconn *ofconn, struct ofputil_packet_in pin, - const struct flow *flow) +schedule_packet_in(struct ofconn *ofconn, struct ofputil_packet_in pin) { struct connmgr *mgr = ofconn->connmgr; + pin.total_len = pin.packet_len; + /* Get OpenFlow buffer_id. */ if (pin.reason == OFPR_ACTION) { pin.buffer_id = UINT32_MAX; @@ -1215,7 +1323,7 @@ schedule_packet_in(struct ofconn *ofconn, struct ofputil_packet_in pin, pin.buffer_id = UINT32_MAX; } else { pin.buffer_id = pktbuf_save(ofconn->pktbuf, pin.packet, pin.packet_len, - flow->in_port); + pin.fmd.in_port); } /* Figure out how much of the packet to send. */ @@ -1233,7 +1341,7 @@ schedule_packet_in(struct ofconn *ofconn, struct ofputil_packet_in pin, * immediately call into do_send_packet_in() or it might buffer it for a * while (until a later call to pinsched_run()). */ pinsched_send(ofconn->schedulers[pin.reason == OFPR_NO_MATCH ? 0 : 1], - flow->in_port, + pin.fmd.in_port, ofputil_encode_packet_in(&pin, ofconn->packet_in_format), do_send_packet_in, ofconn); } @@ -1452,7 +1560,7 @@ connmgr_flushed(struct connmgr *mgr) struct cls_rule rule; memset(&action, 0, sizeof action); - action.type = htons(OFPAT_OUTPUT); + action.type = htons(OFPAT10_OUTPUT); action.output.len = htons(sizeof action); action.output.port = htons(OFPP_NORMAL); cls_rule_init_catchall(&rule, 0); @@ -1499,6 +1607,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