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 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. */
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
};
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 *);
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 *,
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;
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) {
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) {
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();
rconn_connect(ofconn->rconn, target, name);
hmap_insert(&mgr->controllers, &ofconn->hmap_node, hash_string(target, 0));
return (ofconn->master_async_config[OAM_PACKET_IN] & bit) != 0;
}
-/* Returns the currently configured flow format for 'ofconn', one of NXFF_*.
+/* 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
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'. */
}
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;
list_push_back(&mgr->all_conns, &ofconn->node);
ofconn->rconn = rconn;
ofconn->type = type;
+ ofconn->enable_async_msgs = enable_async_msgs;
list_init(&ofconn->opgroups);
static void
ofconn_flush(struct ofconn *ofconn)
{
- uint32_t *master = ofconn->master_async_config;
- uint32_t *slave = ofconn->slave_async_config;
int i;
ofconn->role = NX_ROLE_OTHER;
- ofconn->flow_format = NXFF_OPENFLOW10;
+ ofconn->protocol = OFPUTIL_P_OF10;
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
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();
- /* "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;
+ 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
int probe_interval;
ofconn->band = c->band;
+ ofconn->enable_async_msgs = c->enable_async_msgs;
rconn_set_max_backoff(ofconn->rconn, c->max_backoff);
\f
/* 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) {
if (ofconn_receives_async_msg(ofconn, OAM_PORT_STATUS, reason)) {
- struct ofp_port_status *ops;
- struct ofpbuf *b;
+ struct ofpbuf *msg;
- ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b);
- ops->reason = reason;
- ops->desc = *opp;
- ofconn_send(ofconn, b, NULL);
+ msg = ofputil_encode_port_status(&ps, ofconn->protocol);
+ ofconn_send(ofconn, msg, NULL);
}
}
}
* 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);
+ msg = ofputil_encode_flow_removed(fr, ofconn->protocol);
ofconn_send_reply(ofconn, msg);
}
}
* necessary according to their individual configurations. */
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_msg(ofconn, OAM_PACKET_IN, pin->reason)) {
- 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);
}
}
}
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.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. */
* 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);
}
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);
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