X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=d8215a85d5bb83375a066559c85faa57fe280cb7;hb=487ec65f157060b83ee050dc516ddd792574543b;hp=c5bac6bd96c8dfa1211fe9e57e223fd17b9eb1b8;hpb=0ade584ebe8ca1a1de92fb7422566726f276918c;p=openvswitch diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index c5bac6bd..d8215a85 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -1,5 +1,6 @@ /* * Copyright (c) 2009, 2010 Nicira Networks. + * Copyright (c) 2010 Jean Tourrilhes - HP-Labs. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,6 +19,7 @@ #include "ofproto.h" #include #include +#include #include #include #include @@ -165,27 +167,71 @@ static void rule_post_uninstall(struct ofproto *, struct rule *); static void send_flow_removed(struct ofproto *p, struct rule *rule, long long int now, uint8_t reason); -struct ofconn { - struct list node; - struct rconn *rconn; - struct pktbuf *pktbuf; - int miss_send_len; - - struct rconn_packet_counter *packet_in_counter; +/* ofproto supports two kinds of OpenFlow connections: + * + * - "Controller connections": Connections to ordinary OpenFlow controllers. + * ofproto maintains persistent connections to these controllers and by + * default sends them asynchronous messages such as packet-ins. + * + * - "Transient connections", e.g. from ovs-ofctl. When these connections + * drop, it is the other side's responsibility to reconnect them if + * necessary. ofproto does not send them asynchronous messages by default. + */ +enum ofconn_type { + OFCONN_CONTROLLER, /* An OpenFlow controller. */ + OFCONN_TRANSIENT /* A transient connection. */ +}; - /* Number of OpenFlow messages queued as replies to OpenFlow requests, and - * the maximum number before we stop reading OpenFlow requests. */ +/* An OpenFlow connection. */ +struct ofconn { + struct ofproto *ofproto; /* The ofproto that owns this connection. */ + struct list node; /* In struct ofproto's "all_conns" list. */ + struct rconn *rconn; /* OpenFlow connection. */ + enum ofconn_type type; /* Type. */ + + /* OFPT_PACKET_IN related data. */ + struct rconn_packet_counter *packet_in_counter; /* # queued on 'rconn'. */ + struct pinsched *schedulers[2]; /* Indexed by reason code; see below. */ + struct pktbuf *pktbuf; /* OpenFlow packet buffers. */ + int miss_send_len; /* Bytes to send of buffered packets. */ + + /* Number of OpenFlow messages queued on 'rconn' as replies to OpenFlow + * requests, and the maximum number before we stop reading OpenFlow + * requests. */ #define OFCONN_REPLY_MAX 100 struct rconn_packet_counter *reply_counter; + + /* type == OFCONN_CONTROLLER only. */ + enum nx_role role; /* Role. */ + struct hmap_node hmap_node; /* In struct ofproto's "controllers" map. */ + struct discovery *discovery; /* Controller discovery object, if enabled. */ + struct status_category *ss; /* Switch status category. */ + enum ofproto_band band; /* In-band or out-of-band? */ }; -static struct ofconn *ofconn_create(struct ofproto *, struct rconn *); +/* We use OFPR_NO_MATCH and OFPR_ACTION as indexes into struct ofconn's + * "schedulers" array. Their values are 0 and 1, and their meanings and values + * coincide with _ODPL_MISS_NR and _ODPL_ACTION_NR, so this is convenient. In + * case anything ever changes, check their values here. */ +#define N_SCHEDULERS 2 +BUILD_ASSERT_DECL(OFPR_NO_MATCH == 0); +BUILD_ASSERT_DECL(OFPR_NO_MATCH == _ODPL_MISS_NR); +BUILD_ASSERT_DECL(OFPR_ACTION == 1); +BUILD_ASSERT_DECL(OFPR_ACTION == _ODPL_ACTION_NR); + +static struct ofconn *ofconn_create(struct ofproto *, struct rconn *, + enum ofconn_type); static void ofconn_destroy(struct ofconn *); static void ofconn_run(struct ofconn *, struct ofproto *); static void ofconn_wait(struct ofconn *); +static bool ofconn_receives_async_msgs(const struct ofconn *); + static void queue_tx(struct ofpbuf *msg, const struct ofconn *ofconn, struct rconn_packet_counter *counter); +static void send_packet_in(struct ofproto *, struct ofpbuf *odp_msg); +static void do_send_packet_in(struct ofpbuf *odp_msg, void *ofconn); + struct ofproto { /* Settings. */ uint64_t datapath_id; /* Datapath ID. */ @@ -206,14 +252,16 @@ struct ofproto { /* Configuration. */ struct switch_status *switch_status; - struct status_category *ss_cat; - struct in_band *in_band; - struct discovery *discovery; struct fail_open *fail_open; - struct pinsched *miss_sched, *action_sched; struct netflow *netflow; struct ofproto_sflow *sflow; + /* In-band control. */ + struct in_band *in_band; + long long int next_in_band_update; + struct sockaddr_in *extra_in_band_remotes; + size_t n_extra_remotes; + /* Flow table. */ struct classifier cls; bool need_revalidate; @@ -222,8 +270,8 @@ struct ofproto { bool tun_id_from_cookie; /* OpenFlow connections. */ - struct list all_conns; - struct ofconn *controller; + struct hmap controllers; /* Controller "struct ofconn"s. */ + struct list all_conns; /* Contains "struct ofconn"s. */ struct pvconn **listeners; size_t n_listeners; struct pvconn **snoops; @@ -243,8 +291,7 @@ static const struct ofhooks default_ofhooks; static uint64_t pick_datapath_id(const struct ofproto *); static uint64_t pick_fallback_dpid(void); -static void send_packet_in_miss(struct ofpbuf *, void *ofproto); -static void send_packet_in_action(struct ofpbuf *, void *ofproto); + static void update_used(struct ofproto *); static void update_stats(struct ofproto *, struct rule *, const struct odp_flow_stats *); @@ -319,9 +366,7 @@ ofproto_create(const char *datapath, const char *datapath_type, /* Initialize submodules. */ p->switch_status = switch_status_create(p); p->in_band = NULL; - p->discovery = NULL; p->fail_open = NULL; - p->miss_sched = p->action_sched = NULL; p->netflow = NULL; p->sflow = NULL; @@ -333,9 +378,7 @@ ofproto_create(const char *datapath, const char *datapath_type, /* Initialize OpenFlow connections. */ list_init(&p->all_conns); - p->controller = ofconn_create(p, rconn_create(5, 8)); - p->controller->pktbuf = pktbuf_create(); - p->controller->miss_send_len = OFP_DEFAULT_MISS_SEND_LEN; + hmap_init(&p->controllers); p->listeners = NULL; p->n_listeners = 0; p->snoops = NULL; @@ -352,10 +395,6 @@ ofproto_create(const char *datapath, const char *datapath_type, p->ml = mac_learning_create(); } - /* Register switch status category. */ - p->ss_cat = switch_status_register(p->switch_status, "remote", - rconn_status_cb, p->controller->rconn); - /* Pick final datapath ID. */ p->datapath_id = pick_datapath_id(p); VLOG_INFO("using datapath ID %016"PRIx64, p->datapath_id); @@ -370,26 +409,294 @@ ofproto_set_datapath_id(struct ofproto *p, uint64_t datapath_id) uint64_t old_dpid = p->datapath_id; p->datapath_id = datapath_id ? datapath_id : pick_datapath_id(p); if (p->datapath_id != old_dpid) { + struct ofconn *ofconn; + VLOG_INFO("datapath ID changed to %016"PRIx64, p->datapath_id); - rconn_reconnect(p->controller->rconn); + + /* Force all active connections to reconnect, since there is no way to + * notify a controller that the datapath ID has changed. */ + LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) { + rconn_reconnect(ofconn->rconn); + } + } +} + +static bool +is_discovery_controller(const struct ofproto_controller *c) +{ + return !strcmp(c->target, "discover"); +} + +static bool +is_in_band_controller(const struct ofproto_controller *c) +{ + return is_discovery_controller(c) || c->band == OFPROTO_IN_BAND; +} + +/* Creates a new controller in 'ofproto'. Some of the settings are initially + * drawn from 'c', but update_controller() needs to be called later to finish + * the new ofconn's configuration. */ +static void +add_controller(struct ofproto *ofproto, const struct ofproto_controller *c) +{ + struct discovery *discovery; + struct ofconn *ofconn; + + if (is_discovery_controller(c)) { + int error = discovery_create(c->accept_re, c->update_resolv_conf, + ofproto->dpif, ofproto->switch_status, + &discovery); + if (error) { + return; + } + } else { + discovery = NULL; } + + ofconn = ofconn_create(ofproto, rconn_create(5, 8), OFCONN_CONTROLLER); + ofconn->pktbuf = pktbuf_create(); + ofconn->miss_send_len = OFP_DEFAULT_MISS_SEND_LEN; + if (discovery) { + ofconn->discovery = discovery; + } else { + rconn_connect(ofconn->rconn, c->target); + } + hmap_insert(&ofproto->controllers, &ofconn->hmap_node, + hash_string(c->target, 0)); +} + +/* Reconfigures 'ofconn' to match 'c'. This function cannot update an ofconn's + * target or turn discovery on or off (these are done by creating new ofconns + * and deleting old ones), but it can update the rest of an ofconn's + * settings. */ +static void +update_controller(struct ofconn *ofconn, const struct ofproto_controller *c) +{ + struct ofproto *ofproto = ofconn->ofproto; + int probe_interval; + int i; + + ofconn->band = (is_in_band_controller(c) + ? OFPROTO_IN_BAND : OFPROTO_OUT_OF_BAND); + + rconn_set_max_backoff(ofconn->rconn, c->max_backoff); + + probe_interval = c->probe_interval ? MAX(c->probe_interval, 5) : 0; + rconn_set_probe_interval(ofconn->rconn, probe_interval); + + if (ofconn->discovery) { + discovery_set_update_resolv_conf(ofconn->discovery, + c->update_resolv_conf); + discovery_set_accept_controller_re(ofconn->discovery, c->accept_re); + } + + for (i = 0; i < N_SCHEDULERS; i++) { + struct pinsched **s = &ofconn->schedulers[i]; + + if (c->rate_limit > 0) { + if (!*s) { + *s = pinsched_create(c->rate_limit, c->burst_limit, + ofproto->switch_status); + } else { + pinsched_set_limits(*s, c->rate_limit, c->burst_limit); + } + } else { + pinsched_destroy(*s); + *s = NULL; + } + } +} + +static const char * +ofconn_get_target(const struct ofconn *ofconn) +{ + return ofconn->discovery ? "discover" : rconn_get_name(ofconn->rconn); +} + +static struct ofconn * +find_controller_by_target(struct ofproto *ofproto, const char *target) +{ + struct ofconn *ofconn; + + HMAP_FOR_EACH_WITH_HASH (ofconn, struct ofconn, hmap_node, + hash_string(target, 0), &ofproto->controllers) { + if (!strcmp(ofconn_get_target(ofconn), target)) { + return ofconn; + } + } + return NULL; +} + +static void +update_in_band_remotes(struct ofproto *ofproto) +{ + const struct ofconn *ofconn; + struct sockaddr_in *addrs; + size_t max_addrs, n_addrs; + bool discovery; + size_t i; + + /* Allocate enough memory for as many remotes as we could possibly have. */ + max_addrs = ofproto->n_extra_remotes + hmap_count(&ofproto->controllers); + addrs = xmalloc(max_addrs * sizeof *addrs); + n_addrs = 0; + + /* Add all the remotes. */ + discovery = false; + HMAP_FOR_EACH (ofconn, struct ofconn, hmap_node, &ofproto->controllers) { + struct sockaddr_in *sin = &addrs[n_addrs]; + + if (ofconn->band == OFPROTO_OUT_OF_BAND) { + continue; + } + + sin->sin_addr.s_addr = rconn_get_remote_ip(ofconn->rconn); + if (sin->sin_addr.s_addr) { + sin->sin_port = rconn_get_remote_port(ofconn->rconn); + n_addrs++; + } + if (ofconn->discovery) { + discovery = true; + } + } + for (i = 0; i < ofproto->n_extra_remotes; i++) { + addrs[n_addrs++] = ofproto->extra_in_band_remotes[i]; + } + + /* Create or update or destroy in-band. + * + * Ordinarily we only enable in-band if there's at least one remote + * address, but discovery needs the in-band rules for DHCP to be installed + * even before we know any remote addresses. */ + if (n_addrs || discovery) { + if (!ofproto->in_band) { + in_band_create(ofproto, ofproto->dpif, ofproto->switch_status, + &ofproto->in_band); + } + in_band_set_remotes(ofproto->in_band, addrs, n_addrs); + ofproto->next_in_band_update = time_msec() + 1000; + } else { + in_band_destroy(ofproto->in_band); + ofproto->in_band = NULL; + } + + /* Clean up. */ + free(addrs); } void -ofproto_set_probe_interval(struct ofproto *p, int probe_interval) +ofproto_set_controllers(struct ofproto *p, + const struct ofproto_controller *controllers, + size_t n_controllers) +{ + struct shash new_controllers; + enum ofproto_fail_mode fail_mode; + struct ofconn *ofconn, *next; + bool ss_exists; + size_t i; + + shash_init(&new_controllers); + for (i = 0; i < n_controllers; i++) { + const struct ofproto_controller *c = &controllers[i]; + + shash_add_once(&new_controllers, c->target, &controllers[i]); + if (!find_controller_by_target(p, c->target)) { + add_controller(p, c); + } + } + + fail_mode = OFPROTO_FAIL_STANDALONE; + ss_exists = false; + HMAP_FOR_EACH_SAFE (ofconn, next, struct ofconn, hmap_node, + &p->controllers) { + struct ofproto_controller *c; + + c = shash_find_data(&new_controllers, ofconn_get_target(ofconn)); + if (!c) { + ofconn_destroy(ofconn); + } else { + update_controller(ofconn, c); + if (ofconn->ss) { + ss_exists = true; + } + if (c->fail == OFPROTO_FAIL_SECURE) { + fail_mode = OFPROTO_FAIL_SECURE; + } + } + } + shash_destroy(&new_controllers); + + update_in_band_remotes(p); + + if (!hmap_is_empty(&p->controllers) + && fail_mode == OFPROTO_FAIL_STANDALONE) { + struct rconn **rconns; + size_t n; + + if (!p->fail_open) { + p->fail_open = fail_open_create(p, p->switch_status); + } + + n = 0; + rconns = xmalloc(hmap_count(&p->controllers) * sizeof *rconns); + HMAP_FOR_EACH (ofconn, struct ofconn, hmap_node, &p->controllers) { + rconns[n++] = ofconn->rconn; + } + + fail_open_set_controllers(p->fail_open, rconns, n); + /* p->fail_open takes ownership of 'rconns'. */ + } else { + fail_open_destroy(p->fail_open); + p->fail_open = NULL; + } + + if (!hmap_is_empty(&p->controllers) && !ss_exists) { + ofconn = CONTAINER_OF(hmap_first(&p->controllers), + struct ofconn, hmap_node); + ofconn->ss = switch_status_register(p->switch_status, "remote", + rconn_status_cb, ofconn->rconn); + } +} + +static bool +any_extras_changed(const struct ofproto *ofproto, + const struct sockaddr_in *extras, size_t n) { - probe_interval = probe_interval ? MAX(probe_interval, 5) : 0; - rconn_set_probe_interval(p->controller->rconn, probe_interval); - if (p->fail_open) { - int trigger_duration = probe_interval ? probe_interval * 3 : 15; - fail_open_set_trigger_duration(p->fail_open, trigger_duration); + size_t i; + + if (n != ofproto->n_extra_remotes) { + return true; + } + + for (i = 0; i < n; i++) { + const struct sockaddr_in *old = &ofproto->extra_in_band_remotes[i]; + const struct sockaddr_in *new = &extras[i]; + + if (old->sin_addr.s_addr != new->sin_addr.s_addr || + old->sin_port != new->sin_port) { + return true; + } } + + return false; } +/* Sets the 'n' TCP port addresses in 'extras' as ones to which 'ofproto''s + * in-band control should guarantee access, in the same way that in-band + * control guarantees access to OpenFlow controllers. */ void -ofproto_set_max_backoff(struct ofproto *p, int max_backoff) +ofproto_set_extra_in_band_remotes(struct ofproto *ofproto, + const struct sockaddr_in *extras, size_t n) { - rconn_set_max_backoff(p->controller->rconn, max_backoff); + if (!any_extras_changed(ofproto, extras, n)) { + return; + } + + free(ofproto->extra_in_band_remotes); + ofproto->n_extra_remotes = n; + ofproto->extra_in_band_remotes = xmemdup(extras, n * sizeof *extras); + + update_in_band_remotes(ofproto); } void @@ -443,73 +750,6 @@ ofproto_set_desc(struct ofproto *p, } } -int -ofproto_set_in_band(struct ofproto *p, bool in_band) -{ - if (in_band != (p->in_band != NULL)) { - if (in_band) { - int error; - - error = in_band_create(p, p->dpif, p->switch_status, &p->in_band); - if (error) { - return error; - } - in_band_set_remotes(p->in_band, &p->controller->rconn, 1); - } else { - ofproto_set_discovery(p, false, NULL, true); - in_band_destroy(p->in_band); - p->in_band = NULL; - } - rconn_reconnect(p->controller->rconn); - } - return 0; -} - -int -ofproto_set_discovery(struct ofproto *p, bool discovery, - const char *re, bool update_resolv_conf) -{ - if (discovery != (p->discovery != NULL)) { - if (discovery) { - int error = ofproto_set_in_band(p, true); - if (error) { - return error; - } - error = discovery_create(re, update_resolv_conf, - p->dpif, p->switch_status, - &p->discovery); - if (error) { - return error; - } - } else { - discovery_destroy(p->discovery); - p->discovery = NULL; - } - rconn_disconnect(p->controller->rconn); - } else if (discovery) { - discovery_set_update_resolv_conf(p->discovery, update_resolv_conf); - return discovery_set_accept_controller_re(p->discovery, re); - } - return 0; -} - -int -ofproto_set_controller(struct ofproto *ofproto, const char *controller) -{ - if (ofproto->discovery) { - return EINVAL; - } else if (controller) { - if (strcmp(rconn_get_name(ofproto->controller->rconn), controller)) { - return rconn_connect(ofproto->controller->rconn, controller); - } else { - return 0; - } - } else { - rconn_disconnect(ofproto->controller->rconn); - return 0; - } -} - static int set_pvconns(struct pvconn ***pvconnsp, size_t *n_pvconnsp, const struct svec *svec) @@ -600,49 +840,6 @@ ofproto_set_sflow(struct ofproto *ofproto, } } -void -ofproto_set_failure(struct ofproto *ofproto, bool fail_open) -{ - if (fail_open) { - struct rconn *rconn = ofproto->controller->rconn; - int trigger_duration = rconn_get_probe_interval(rconn) * 3; - if (!ofproto->fail_open) { - ofproto->fail_open = fail_open_create(ofproto, trigger_duration, - ofproto->switch_status, - rconn); - } else { - fail_open_set_trigger_duration(ofproto->fail_open, - trigger_duration); - } - } else { - fail_open_destroy(ofproto->fail_open); - ofproto->fail_open = NULL; - } -} - -void -ofproto_set_rate_limit(struct ofproto *ofproto, - int rate_limit, int burst_limit) -{ - if (rate_limit > 0) { - if (!ofproto->miss_sched) { - ofproto->miss_sched = pinsched_create(rate_limit, burst_limit, - ofproto->switch_status); - ofproto->action_sched = pinsched_create(rate_limit, burst_limit, - NULL); - } else { - pinsched_set_limits(ofproto->miss_sched, rate_limit, burst_limit); - pinsched_set_limits(ofproto->action_sched, - rate_limit, burst_limit); - } - } else { - pinsched_destroy(ofproto->miss_sched); - ofproto->miss_sched = NULL; - pinsched_destroy(ofproto->action_sched); - ofproto->action_sched = NULL; - } -} - int ofproto_set_stp(struct ofproto *ofproto OVS_UNUSED, bool enable_stp) { @@ -661,34 +858,10 @@ ofproto_get_datapath_id(const struct ofproto *ofproto) return ofproto->datapath_id; } -int -ofproto_get_probe_interval(const struct ofproto *ofproto) -{ - return rconn_get_probe_interval(ofproto->controller->rconn); -} - -int -ofproto_get_max_backoff(const struct ofproto *ofproto) -{ - return rconn_get_max_backoff(ofproto->controller->rconn); -} - -bool -ofproto_get_in_band(const struct ofproto *ofproto) -{ - return ofproto->in_band != NULL; -} - bool -ofproto_get_discovery(const struct ofproto *ofproto) -{ - return ofproto->discovery != NULL; -} - -const char * -ofproto_get_controller(const struct ofproto *ofproto) +ofproto_has_controller(const struct ofproto *ofproto) { - return rconn_get_name(ofproto->controller->rconn); + return !hmap_is_empty(&ofproto->controllers); } void @@ -724,8 +897,12 @@ ofproto_destroy(struct ofproto *p) } /* Destroy fail-open and in-band early, since they touch the classifier. */ - ofproto_set_failure(p, false); - ofproto_set_in_band(p, false); + fail_open_destroy(p->fail_open); + p->fail_open = NULL; + + in_band_destroy(p->in_band); + p->in_band = NULL; + free(p->extra_in_band_remotes); ofproto_flush_flows(p); classifier_destroy(&p->cls); @@ -734,6 +911,7 @@ ofproto_destroy(struct ofproto *p) &p->all_conns) { ofconn_destroy(ofconn); } + hmap_destroy(&p->controllers); dpif_close(p->dpif); netdev_monitor_destroy(p->netdev_monitor); @@ -743,14 +921,9 @@ ofproto_destroy(struct ofproto *p) shash_destroy(&p->port_by_name); switch_status_destroy(p->switch_status); - discovery_destroy(p->discovery); - pinsched_destroy(p->miss_sched); - pinsched_destroy(p->action_sched); netflow_destroy(p->netflow); ofproto_sflow_destroy(p->sflow); - switch_status_unregister(p->ss_cat); - for (i = 0; i < p->n_listeners; i++) { pvconn_close(p->listeners[i]); } @@ -795,6 +968,49 @@ process_port_change(struct ofproto *ofproto, int error, char *devname) } } +/* Returns a "preference level" for snooping 'ofconn'. A higher return value + * means that 'ofconn' is more interesting for monitoring than a lower return + * value. */ +static int +snoop_preference(const struct ofconn *ofconn) +{ + switch (ofconn->role) { + case NX_ROLE_MASTER: + return 3; + case NX_ROLE_OTHER: + return 2; + case NX_ROLE_SLAVE: + return 1; + default: + /* Shouldn't happen. */ + return 0; + } +} + +/* One of ofproto's "snoop" pvconns has accepted a new connection on 'vconn'. + * Connects this vconn to a controller. */ +static void +add_snooper(struct ofproto *ofproto, struct vconn *vconn) +{ + struct ofconn *ofconn, *best; + + /* Pick a controller for monitoring. */ + best = NULL; + LIST_FOR_EACH (ofconn, struct ofconn, node, &ofproto->all_conns) { + if (ofconn->type == OFCONN_CONTROLLER + && (!best || snoop_preference(ofconn) > snoop_preference(best))) { + best = ofconn; + } + } + + if (best) { + rconn_add_monitor(best->rconn, vconn); + } else { + VLOG_INFO_RL(&rl, "no controller connection to snoop"); + vconn_close(vconn); + } +} + int ofproto_run1(struct ofproto *p) { @@ -837,23 +1053,11 @@ ofproto_run1(struct ofproto *p) } if (p->in_band) { - in_band_run(p->in_band); - } - if (p->discovery) { - char *controller_name; - if (rconn_is_connectivity_questionable(p->controller->rconn)) { - discovery_question_connectivity(p->discovery); - } - if (discovery_run(p->discovery, &controller_name)) { - if (controller_name) { - rconn_connect(p->controller->rconn, controller_name); - } else { - rconn_disconnect(p->controller->rconn); - } + if (time_msec() >= p->next_in_band_update) { + update_in_band_remotes(p); } + in_band_run(p->in_band); } - pinsched_run(p->miss_sched, send_packet_in_miss, p); - pinsched_run(p->action_sched, send_packet_in_action, p); LIST_FOR_EACH_SAFE (ofconn, next_ofconn, struct ofconn, node, &p->all_conns) { @@ -872,7 +1076,8 @@ ofproto_run1(struct ofproto *p) retval = pvconn_accept(p->listeners[i], OFP_VERSION, &vconn); if (!retval) { - ofconn_create(p, rconn_new_from_vconn("passive", vconn)); + ofconn_create(p, rconn_new_from_vconn("passive", vconn), + OFCONN_TRANSIENT); } else if (retval != EAGAIN) { VLOG_WARN_RL(&rl, "accept failed (%s)", strerror(retval)); } @@ -884,7 +1089,7 @@ ofproto_run1(struct ofproto *p) retval = pvconn_accept(p->snoops[i], OFP_VERSION, &vconn); if (!retval) { - rconn_add_monitor(p->controller->rconn, vconn); + add_snooper(p, vconn); } else if (retval != EAGAIN) { VLOG_WARN_RL(&rl, "accept failed (%s)", strerror(retval)); } @@ -955,16 +1160,12 @@ ofproto_wait(struct ofproto *p) ofconn_wait(ofconn); } if (p->in_band) { + poll_timer_wait_until(p->next_in_band_update); in_band_wait(p->in_band); } - if (p->discovery) { - discovery_wait(p->discovery); - } if (p->fail_open) { fail_open_wait(p->fail_open); } - pinsched_wait(p->miss_sched); - pinsched_wait(p->action_sched); if (p->sflow) { ofproto_sflow_wait(p->sflow); } @@ -976,7 +1177,7 @@ ofproto_wait(struct ofproto *p) VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()"); poll_immediate_wake(); } else if (p->next_expiration != LLONG_MAX) { - poll_timer_wait(p->next_expiration - time_msec()); + poll_timer_wait_until(p->next_expiration); } for (i = 0; i < p->n_listeners; i++) { pvconn_wait(p->listeners[i]); @@ -1001,7 +1202,7 @@ ofproto_get_revalidate_set(struct ofproto *ofproto) bool ofproto_is_alive(const struct ofproto *p) { - return p->discovery || rconn_is_alive(p->controller->rconn); + return !hmap_is_empty(&p->controllers); } int @@ -1230,6 +1431,10 @@ send_port_status(struct ofproto *p, const struct ofport *ofport, struct ofp_port_status *ops; struct ofpbuf *b; + if (!ofconn_receives_async_msgs(ofconn)) { + continue; + } + ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b); ops->reason = reason; ops->desc = ofport->opp; @@ -1378,14 +1583,17 @@ init_ports(struct ofproto *p) } static struct ofconn * -ofconn_create(struct ofproto *p, struct rconn *rconn) +ofconn_create(struct ofproto *p, struct rconn *rconn, enum ofconn_type type) { - struct ofconn *ofconn = xmalloc(sizeof *ofconn); + struct ofconn *ofconn = xzalloc(sizeof *ofconn); + ofconn->ofproto = p; list_push_back(&p->all_conns, &ofconn->node); ofconn->rconn = rconn; + ofconn->type = type; + ofconn->role = NX_ROLE_OTHER; + ofconn->packet_in_counter = rconn_packet_counter_create (); ofconn->pktbuf = NULL; ofconn->miss_send_len = 0; - ofconn->packet_in_counter = rconn_packet_counter_create (); ofconn->reply_counter = rconn_packet_counter_create (); return ofconn; } @@ -1393,7 +1601,13 @@ ofconn_create(struct ofproto *p, struct rconn *rconn) static void ofconn_destroy(struct ofconn *ofconn) { + if (ofconn->type == OFCONN_CONTROLLER) { + hmap_remove(&ofconn->ofproto->controllers, &ofconn->hmap_node); + } + discovery_destroy(ofconn->discovery); + list_remove(&ofconn->node); + switch_status_unregister(ofconn->ss); rconn_destroy(ofconn->rconn); rconn_packet_counter_destroy(ofconn->packet_in_counter); rconn_packet_counter_destroy(ofconn->reply_counter); @@ -1405,6 +1619,25 @@ static void ofconn_run(struct ofconn *ofconn, struct ofproto *p) { int iteration; + size_t i; + + if (ofconn->discovery) { + char *controller_name; + if (rconn_is_connectivity_questionable(ofconn->rconn)) { + discovery_question_connectivity(ofconn->discovery); + } + if (discovery_run(ofconn->discovery, &controller_name)) { + if (controller_name) { + rconn_connect(ofconn->rconn, controller_name); + } else { + rconn_disconnect(ofconn->rconn); + } + } + } + + for (i = 0; i < N_SCHEDULERS; i++) { + pinsched_run(ofconn->schedulers[i], do_send_packet_in, ofconn); + } rconn_run(ofconn->rconn); @@ -1424,7 +1657,7 @@ ofconn_run(struct ofconn *ofconn, struct ofproto *p) } } - if (ofconn != p->controller && !rconn_is_alive(ofconn->rconn)) { + if (!ofconn->discovery && !rconn_is_alive(ofconn->rconn)) { ofconn_destroy(ofconn); } } @@ -1432,6 +1665,14 @@ ofconn_run(struct ofconn *ofconn, struct ofproto *p) static void ofconn_wait(struct ofconn *ofconn) { + int i; + + if (ofconn->discovery) { + discovery_wait(ofconn->discovery); + } + for (i = 0; i < N_SCHEDULERS; i++) { + pinsched_wait(ofconn->schedulers[i]); + } rconn_run_wait(ofconn->rconn); if (rconn_packet_counter_read (ofconn->reply_counter) < OFCONN_REPLY_MAX) { rconn_recv_wait(ofconn->rconn); @@ -1439,6 +1680,22 @@ ofconn_wait(struct ofconn *ofconn) COVERAGE_INC(ofproto_ofconn_stuck); } } + +/* Returns true if 'ofconn' should receive asynchronous messages. */ +static bool +ofconn_receives_async_msgs(const struct ofconn *ofconn) +{ + if (ofconn->type == OFCONN_CONTROLLER) { + /* Ordinary controllers always get asynchronous messages unless they + * have configured themselves as "slaves". */ + return ofconn->role != NX_ROLE_SLAVE; + } else { + /* Transient 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; + } +} /* Caller is responsible for initializing the 'cr' member of the returned * rule. */ @@ -1957,7 +2214,7 @@ handle_set_config(struct ofproto *p, struct ofconn *ofconn, } flags = ntohs(osc->flags); - if (ofconn == p->controller) { + if (ofconn->type == OFCONN_CONTROLLER && ofconn->role != NX_ROLE_SLAVE) { switch (flags & OFPC_FRAG_MASK) { case OFPC_FRAG_NORMAL: dpif_set_drop_frags(p->dpif, false); @@ -1972,14 +2229,6 @@ handle_set_config(struct ofproto *p, struct ofconn *ofconn, } } - if ((ntohs(osc->miss_send_len) != 0) != (ofconn->miss_send_len != 0)) { - if (ntohs(osc->miss_send_len) != 0) { - ofconn->pktbuf = pktbuf_create(); - } else { - pktbuf_destroy(ofconn->pktbuf); - } - } - ofconn->miss_send_len = ntohs(osc->miss_send_len); return 0; @@ -2001,7 +2250,7 @@ add_controller_action(struct odp_actions *actions, const struct ofp_action_output *oao) { union odp_action *a = odp_actions_add(actions, ODPAT_CONTROLLER); - a->controller.arg = oao->max_len ? ntohs(oao->max_len) : UINT32_MAX; + a->controller.arg = ntohs(oao->max_len); } struct action_xlate_ctx { @@ -2312,6 +2561,29 @@ xlate_actions(const union ofp_action *in, size_t n_in, return 0; } +/* Checks whether 'ofconn' is a slave controller. If so, returns an OpenFlow + * error message code (composed with ofp_mkerr()) for the caller to propagate + * upward. Otherwise, returns 0. + * + * 'oh' is used to make log messages more informative. */ +static int +reject_slave_controller(struct ofconn *ofconn, const struct ofp_header *oh) +{ + if (ofconn->type == OFCONN_CONTROLLER && ofconn->role == NX_ROLE_SLAVE) { + static struct vlog_rate_limit perm_rl = VLOG_RATE_LIMIT_INIT(1, 5); + char *type_name; + + type_name = ofp_message_type_to_string(oh->type); + VLOG_WARN_RL(&perm_rl, "rejecting %s message from slave controller", + type_name); + free(type_name); + + return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM); + } else { + return 0; + } +} + static int handle_packet_out(struct ofproto *p, struct ofconn *ofconn, struct ofp_header *oh) @@ -2324,6 +2596,11 @@ handle_packet_out(struct ofproto *p, struct ofconn *ofconn, flow_t flow; int error; + error = reject_slave_controller(ofconn, oh); + if (error) { + return error; + } + error = check_ofp_packet_out(oh, &payload, &n_actions, p->max_ports); if (error) { return error; @@ -2385,12 +2662,17 @@ update_port_config(struct ofproto *p, struct ofport *port, } static int -handle_port_mod(struct ofproto *p, struct ofp_header *oh) +handle_port_mod(struct ofproto *p, struct ofconn *ofconn, + struct ofp_header *oh) { const struct ofp_port_mod *opm; struct ofport *port; int error; + error = reject_slave_controller(ofconn, oh); + if (error) { + return error; + } error = check_ofp_message(oh, OFPT_PORT_MOD, sizeof *opm); if (error) { return error; @@ -2524,7 +2806,7 @@ handle_table_stats_request(struct ofproto *p, struct ofconn *ofconn, static void append_port_stat(struct ofport *port, uint16_t port_no, struct ofconn *ofconn, - struct ofpbuf *msg) + struct ofpbuf **msgp) { struct netdev_stats stats; struct ofp_port_stats *ops; @@ -2534,7 +2816,7 @@ append_port_stat(struct ofport *port, uint16_t port_no, struct ofconn *ofconn, * netdev_get_stats() will log errors. */ netdev_get_stats(port->netdev, &stats); - ops = append_stats_reply(sizeof *ops, ofconn, &msg); + ops = append_stats_reply(sizeof *ops, ofconn, msgp); ops->port_no = htons(odp_port_to_ofp_port(port_no)); memset(ops->pad, 0, sizeof ops->pad); ops->rx_packets = htonll(stats.rx_packets); @@ -2572,11 +2854,11 @@ handle_port_stats_request(struct ofproto *p, struct ofconn *ofconn, port = port_array_get(&p->ports, ofp_port_to_odp_port(ntohs(psr->port_no))); if (port) { - append_port_stat(port, ntohs(psr->port_no), ofconn, msg); + append_port_stat(port, ntohs(psr->port_no), ofconn, &msg); } } else { PORT_ARRAY_FOR_EACH (port, &p->ports, port_no) { - append_port_stat(port, port_no, ofconn, msg); + append_port_stat(port, port_no, ofconn, &msg); } } @@ -3187,6 +3469,10 @@ handle_flow_mod(struct ofproto *p, struct ofconn *ofconn, size_t n_actions; int error; + error = reject_slave_controller(ofconn, &ofm->header); + if (error) { + return error; + } error = check_ofp_message_array(&ofm->header, OFPT_FLOW_MOD, sizeof *ofm, sizeof *ofm->actions, &n_actions); if (error) { @@ -3249,6 +3535,59 @@ handle_tun_id_from_cookie(struct ofproto *p, struct nxt_tun_id_cookie *msg) return 0; } +static int +handle_role_request(struct ofproto *ofproto, + struct ofconn *ofconn, struct nicira_header *msg) +{ + struct nx_role_request *nrr; + struct nx_role_request *reply; + struct ofpbuf *buf; + uint32_t role; + + if (ntohs(msg->header.length) != sizeof *nrr) { + VLOG_WARN_RL(&rl, "received role request of length %u (expected %zu)", + ntohs(msg->header.length), sizeof *nrr); + return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); + } + nrr = (struct nx_role_request *) msg; + + if (ofconn->type != OFCONN_CONTROLLER) { + VLOG_WARN_RL(&rl, "ignoring role request on non-controller " + "connection"); + return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM); + } + + role = ntohl(nrr->role); + if (role != NX_ROLE_OTHER && role != NX_ROLE_MASTER + && role != NX_ROLE_SLAVE) { + VLOG_WARN_RL(&rl, "received request for unknown role %"PRIu32, role); + + /* There's no good error code for this. */ + return ofp_mkerr(OFPET_BAD_REQUEST, -1); + } + + if (role == NX_ROLE_MASTER) { + struct ofconn *other; + + HMAP_FOR_EACH (other, struct ofconn, hmap_node, + &ofproto->controllers) { + if (other->role == NX_ROLE_MASTER) { + other->role = NX_ROLE_SLAVE; + } + } + } + ofconn->role = role; + + reply = make_openflow_xid(sizeof *reply, OFPT_VENDOR, msg->header.xid, + &buf); + reply->nxh.vendor = htonl(NX_VENDOR_ID); + reply->nxh.subtype = htonl(NXT_ROLE_REPLY); + reply->role = htonl(role); + queue_tx(buf, ofconn, ofconn->reply_counter); + + return 0; +} + static int handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg) { @@ -3256,7 +3595,7 @@ handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg) struct nicira_header *nh; if (ntohs(ovh->header.length) < sizeof(struct ofp_vendor_header)) { - VLOG_WARN_RL(&rl, "received vendor message of length %zu " + VLOG_WARN_RL(&rl, "received vendor message of length %u " "(expected at least %zu)", ntohs(ovh->header.length), sizeof(struct ofp_vendor_header)); return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); @@ -3265,7 +3604,7 @@ handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg) return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR); } if (ntohs(ovh->header.length) < sizeof(struct nicira_header)) { - VLOG_WARN_RL(&rl, "received Nicira vendor message of length %zu " + VLOG_WARN_RL(&rl, "received Nicira vendor message of length %u " "(expected at least %zu)", ntohs(ovh->header.length), sizeof(struct nicira_header)); return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); @@ -3279,6 +3618,9 @@ handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg) case NXT_TUN_ID_FROM_COOKIE: return handle_tun_id_from_cookie(p, msg); + + case NXT_ROLE_REQUEST: + return handle_role_request(p, ofconn, msg); } return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE); @@ -3331,7 +3673,7 @@ handle_openflow(struct ofconn *ofconn, struct ofproto *p, break; case OFPT_PORT_MOD: - error = handle_port_mod(p, oh); + error = handle_port_mod(p, ofconn, oh); break; case OFPT_FLOW_MOD: @@ -3369,7 +3711,6 @@ static void handle_odp_miss_msg(struct ofproto *p, struct ofpbuf *packet) { struct odp_msg *msg = packet->data; - uint16_t in_port = odp_port_to_ofp_port(msg->port); struct rule *rule; struct ofpbuf payload; flow_t flow; @@ -3405,7 +3746,7 @@ handle_odp_miss_msg(struct ofproto *p, struct ofpbuf *packet) } COVERAGE_INC(ofproto_packet_in); - pinsched_send(p->miss_sched, in_port, packet, send_packet_in_miss, p); + send_packet_in(p, packet); return; } @@ -3426,8 +3767,7 @@ handle_odp_miss_msg(struct ofproto *p, struct ofpbuf *packet) rule_execute(p, rule, &payload, &flow); rule_reinstall(p, rule); - if (rule->super && rule->super->cr.priority == FAIL_OPEN_PRIORITY - && rconn_is_connected(p->controller->rconn)) { + if (rule->super && rule->super->cr.priority == FAIL_OPEN_PRIORITY) { /* * Extra-special case for fail-open mode. * @@ -3438,7 +3778,7 @@ handle_odp_miss_msg(struct ofproto *p, struct ofpbuf *packet) * * See the top-level comment in fail-open.c for more information. */ - pinsched_send(p->miss_sched, in_port, packet, send_packet_in_miss, p); + send_packet_in(p, packet); } else { ofpbuf_delete(packet); } @@ -3452,8 +3792,7 @@ handle_odp_msg(struct ofproto *p, struct ofpbuf *packet) switch (msg->type) { case _ODPL_ACTION_NR: COVERAGE_INC(ofproto_ctlr_action); - pinsched_send(p->action_sched, odp_port_to_ofp_port(msg->port), packet, - send_packet_in_action, p); + send_packet_in(p, packet); break; case _ODPL_SFLOW_NR: @@ -3552,6 +3891,7 @@ uninstall_idle_flow(struct ofproto *ofproto, struct rule *rule) rule_uninstall(ofproto, rule); } } + static void send_flow_removed(struct ofproto *p, struct rule *rule, long long int now, uint8_t reason) @@ -3568,7 +3908,8 @@ send_flow_removed(struct ofproto *p, struct rule *rule, prev = NULL; LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) { - if (rule->send_flow_removed && rconn_is_connected(ofconn->rconn)) { + if (rule->send_flow_removed && rconn_is_connected(ofconn->rconn) + && ofconn_receives_async_msgs(ofconn)) { if (prev) { queue_tx(ofpbuf_clone(buf), prev, prev->reply_counter); } else { @@ -3698,68 +4039,150 @@ update_used(struct ofproto *p) free(flows); } +/* pinsched callback for sending 'packet' on 'ofconn'. */ static void -do_send_packet_in(struct ofconn *ofconn, uint32_t buffer_id, - const struct ofpbuf *packet, int send_len) +do_send_packet_in(struct ofpbuf *packet, void *ofconn_) { - struct odp_msg *msg = packet->data; - struct ofpbuf payload; - struct ofpbuf *opi; - uint8_t reason; + struct ofconn *ofconn = ofconn_; - /* Extract packet payload from 'msg'. */ - payload.data = msg + 1; - payload.size = msg->length - sizeof *msg; + rconn_send_with_limit(ofconn->rconn, packet, + ofconn->packet_in_counter, 100); +} + +/* Takes 'packet', which has been converted with do_convert_to_packet_in(), and + * finalizes its content for sending on 'ofconn', and passes it to 'ofconn''s + * packet scheduler for sending. + * + * 'max_len' specifies the maximum number of bytes of the packet to send on + * 'ofconn' (INT_MAX specifies no limit). + * + * If 'clone' is true, the caller retains ownership of 'packet'. Otherwise, + * ownership is transferred to this function. */ +static void +schedule_packet_in(struct ofconn *ofconn, struct ofpbuf *packet, int max_len, + bool clone) +{ + struct ofproto *ofproto = ofconn->ofproto; + struct ofp_packet_in *opi = packet->data; + uint16_t in_port = ofp_port_to_odp_port(ntohs(opi->in_port)); + int send_len, trim_size; + uint32_t buffer_id; + + /* Get buffer. */ + if (opi->reason == OFPR_ACTION) { + buffer_id = UINT32_MAX; + } else if (ofproto->fail_open && fail_open_is_active(ofproto->fail_open)) { + buffer_id = pktbuf_get_null(); + } else if (!ofconn->pktbuf) { + buffer_id = UINT32_MAX; + } else { + struct ofpbuf payload; + payload.data = opi->data; + payload.size = packet->size - offsetof(struct ofp_packet_in, data); + buffer_id = pktbuf_save(ofconn->pktbuf, &payload, in_port); + } - /* Construct ofp_packet_in message. */ - reason = msg->type == _ODPL_ACTION_NR ? OFPR_ACTION : OFPR_NO_MATCH; - opi = make_packet_in(buffer_id, odp_port_to_ofp_port(msg->port), reason, - &payload, send_len); + /* Figure out how much of the packet to send. */ + send_len = ntohs(opi->total_len); + if (buffer_id != UINT32_MAX) { + send_len = MIN(send_len, ofconn->miss_send_len); + } + send_len = MIN(send_len, max_len); - /* Send. */ - rconn_send_with_limit(ofconn->rconn, opi, ofconn->packet_in_counter, 100); + /* Adjust packet length and clone if necessary. */ + trim_size = offsetof(struct ofp_packet_in, data) + send_len; + if (clone) { + packet = ofpbuf_clone_data(packet->data, trim_size); + opi = packet->data; + } else { + packet->size = trim_size; + } + + /* Update packet headers. */ + opi->buffer_id = htonl(buffer_id); + update_openflow_length(packet); + + /* Hand over to packet scheduler. It might 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[opi->reason], in_port, + packet, do_send_packet_in, ofconn); } -static void -send_packet_in_action(struct ofpbuf *packet, void *p_) +/* Replace struct odp_msg header in 'packet' by equivalent struct + * ofp_packet_in. The odp_msg must have sufficient headroom to do so (e.g. as + * returned by dpif_recv()). + * + * The conversion is not complete: the caller still needs to trim any unneeded + * payload off the end of the buffer, set the length in the OpenFlow header, + * and set buffer_id. Those require us to know the controller settings and so + * must be done on a per-controller basis. + * + * Returns the maximum number of bytes of the packet that should be sent to + * the controller (INT_MAX if no limit). */ +static int +do_convert_to_packet_in(struct ofpbuf *packet) { - struct ofproto *p = p_; - struct ofconn *ofconn; - struct odp_msg *msg; + struct odp_msg *msg = packet->data; + struct ofp_packet_in *opi; + uint8_t reason; + uint16_t total_len; + uint16_t in_port; + int max_len; - msg = packet->data; - LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) { - if (ofconn == p->controller || ofconn->miss_send_len) { - do_send_packet_in(ofconn, UINT32_MAX, packet, msg->arg); - } + /* Extract relevant header fields */ + if (msg->type == _ODPL_ACTION_NR) { + reason = OFPR_ACTION; + max_len = msg->arg; + } else { + reason = OFPR_NO_MATCH; + max_len = INT_MAX; } - ofpbuf_delete(packet); + total_len = msg->length - sizeof *msg; + in_port = odp_port_to_ofp_port(msg->port); + + /* Repurpose packet buffer by overwriting header. */ + ofpbuf_pull(packet, sizeof(struct odp_msg)); + opi = ofpbuf_push_zeros(packet, offsetof(struct ofp_packet_in, data)); + opi->header.version = OFP_VERSION; + opi->header.type = OFPT_PACKET_IN; + opi->total_len = htons(total_len); + opi->in_port = htons(in_port); + opi->reason = reason; + + return max_len; } +/* Given 'packet' containing an odp_msg of type _ODPL_ACTION_NR or + * _ODPL_MISS_NR, sends an OFPT_PACKET_IN message to each OpenFlow controller + * as necessary according to their individual configurations. + * + * 'packet' must have sufficient headroom to convert it into a struct + * ofp_packet_in (e.g. as returned by dpif_recv()). + * + * Takes ownership of 'packet'. */ static void -send_packet_in_miss(struct ofpbuf *packet, void *p_) +send_packet_in(struct ofproto *ofproto, struct ofpbuf *packet) { - struct ofproto *p = p_; - bool in_fail_open = p->fail_open && fail_open_is_active(p->fail_open); - struct ofconn *ofconn; - struct ofpbuf payload; - struct odp_msg *msg; + struct ofconn *ofconn, *prev; + int max_len; - msg = packet->data; - payload.data = msg + 1; - payload.size = msg->length - sizeof *msg; - LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) { - if (ofconn->miss_send_len) { - struct pktbuf *pb = ofconn->pktbuf; - uint32_t buffer_id = (in_fail_open - ? pktbuf_get_null() - : pktbuf_save(pb, &payload, msg->port)); - int send_len = (buffer_id != UINT32_MAX ? ofconn->miss_send_len - : INT_MAX); - do_send_packet_in(ofconn, buffer_id, packet, send_len); + max_len = do_convert_to_packet_in(packet); + + prev = NULL; + LIST_FOR_EACH (ofconn, struct ofconn, node, &ofproto->all_conns) { + if (ofconn_receives_async_msgs(ofconn)) { + if (prev) { + schedule_packet_in(prev, packet, max_len, true); + } + prev = ofconn; } } - ofpbuf_delete(packet); + if (prev) { + schedule_packet_in(prev, packet, max_len, false); + } else { + ofpbuf_delete(packet); + } } static uint64_t