X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=636e5ec80d3148450337709373cb34249cc7b56b;hb=a3c5ac709a32ad802534b6039fd8f762910d19d6;hp=9ddf6b155a9670d61a88a5170af68b7b6a56eaf0;hpb=e18fe8a220f268624e5b670d6adcf2d4080866aa;p=openvswitch diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index 9ddf6b15..636e5ec8 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -165,27 +165,68 @@ 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. */ }; -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 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,11 +247,8 @@ 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; @@ -219,10 +257,11 @@ struct ofproto { bool need_revalidate; long long int next_expiration; struct tag_set revalidate_set; + 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; @@ -242,8 +281,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 *); @@ -318,9 +356,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; @@ -332,9 +368,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; @@ -351,10 +385,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); @@ -369,26 +399,213 @@ 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); + } } } -void -ofproto_set_probe_interval(struct ofproto *p, int probe_interval) +static bool +is_discovery_controller(const struct ofproto_controller *c) { - 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); + 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)); } -void -ofproto_set_max_backoff(struct ofproto *p, int max_backoff) +/* 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) { - rconn_set_max_backoff(p->controller->rconn, max_backoff); + struct ofproto *ofproto = ofconn->ofproto; + int probe_interval; + int i; + + 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; +} + +void +ofproto_set_controllers(struct ofproto *p, + const struct ofproto_controller *controllers, + size_t n_controllers) +{ + struct shash new_controllers; + struct rconn **in_band_rconns; + enum ofproto_fail_mode fail_mode; + struct ofconn *ofconn, *next; + bool ss_exists; + size_t n_in_band; + 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); + } + } + + in_band_rconns = xmalloc(n_controllers * sizeof *in_band_rconns); + n_in_band = 0; + 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 (is_in_band_controller(c)) { + in_band_rconns[n_in_band++] = ofconn->rconn; + } + + if (c->fail == OFPROTO_FAIL_SECURE) { + fail_mode = OFPROTO_FAIL_SECURE; + } + } + } + shash_destroy(&new_controllers); + + if (n_in_band) { + if (!p->in_band) { + in_band_create(p, p->dpif, p->switch_status, &p->in_band); + } + if (p->in_band) { + in_band_set_remotes(p->in_band, in_band_rconns, n_in_band); + } + } else { + in_band_destroy(p->in_band); + p->in_band = NULL; + } + free(in_band_rconns); + + 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); + } } void @@ -442,68 +659,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) { - return in_band_create(p, p->dpif, p->switch_status, - p->controller->rconn, &p->in_band); - } 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) @@ -594,49 +749,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) { @@ -655,34 +767,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) +ofproto_has_controller(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) -{ - return rconn_get_name(ofproto->controller->rconn); + return !hmap_is_empty(&ofproto->controllers); } void @@ -717,8 +805,12 @@ ofproto_destroy(struct ofproto *p) return; } - /* Destroy fail-open early, because it touches the classifier. */ - ofproto_set_failure(p, false); + /* Destroy fail-open and in-band early, since they touch the classifier. */ + fail_open_destroy(p->fail_open); + p->fail_open = NULL; + + in_band_destroy(p->in_band); + p->in_band = NULL; ofproto_flush_flows(p); classifier_destroy(&p->cls); @@ -727,6 +819,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); @@ -736,15 +829,9 @@ ofproto_destroy(struct ofproto *p) shash_destroy(&p->port_by_name); switch_status_destroy(p->switch_status); - in_band_destroy(p->in_band); - 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]); } @@ -789,6 +876,27 @@ process_port_change(struct ofproto *ofproto, int error, char *devname) } } +/* 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; + + /* Arbitrarily pick the first controller in the list for monitoring. We + * could do something smarter or more flexible later, if it ever proves + * useful. */ + LIST_FOR_EACH (ofconn, struct ofconn, node, &ofproto->all_conns) { + if (ofconn->type == OFCONN_CONTROLLER) { + rconn_add_monitor(ofconn->rconn, vconn); + return; + } + + } + VLOG_INFO_RL(&rl, "no controller connection to monitor"); + vconn_close(vconn); +} + int ofproto_run1(struct ofproto *p) { @@ -833,21 +941,6 @@ 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); - } - } - } - 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) { @@ -866,7 +959,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)); } @@ -878,7 +972,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)); } @@ -951,14 +1045,9 @@ ofproto_wait(struct ofproto *p) if (p->in_band) { 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); } @@ -995,7 +1084,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 @@ -1029,7 +1118,7 @@ ofproto_add_flow(struct ofproto *p, rule = rule_create(p, NULL, actions, n_actions, idle_timeout >= 0 ? idle_timeout : 5 /* XXX */, 0, 0, false); - cls_rule_from_flow(&rule->cr, flow, wildcards, priority); + cls_rule_from_flow(flow, wildcards, priority, &rule->cr); rule_insert(p, rule, NULL, 0); } @@ -1224,6 +1313,10 @@ send_port_status(struct ofproto *p, const struct ofport *ofport, struct ofp_port_status *ops; struct ofpbuf *b; + if (ofconn->role == NX_ROLE_SLAVE) { + continue; + } + ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b); ops->reason = reason; ops->desc = ofport->opp; @@ -1372,14 +1465,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; } @@ -1387,7 +1483,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); @@ -1399,6 +1501,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); @@ -1418,7 +1539,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); } } @@ -1426,6 +1547,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); @@ -1583,7 +1712,7 @@ rule_insert(struct ofproto *p, struct rule *rule, struct ofpbuf *packet, /* Send the packet and credit it to the rule. */ if (packet) { flow_t flow; - flow_extract(packet, in_port, &flow); + flow_extract(packet, 0, in_port, &flow); rule_execute(p, rule, packet, &flow); } @@ -1610,9 +1739,8 @@ rule_create_subrule(struct ofproto *ofproto, struct rule *rule, rule->idle_timeout, rule->hard_timeout, 0, false); COVERAGE_INC(ofproto_subrule_create); - cls_rule_from_flow(&subrule->cr, flow, 0, - (rule->cr.priority <= UINT16_MAX ? UINT16_MAX - : rule->cr.priority)); + cls_rule_from_flow(flow, 0, (rule->cr.priority <= UINT16_MAX ? UINT16_MAX + : rule->cr.priority), &subrule->cr); classifier_insert_exact(&ofproto->cls, &subrule->cr); return subrule; @@ -1669,6 +1797,7 @@ do_put_flow(struct ofproto *ofproto, struct rule *rule, int flags, put->flow.key = rule->cr.flow; put->flow.actions = rule->odp_actions; put->flow.n_actions = rule->n_odp_actions; + put->flow.flags = 0; put->flags = flags; return dpif_flow_put(ofproto->dpif, put); } @@ -1764,6 +1893,7 @@ rule_uninstall(struct ofproto *p, struct rule *rule) odp_flow.key = rule->cr.flow; odp_flow.actions = NULL; odp_flow.n_actions = 0; + odp_flow.flags = 0; if (!dpif_flow_del(p->dpif, &odp_flow)) { update_stats(p, rule, &odp_flow.stats); } @@ -1950,7 +2080,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); @@ -1965,14 +2095,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; @@ -2062,11 +2184,17 @@ static void xlate_table_action(struct action_xlate_ctx *ctx, uint16_t in_port) { if (!ctx->recurse) { - uint16_t old_in_port = ctx->flow.in_port; + uint16_t old_in_port; struct rule *rule; + /* Look up a flow with 'in_port' as the input port. Then restore the + * original input port (otherwise OFPP_NORMAL and OFPP_IN_PORT will + * have surprising behavior). */ + old_in_port = ctx->flow.in_port; ctx->flow.in_port = in_port; rule = lookup_valid_rule(ctx->ofproto, &ctx->flow); + ctx->flow.in_port = old_in_port; + if (rule) { if (rule->super) { rule = rule->super; @@ -2076,7 +2204,6 @@ xlate_table_action(struct action_xlate_ctx *ctx, uint16_t in_port) do_xlate_actions(rule->actions, rule->n_actions, ctx); ctx->recurse--; } - ctx->flow.in_port = old_in_port; } } @@ -2141,6 +2268,8 @@ xlate_nicira_action(struct action_xlate_ctx *ctx, const struct nx_action_header *nah) { const struct nx_action_resubmit *nar; + const struct nx_action_set_tunnel *nast; + union odp_action *oa; int subtype = ntohs(nah->subtype); assert(nah->vendor == htonl(NX_VENDOR_ID)); @@ -2150,6 +2279,15 @@ xlate_nicira_action(struct action_xlate_ctx *ctx, xlate_table_action(ctx, ofp_port_to_odp_port(ntohs(nar->in_port))); break; + case NXAST_SET_TUNNEL: + nast = (const struct nx_action_set_tunnel *) nah; + oa = odp_actions_add(ctx->out, ODPAT_SET_TUNNEL); + ctx->flow.tun_id = oa->tunnel.tun_id = nast->tun_id; + break; + + /* If you add a new action here that modifies flow data, don't forget to + * update the flow key in ctx->flow in the same key. */ + default: VLOG_DBG_RL(&rl, "unknown Nicira action type %"PRIu16, subtype); break; @@ -2183,53 +2321,59 @@ do_xlate_actions(const union ofp_action *in, size_t n_in, case OFPAT_SET_VLAN_VID: oa = odp_actions_add(ctx->out, ODPAT_SET_VLAN_VID); - oa->vlan_vid.vlan_vid = ia->vlan_vid.vlan_vid; + ctx->flow.dl_vlan = oa->vlan_vid.vlan_vid = ia->vlan_vid.vlan_vid; break; case OFPAT_SET_VLAN_PCP: oa = odp_actions_add(ctx->out, ODPAT_SET_VLAN_PCP); - oa->vlan_pcp.vlan_pcp = ia->vlan_pcp.vlan_pcp; + ctx->flow.dl_vlan_pcp = oa->vlan_pcp.vlan_pcp = ia->vlan_pcp.vlan_pcp; break; case OFPAT_STRIP_VLAN: odp_actions_add(ctx->out, ODPAT_STRIP_VLAN); + ctx->flow.dl_vlan = OFP_VLAN_NONE; + ctx->flow.dl_vlan_pcp = 0; break; case OFPAT_SET_DL_SRC: oa = odp_actions_add(ctx->out, ODPAT_SET_DL_SRC); memcpy(oa->dl_addr.dl_addr, ((struct ofp_action_dl_addr *) ia)->dl_addr, ETH_ADDR_LEN); + memcpy(ctx->flow.dl_src, + ((struct ofp_action_dl_addr *) ia)->dl_addr, ETH_ADDR_LEN); break; case OFPAT_SET_DL_DST: oa = odp_actions_add(ctx->out, ODPAT_SET_DL_DST); memcpy(oa->dl_addr.dl_addr, ((struct ofp_action_dl_addr *) ia)->dl_addr, ETH_ADDR_LEN); + memcpy(ctx->flow.dl_dst, + ((struct ofp_action_dl_addr *) ia)->dl_addr, ETH_ADDR_LEN); break; case OFPAT_SET_NW_SRC: oa = odp_actions_add(ctx->out, ODPAT_SET_NW_SRC); - oa->nw_addr.nw_addr = ia->nw_addr.nw_addr; + ctx->flow.nw_src = oa->nw_addr.nw_addr = ia->nw_addr.nw_addr; break; case OFPAT_SET_NW_DST: oa = odp_actions_add(ctx->out, ODPAT_SET_NW_DST); - oa->nw_addr.nw_addr = ia->nw_addr.nw_addr; + ctx->flow.nw_dst = oa->nw_addr.nw_addr = ia->nw_addr.nw_addr; break; case OFPAT_SET_NW_TOS: oa = odp_actions_add(ctx->out, ODPAT_SET_NW_TOS); - oa->nw_tos.nw_tos = ia->nw_tos.nw_tos; + ctx->flow.nw_tos = oa->nw_tos.nw_tos = ia->nw_tos.nw_tos; break; case OFPAT_SET_TP_SRC: oa = odp_actions_add(ctx->out, ODPAT_SET_TP_SRC); - oa->tp_port.tp_port = ia->tp_port.tp_port; + ctx->flow.tp_src = oa->tp_port.tp_port = ia->tp_port.tp_port; break; case OFPAT_SET_TP_DST: oa = odp_actions_add(ctx->out, ODPAT_SET_TP_DST); - oa->tp_port.tp_port = ia->tp_port.tp_port; + ctx->flow.tp_dst = oa->tp_port.tp_port = ia->tp_port.tp_port; break; case OFPAT_VENDOR: @@ -2283,6 +2427,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) @@ -2295,6 +2462,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; @@ -2313,7 +2485,7 @@ handle_packet_out(struct ofproto *p, struct ofconn *ofconn, buffer = NULL; } - flow_extract(&payload, ofp_port_to_odp_port(ntohs(opo->in_port)), &flow); + flow_extract(&payload, 0, ofp_port_to_odp_port(ntohs(opo->in_port)), &flow); error = xlate_actions((const union ofp_action *) opo->actions, n_actions, &flow, p, &payload, &actions, NULL, NULL, NULL); if (error) { @@ -2356,12 +2528,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; @@ -2482,7 +2659,8 @@ handle_table_stats_request(struct ofproto *p, struct ofconn *ofconn, memset(ots, 0, sizeof *ots); ots->table_id = TABLEID_CLASSIFIER; strcpy(ots->name, "classifier"); - ots->wildcards = htonl(OFPFW_ALL); + ots->wildcards = p->tun_id_from_cookie ? htonl(OVSFW_ALL) + : htonl(OFPFW_ALL); ots->max_entries = htonl(65536); ots->active_count = htonl(n_wild); ots->lookup_count = htonll(0); /* XXX */ @@ -2640,7 +2818,8 @@ flow_stats_cb(struct cls_rule *rule_, void *cbdata_) ofs->length = htons(len); ofs->table_id = rule->cr.wc.wildcards ? TABLEID_CLASSIFIER : TABLEID_HASH; ofs->pad = 0; - flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &ofs->match); + flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, + cbdata->ofproto->tun_id_from_cookie, &ofs->match); ofs->duration_sec = htonl(sec); ofs->duration_nsec = htonl(msec * 1000000); ofs->cookie = rule->flow_cookie; @@ -2681,7 +2860,7 @@ handle_flow_stats_request(struct ofproto *p, struct ofconn *ofconn, cbdata.ofconn = ofconn; cbdata.out_port = fsr->out_port; cbdata.msg = start_stats_reply(osr, 1024); - cls_rule_from_match(&target, &fsr->match, 0); + cls_rule_from_match(&fsr->match, 0, false, 0, &target); classifier_for_each_match(&p->cls, &target, table_id_to_include(fsr->table_id), flow_stats_cb, &cbdata); @@ -2710,7 +2889,8 @@ flow_stats_ds_cb(struct cls_rule *rule_, void *cbdata_) } query_stats(cbdata->ofproto, rule, &packet_count, &byte_count); - flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &match); + flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, + cbdata->ofproto->tun_id_from_cookie, &match); ds_put_format(results, "duration=%llds, ", (time_msec() - rule->created) / 1000); @@ -2732,12 +2912,12 @@ ofproto_get_all_flows(struct ofproto *p, struct ds *results) struct flow_stats_ds_cbdata cbdata; memset(&match, 0, sizeof match); - match.wildcards = htonl(OFPFW_ALL); + match.wildcards = htonl(OVSFW_ALL); cbdata.ofproto = p; cbdata.results = results; - cls_rule_from_match(&target, &match, 0); + cls_rule_from_match(&match, 0, false, 0, &target); classifier_for_each_match(&p->cls, &target, CLS_INC_ALL, flow_stats_ds_cb, &cbdata); } @@ -2790,7 +2970,7 @@ handle_aggregate_stats_request(struct ofproto *p, struct ofconn *ofconn, cbdata.packet_count = 0; cbdata.byte_count = 0; cbdata.n_flows = 0; - cls_rule_from_match(&target, &asr->match, 0); + cls_rule_from_match(&asr->match, 0, false, 0, &target); classifier_for_each_match(&p->cls, &target, table_id_to_include(asr->table_id), aggregate_stats_cb, &cbdata); @@ -2898,7 +3078,8 @@ add_flow(struct ofproto *p, struct ofconn *ofconn, flow_t flow; uint32_t wildcards; - flow_from_match(&flow, &wildcards, &ofm->match); + flow_from_match(&ofm->match, p->tun_id_from_cookie, ofm->cookie, + &flow, &wildcards); if (classifier_rule_overlaps(&p->cls, &flow, wildcards, ntohs(ofm->priority))) { return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP); @@ -2909,7 +3090,8 @@ add_flow(struct ofproto *p, struct ofconn *ofconn, n_actions, ntohs(ofm->idle_timeout), ntohs(ofm->hard_timeout), ofm->cookie, ofm->flags & htons(OFPFF_SEND_FLOW_REM)); - cls_rule_from_match(&rule->cr, &ofm->match, ntohs(ofm->priority)); + cls_rule_from_match(&ofm->match, ntohs(ofm->priority), + p->tun_id_from_cookie, ofm->cookie, &rule->cr); error = 0; if (ofm->buffer_id != htonl(UINT32_MAX)) { @@ -2931,7 +3113,8 @@ find_flow_strict(struct ofproto *p, const struct ofp_flow_mod *ofm) uint32_t wildcards; flow_t flow; - flow_from_match(&flow, &wildcards, &ofm->match); + flow_from_match(&ofm->match, p->tun_id_from_cookie, ofm->cookie, + &flow, &wildcards); return rule_from_cls_rule(classifier_find_rule_exactly( &p->cls, &flow, wildcards, ntohs(ofm->priority))); @@ -2956,7 +3139,7 @@ send_buffered_packet(struct ofproto *ofproto, struct ofconn *ofconn, return error; } - flow_extract(packet, in_port, &flow); + flow_extract(packet, 0, in_port, &flow); rule_execute(ofproto, rule, packet, &flow); ofpbuf_delete(packet); @@ -2993,7 +3176,8 @@ modify_flows_loose(struct ofproto *p, struct ofconn *ofconn, cbdata.n_actions = n_actions; cbdata.match = NULL; - cls_rule_from_match(&target, &ofm->match, 0); + cls_rule_from_match(&ofm->match, 0, p->tun_id_from_cookie, ofm->cookie, + &target); classifier_for_each_match(&p->cls, &target, CLS_INC_ALL, modify_flows_cb, &cbdata); @@ -3094,7 +3278,8 @@ delete_flows_loose(struct ofproto *p, const struct ofp_flow_mod *ofm) cbdata.ofproto = p; cbdata.out_port = ofm->out_port; - cls_rule_from_match(&target, &ofm->match, 0); + cls_rule_from_match(&ofm->match, 0, p->tun_id_from_cookie, ofm->cookie, + &target); classifier_for_each_match(&p->cls, &target, CLS_INC_ALL, delete_flows_cb, &cbdata); @@ -3150,6 +3335,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) { @@ -3198,6 +3387,73 @@ handle_flow_mod(struct ofproto *p, struct ofconn *ofconn, } } +static int +handle_tun_id_from_cookie(struct ofproto *p, struct nxt_tun_id_cookie *msg) +{ + int error; + + error = check_ofp_message(&msg->header, OFPT_VENDOR, sizeof *msg); + if (error) { + return error; + } + + p->tun_id_from_cookie = !!msg->set; + 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 %zu (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) { @@ -3205,12 +3461,18 @@ 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 " + "(expected at least %zu)", + ntohs(ovh->header.length), sizeof(struct ofp_vendor_header)); return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); } if (ovh->vendor != htonl(NX_VENDOR_ID)) { 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 " + "(expected at least %zu)", + ntohs(ovh->header.length), sizeof(struct nicira_header)); return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); } @@ -3219,6 +3481,12 @@ handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg) case NXT_STATUS_REQUEST: return switch_status_handle_request(p->switch_status, ofconn->rconn, 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); @@ -3271,7 +3539,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: @@ -3309,14 +3577,13 @@ 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; payload.data = msg + 1; payload.size = msg->length - sizeof *msg; - flow_extract(&payload, msg->port, &flow); + flow_extract(&payload, msg->arg, msg->port, &flow); /* Check with in-band control to see if this packet should be sent * to the local port regardless of the flow table. */ @@ -3345,7 +3612,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; } @@ -3366,8 +3633,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. * @@ -3378,7 +3644,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); } @@ -3392,8 +3658,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: @@ -3456,7 +3721,8 @@ revalidate_rule(struct ofproto *p, struct rule *rule) } static struct ofpbuf * -compose_flow_removed(const struct rule *rule, long long int now, uint8_t reason) +compose_flow_removed(struct ofproto *p, const struct rule *rule, + long long int now, uint8_t reason) { struct ofp_flow_removed *ofr; struct ofpbuf *buf; @@ -3465,7 +3731,8 @@ compose_flow_removed(const struct rule *rule, long long int now, uint8_t reason) uint32_t msec = tdiff - (sec * 1000); ofr = make_openflow(sizeof *ofr, OFPT_FLOW_REMOVED, &buf); - flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &ofr->match); + flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, p->tun_id_from_cookie, + &ofr->match); ofr->cookie = rule->flow_cookie; ofr->priority = htons(rule->cr.priority); ofr->reason = reason; @@ -3490,6 +3757,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) @@ -3506,11 +3774,12 @@ 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->role != NX_ROLE_SLAVE) { if (prev) { queue_tx(ofpbuf_clone(buf), prev, prev->reply_counter); } else { - buf = compose_flow_removed(rule, now, reason); + buf = compose_flow_removed(p, rule, now, reason); } prev = ofconn; } @@ -3637,67 +3906,67 @@ update_used(struct ofproto *p) } 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 ofconn *ofconn = ofconn_; + struct ofproto *ofproto = ofconn->ofproto; struct odp_msg *msg = packet->data; struct ofpbuf payload; struct ofpbuf *opi; - uint8_t reason; + uint32_t buffer_id; + int send_len; /* Extract packet payload from 'msg'. */ payload.data = msg + 1; payload.size = msg->length - sizeof *msg; - /* 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); + /* Construct packet-in message. */ + send_len = INT_MAX; + if (msg->type == _ODPL_ACTION_NR) { + buffer_id = UINT32_MAX; + } else { + if (ofproto->fail_open && fail_open_is_active(ofproto->fail_open)) { + buffer_id = pktbuf_get_null(); + } else { + buffer_id = pktbuf_save(ofconn->pktbuf, &payload, msg->port); + } + if (buffer_id != UINT32_MAX) { + send_len = ofconn->miss_send_len; + } + } + opi = make_packet_in(buffer_id, odp_port_to_ofp_port(msg->port), + msg->type, &payload, send_len); /* Send. */ rconn_send_with_limit(ofconn->rconn, opi, ofconn->packet_in_counter, 100); -} -static void -send_packet_in_action(struct ofpbuf *packet, void *p_) -{ - struct ofproto *p = p_; - struct ofconn *ofconn; - struct odp_msg *msg; - - 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); - } - } ofpbuf_delete(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 odp_msg *msg = packet->data; + struct ofconn *ofconn, *prev; - 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 - : UINT32_MAX); - do_send_packet_in(ofconn, buffer_id, packet, send_len); + assert(msg->type == _ODPL_MISS_NR || msg->type == _ODPL_ACTION_NR); + + prev = NULL; + LIST_FOR_EACH (ofconn, struct ofconn, node, &ofproto->all_conns) { + if (ofconn->role != NX_ROLE_SLAVE) { + if (prev) { + pinsched_send(prev->schedulers[msg->type], msg->port, + ofpbuf_clone(packet), do_send_packet_in, prev); + } + prev = ofconn; } } - ofpbuf_delete(packet); + if (prev) { + pinsched_send(prev->schedulers[msg->type], msg->port, + packet, do_send_packet_in, prev); + } else { + ofpbuf_delete(packet); + } } static uint64_t