+/* Port status watcher. */
+
+typedef void port_watcher_cb_func(uint16_t port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new,
+ void *aux);
+
+struct port_watcher_cb {
+ port_watcher_cb_func *function;
+ void *aux;
+};
+
+struct port_watcher {
+ struct rconn *local_rconn;
+ struct rconn *remote_rconn;
+ struct ofp_phy_port ports[OFPP_MAX + 1];
+ time_t last_feature_request;
+ bool got_feature_reply;
+ int n_txq;
+ struct port_watcher_cb cbs[2];
+ int n_cbs;
+};
+
+/* Returns the number of fields that differ from 'a' to 'b'. */
+static int
+opp_differs(const struct ofp_phy_port *a, const struct ofp_phy_port *b)
+{
+ BUILD_ASSERT_DECL(sizeof *a == 36); /* Trips when we add or remove fields. */
+ return ((a->port_no != b->port_no)
+ + (memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr) != 0)
+ + (memcmp(a->name, b->name, sizeof a->name) != 0)
+ + (a->flags != b->flags)
+ + (a->speed != b->speed)
+ + (a->features != b->features));
+}
+
+static void
+sanitize_opp(struct ofp_phy_port *opp)
+{
+ size_t i;
+
+ for (i = 0; i < sizeof opp->name; i++) {
+ char c = opp->name[i];
+ if (c && (c < 0x20 || c > 0x7e)) {
+ opp->name[i] = '.';
+ }
+ }
+ opp->name[sizeof opp->name - 1] = '\0';
+}
+
+static int
+port_no_to_pw_idx(int port_no)
+{
+ return (port_no < OFPP_MAX ? port_no
+ : port_no == OFPP_LOCAL ? OFPP_MAX
+ : -1);
+}
+
+static void
+call_pw_callbacks(struct port_watcher *pw, int port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new)
+{
+ if (opp_differs(old, new)) {
+ int i;
+ for (i = 0; i < pw->n_cbs; i++) {
+ pw->cbs[i].function(port_no, old, new, pw->cbs[i].aux);
+ }
+ }
+}
+
+static void
+update_phy_port(struct port_watcher *pw, struct ofp_phy_port *opp,
+ uint8_t reason, bool seen[OFPP_MAX + 1])
+{
+ struct ofp_phy_port *pw_opp;
+ struct ofp_phy_port old;
+ uint16_t port_no;
+ int idx;
+
+ port_no = ntohs(opp->port_no);
+ idx = port_no_to_pw_idx(port_no);
+ if (idx < 0) {
+ return;
+ }
+
+ if (seen) {
+ seen[idx] = true;
+ }
+
+ pw_opp = &pw->ports[idx];
+ old = *pw_opp;
+ if (reason == OFPPR_DELETE) {
+ memset(pw_opp, 0, sizeof *pw_opp);
+ pw_opp->port_no = htons(OFPP_NONE);
+ } else if (reason == OFPPR_MOD || reason == OFPPR_ADD) {
+ *pw_opp = *opp;
+ sanitize_opp(pw_opp);
+ }
+ call_pw_callbacks(pw, port_no, &old, pw_opp);
+}
+
+static bool
+port_watcher_local_packet_cb(struct relay *r, void *pw_)
+{
+ struct port_watcher *pw = pw_;
+ struct buffer *msg = r->halves[HALF_LOCAL].rxbuf;
+ struct ofp_header *oh = msg->data;
+
+ if (oh->type == OFPT_FEATURES_REPLY
+ && msg->size >= offsetof(struct ofp_switch_features, ports)) {
+ struct ofp_switch_features *osf = msg->data;
+ bool seen[ARRAY_SIZE(pw->ports)];
+ size_t n_ports;
+ size_t i;
+
+ pw->got_feature_reply = true;
+
+ /* Update each port included in the message. */
+ memset(seen, 0, sizeof seen);
+ n_ports = ((msg->size - offsetof(struct ofp_switch_features, ports))
+ / sizeof *osf->ports);
+ for (i = 0; i < n_ports; i++) {
+ update_phy_port(pw, &osf->ports[i], OFPPR_MOD, seen);
+ }
+
+ /* Delete all the ports not included in the message. */
+ for (i = 0; i < ARRAY_SIZE(pw->ports); i++) {
+ if (!seen[i]) {
+ update_phy_port(pw, &pw->ports[i], OFPPR_DELETE, NULL);
+ }
+ }
+ } else if (oh->type == OFPT_PORT_STATUS
+ && msg->size >= sizeof(struct ofp_port_status)) {
+ struct ofp_port_status *ops = msg->data;
+ update_phy_port(pw, &ops->desc, ops->reason, NULL);
+ }
+ return false;
+}
+
+static void
+port_watcher_periodic_cb(void *pw_)
+{
+ struct port_watcher *pw = pw_;
+
+ if (!pw->got_feature_reply && time_now() >= pw->last_feature_request + 5) {
+ struct buffer *b;
+ make_openflow(sizeof(struct ofp_header), OFPT_FEATURES_REQUEST, &b);
+ rconn_send_with_limit(pw->local_rconn, b, &pw->n_txq, 1);
+ pw->last_feature_request = time_now();
+ }
+}
+
+static void
+put_duplexes(struct ds *ds, const char *name, uint32_t features,
+ uint32_t hd_bit, uint32_t fd_bit)
+{
+ if (features & (hd_bit | fd_bit)) {
+ ds_put_format(ds, " %s", name);
+ if (features & hd_bit) {
+ ds_put_cstr(ds, "(HD)");
+ }
+ if (features & fd_bit) {
+ ds_put_cstr(ds, "(FD)");
+ }
+ }
+}
+
+static void
+log_port_status(uint16_t port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new,
+ void *aux)
+{
+ if (VLOG_IS_DBG_ENABLED()) {
+ bool was_enabled = old->port_no != htons(OFPP_NONE);
+ bool now_enabled = new->port_no != htons(OFPP_NONE);
+ uint32_t features = ntohl(new->features);
+ struct ds ds;
+
+ if (old->flags != new->flags && opp_differs(old, new) == 1) {
+ /* Don't care if only flags changed. */
+ return;
+ }
+
+ ds_init(&ds);
+ ds_put_format(&ds, "\"%s\", "ETH_ADDR_FMT, new->name,
+ ETH_ADDR_ARGS(new->hw_addr));
+ if (ntohl(new->speed)) {
+ ds_put_format(&ds, ", speed %"PRIu32, ntohl(new->speed));
+ }
+ if (features & (OFPPF_10MB_HD | OFPPF_10MB_FD
+ | OFPPF_100MB_HD | OFPPF_100MB_FD
+ | OFPPF_1GB_HD | OFPPF_1GB_FD | OFPPF_10GB_FD)) {
+ ds_put_cstr(&ds, ", supports");
+ put_duplexes(&ds, "10M", features, OFPPF_10MB_HD, OFPPF_10MB_FD);
+ put_duplexes(&ds, "100M", features,
+ OFPPF_100MB_HD, OFPPF_100MB_FD);
+ put_duplexes(&ds, "1G", features, OFPPF_100MB_HD, OFPPF_100MB_FD);
+ if (features & OFPPF_10GB_FD) {
+ ds_put_cstr(&ds, " 10G");
+ }
+ }
+ if (was_enabled != now_enabled) {
+ if (now_enabled) {
+ VLOG_DBG("Port %d added: %s", port_no, ds_cstr(&ds));
+ } else {
+ VLOG_DBG("Port %d deleted", port_no);
+ }
+ } else {
+ VLOG_DBG("Port %d changed: %s", port_no, ds_cstr(&ds));
+ }
+ ds_destroy(&ds);
+ }
+}
+
+static void
+port_watcher_register_callback(struct port_watcher *pw,
+ port_watcher_cb_func *function,
+ void *aux)
+{
+ assert(pw->n_cbs < ARRAY_SIZE(pw->cbs));
+ pw->cbs[pw->n_cbs].function = function;
+ pw->cbs[pw->n_cbs].aux = aux;
+ pw->n_cbs++;
+}
+
+static uint32_t
+port_watcher_get_flags(const struct port_watcher *pw, int port_no)
+{
+ int idx = port_no_to_pw_idx(port_no);
+ return idx >= 0 ? ntohl(pw->ports[idx].flags) : 0;
+}
+
+static void
+port_watcher_set_flags(struct port_watcher *pw,
+ int port_no, uint32_t flags, uint32_t mask)
+{
+ struct ofp_phy_port old;
+ struct ofp_phy_port *p;
+ struct ofp_port_mod *opm;
+ struct ofp_port_status *ops;
+ struct buffer *b;
+ int idx;
+
+ idx = port_no_to_pw_idx(port_no);
+ if (idx < 0) {
+ return;
+ }
+
+ p = &pw->ports[idx];
+ if (!((ntohl(p->flags) ^ flags) & mask)) {
+ return;
+ }
+ old = *p;
+
+ /* Update our idea of the flags. */
+ p->flags = ntohl(flags);
+ call_pw_callbacks(pw, port_no, &old, p);
+
+ /* Change the flags in the datapath. */
+ opm = make_openflow(sizeof *opm, OFPT_PORT_MOD, &b);
+ opm->mask = htonl(mask);
+ opm->desc = *p;
+ rconn_send(pw->local_rconn, b, NULL);
+
+ /* Notify the controller that the flags changed. */
+ ops = make_openflow(sizeof *ops, OFPT_PORT_STATUS, &b);
+ ops->reason = OFPPR_MOD;
+ ops->desc = *p;
+ rconn_send(pw->remote_rconn, b, NULL);
+}
+
+static bool
+port_watcher_is_ready(const struct port_watcher *pw)
+{
+ return pw->got_feature_reply;
+}
+
+static struct hook
+port_watcher_create(struct rconn *local_rconn, struct rconn *remote_rconn,
+ struct port_watcher **pwp)
+{
+ struct port_watcher *pw;
+ int i;
+
+ pw = *pwp = xcalloc(1, sizeof *pw);
+ pw->local_rconn = local_rconn;
+ pw->remote_rconn = remote_rconn;
+ pw->last_feature_request = TIME_MIN;
+ for (i = 0; i < OFPP_MAX; i++) {
+ pw->ports[i].port_no = htons(OFPP_NONE);
+ }
+ port_watcher_register_callback(pw, log_port_status, NULL);
+ return make_hook(port_watcher_local_packet_cb, NULL,
+ port_watcher_periodic_cb, NULL, pw);
+}
+\f
+/* Spanning tree protocol. */
+
+/* Extra time, in seconds, at boot before going into fail-open, to give the
+ * spanning tree protocol time to figure out the network layout. */
+#define STP_EXTRA_BOOT_TIME 30
+
+struct stp_data {
+ struct stp *stp;
+ struct port_watcher *pw;
+ struct rconn *local_rconn;
+ struct rconn *remote_rconn;
+ uint8_t dpid[ETH_ADDR_LEN];
+ long long int last_tick_256ths;
+ int n_txq;
+};
+
+static bool
+stp_local_packet_cb(struct relay *r, void *stp_)
+{
+ struct stp_data *stp = stp_;
+ struct ofp_packet_in *opi;
+ struct eth_header *eth;
+ struct llc_header *llc;
+ struct buffer payload;
+ uint16_t port_no;
+ struct flow flow;
+
+ if (!get_ofp_packet_eth_header(r, &opi, ð)
+ || !eth_addr_equals(eth->eth_dst, stp_eth_addr)) {
+ return false;
+ }
+
+ port_no = ntohs(opi->in_port);
+ if (port_no >= STP_MAX_PORTS) {
+ /* STP only supports 255 ports. */
+ return false;
+ }
+ if (port_watcher_get_flags(stp->pw, port_no) & OFPPFL_NO_STP) {
+ /* We're not doing STP on this port. */
+ return false;
+ }
+
+ if (opi->reason == OFPR_ACTION) {
+ /* The controller set up a flow for this, so we won't intercept it. */
+ return false;
+ }
+
+ get_ofp_packet_payload(opi, &payload);
+ flow_extract(&payload, port_no, &flow);
+ if (flow.dl_type != htons(OFP_DL_TYPE_NOT_ETH_TYPE)) {
+ VLOG_DBG("non-LLC frame received on STP multicast address");
+ return false;
+ }
+ llc = buffer_at_assert(&payload, sizeof *eth, sizeof *llc);
+ if (llc->llc_dsap != STP_LLC_DSAP) {
+ VLOG_DBG("bad DSAP 0x%02"PRIx8" received on STP multicast address",
+ llc->llc_dsap);
+ return false;
+ }
+
+ /* Trim off padding on payload. */
+ if (payload.size > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
+ payload.size = ntohs(eth->eth_type) + ETH_HEADER_LEN;
+ }
+ if (buffer_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
+ struct stp_port *p = stp_get_port(stp->stp, port_no);
+ stp_received_bpdu(p, payload.data, payload.size);
+ }
+
+ return true;
+}
+
+static long long int
+time_256ths(void)
+{
+ return time_msec() * 256 / 1000;
+}
+
+static void
+stp_periodic_cb(void *stp_)
+{
+ struct stp_data *stp = stp_;
+ long long int now_256ths = time_256ths();
+ long long int elapsed_256ths = now_256ths - stp->last_tick_256ths;
+ struct stp_port *p;
+
+ if (!port_watcher_is_ready(stp->pw)) {
+ /* Can't start STP until we know port flags, because port flags can
+ * disable STP. */
+ return;
+ }
+ if (elapsed_256ths <= 0) {
+ return;
+ }
+
+ stp_tick(stp->stp, MIN(INT_MAX, elapsed_256ths));
+ stp->last_tick_256ths = now_256ths;
+
+ while (stp_get_changed_port(stp->stp, &p)) {
+ int port_no = stp_port_no(p);
+ enum stp_state state = stp_port_get_state(p);
+
+ if (state != STP_DISABLED) {
+ VLOG_WARN("STP: Port %d entered %s state",
+ port_no, stp_state_name(state));
+ }
+ if (!(port_watcher_get_flags(stp->pw, port_no) & OFPPFL_NO_STP)) {
+ uint32_t flags;
+ switch (state) {
+ case STP_LISTENING:
+ flags = OFPPFL_STP_LISTEN;
+ break;
+ case STP_LEARNING:
+ flags = OFPPFL_STP_LEARN;
+ break;
+ case STP_DISABLED:
+ case STP_FORWARDING:
+ flags = OFPPFL_STP_FORWARD;
+ break;
+ case STP_BLOCKING:
+ flags = OFPPFL_STP_BLOCK;
+ break;
+ default:
+ VLOG_DBG_RL(&vrl, "STP: Port %d has bad state %x",
+ port_no, state);
+ flags = OFPPFL_STP_FORWARD;
+ break;
+ }
+ if (!stp_forward_in_state(state)) {
+ flags |= OFPPFL_NO_FLOOD;
+ }
+ port_watcher_set_flags(stp->pw, port_no, flags,
+ OFPPFL_STP_MASK | OFPPFL_NO_FLOOD);
+ } else {
+ /* We don't own those flags. */
+ }
+ }
+}
+
+static void
+stp_wait_cb(void *stp_ UNUSED)
+{
+ poll_timer_wait(1000);
+}
+
+static void
+send_bpdu(const void *bpdu, size_t bpdu_size, int port_no, void *stp_)
+{
+ struct stp_data *stp = stp_;
+ struct eth_header *eth;
+ struct llc_header *llc;
+ struct buffer pkt, *opo;
+
+ /* Packet skeleton. */
+ buffer_init(&pkt, ETH_HEADER_LEN + LLC_HEADER_LEN + bpdu_size);
+ eth = buffer_put_uninit(&pkt, sizeof *eth);
+ llc = buffer_put_uninit(&pkt, sizeof *llc);
+ buffer_put(&pkt, bpdu, bpdu_size);
+
+ /* 802.2 header. */
+ memcpy(eth->eth_dst, stp_eth_addr, ETH_ADDR_LEN);
+ memcpy(eth->eth_src, stp->pw->ports[port_no].hw_addr, ETH_ADDR_LEN);
+ eth->eth_type = htons(pkt.size - ETH_HEADER_LEN);
+
+ /* LLC header. */
+ llc->llc_dsap = STP_LLC_DSAP;
+ llc->llc_ssap = STP_LLC_SSAP;
+ llc->llc_cntl = STP_LLC_CNTL;
+
+ opo = make_unbuffered_packet_out(&pkt, OFPP_NONE, port_no);
+ buffer_uninit(&pkt);
+ rconn_send_with_limit(stp->local_rconn, opo, &stp->n_txq, OFPP_MAX);
+}
+
+static void
+stp_port_watcher_cb(uint16_t port_no,
+ const struct ofp_phy_port *old,
+ const struct ofp_phy_port *new,
+ void *stp_)
+{
+ struct stp_data *stp = stp_;
+ struct stp_port *p;
+
+ /* STP only supports a maximum of 255 ports, one less than OpenFlow. We
+ * don't support STP on OFPP_LOCAL, either. */
+ if (port_no >= STP_MAX_PORTS) {
+ return;
+ }
+
+ p = stp_get_port(stp->stp, port_no);
+ if (new->port_no == htons(OFPP_NONE)
+ || new->flags & htonl(OFPPFL_NO_STP)) {
+ stp_port_disable(p);
+ } else {
+ stp_port_enable(p);
+ stp_port_set_speed(p, new->speed);
+ }
+}
+
+static struct hook
+stp_hook_create(const struct settings *s, struct port_watcher *pw,
+ struct rconn *local, struct rconn *remote)
+{
+ uint8_t dpid[ETH_ADDR_LEN];
+ struct netdev *netdev;
+ struct stp_data *stp;
+ int retval;
+
+ retval = netdev_open(s->of_name, NETDEV_ETH_TYPE_NONE, &netdev);
+ if (retval) {
+ fatal(retval, "Could not open %s device", s->of_name);
+ }
+ memcpy(dpid, netdev_get_etheraddr(netdev), ETH_ADDR_LEN);
+ netdev_close(netdev);
+
+ stp = xcalloc(1, sizeof *stp);
+ stp->stp = stp_create("stp", eth_addr_to_uint64(dpid), send_bpdu, stp);
+ stp->pw = pw;
+ memcpy(stp->dpid, dpid, ETH_ADDR_LEN);
+ stp->local_rconn = local;
+ stp->remote_rconn = remote;
+ stp->last_tick_256ths = time_256ths();
+
+ port_watcher_register_callback(pw, stp_port_watcher_cb, stp);
+ return make_hook(stp_local_packet_cb, NULL,
+ stp_periodic_cb, stp_wait_cb, stp);
+}
+\f