Rename "secchan" to "ofproto" (library) and "ovs-openflowd" (program).
[openvswitch] / vswitchd / bridge.c
1 /* Copyright (c) 2008, 2009 Nicira Networks
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 #include <config.h>
17 #include "bridge.h"
18 #include <assert.h>
19 #include <errno.h>
20 #include <arpa/inet.h>
21 #include <ctype.h>
22 #include <inttypes.h>
23 #include <net/if.h>
24 #include <openflow/openflow.h>
25 #include <signal.h>
26 #include <stdlib.h>
27 #include <strings.h>
28 #include <sys/stat.h>
29 #include <sys/socket.h>
30 #include <sys/types.h>
31 #include <unistd.h>
32 #include "bitmap.h"
33 #include "cfg.h"
34 #include "coverage.h"
35 #include "dirs.h"
36 #include "dpif.h"
37 #include "dynamic-string.h"
38 #include "flow.h"
39 #include "hash.h"
40 #include "list.h"
41 #include "mac-learning.h"
42 #include "netdev.h"
43 #include "odp-util.h"
44 #include "ofp-print.h"
45 #include "ofpbuf.h"
46 #include "ofproto/ofproto.h"
47 #include "packets.h"
48 #include "poll-loop.h"
49 #include "port-array.h"
50 #include "proc-net-compat.h"
51 #include "process.h"
52 #include "socket-util.h"
53 #include "stp.h"
54 #include "svec.h"
55 #include "timeval.h"
56 #include "util.h"
57 #include "unixctl.h"
58 #include "vconn.h"
59 #include "vconn-ssl.h"
60 #include "xenserver.h"
61 #include "xtoxll.h"
62
63 #define THIS_MODULE VLM_bridge
64 #include "vlog.h"
65
66 struct dst {
67     uint16_t vlan;
68     uint16_t dp_ifidx;
69 };
70
71 extern uint64_t mgmt_id;
72
73 struct iface {
74     struct port *port;          /* Containing port. */
75     size_t port_ifidx;          /* Index within containing port. */
76
77     char *name;                 /* Host network device name. */
78     int dp_ifidx;               /* Index within kernel datapath. */
79
80     uint8_t mac[ETH_ADDR_LEN];  /* Ethernet address (all zeros if unknowns). */
81
82     tag_type tag;               /* Tag associated with this interface. */
83     bool enabled;               /* May be chosen for flows? */
84     long long delay_expires;    /* Time after which 'enabled' may change. */
85 };
86
87 #define BOND_MASK 0xff
88 struct bond_entry {
89     int iface_idx;              /* Index of assigned iface, or -1 if none. */
90     uint64_t tx_bytes;          /* Count of bytes recently transmitted. */
91     tag_type iface_tag;         /* Tag associated with iface_idx. */
92 };
93
94 #define MAX_MIRRORS 32
95 typedef uint32_t mirror_mask_t;
96 #define MIRROR_MASK_C(X) UINT32_C(X)
97 BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
98 struct mirror {
99     struct bridge *bridge;
100     size_t idx;
101     char *name;
102
103     /* Selection criteria. */
104     struct svec src_ports;
105     struct svec dst_ports;
106     int *vlans;
107     size_t n_vlans;
108
109     /* Output. */
110     struct port *out_port;
111     int out_vlan;
112 };
113
114 #define FLOOD_PORT ((struct port *) 1) /* The 'flood' output port. */
115 struct port {
116     struct bridge *bridge;
117     size_t port_idx;
118     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
119     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1. */
120     char *name;
121
122     /* An ordinary bridge port has 1 interface.
123      * A bridge port for bonding has at least 2 interfaces. */
124     struct iface **ifaces;
125     size_t n_ifaces, allocated_ifaces;
126
127     /* Bonding info. */
128     struct bond_entry *bond_hash; /* An array of (BOND_MASK + 1) elements. */
129     int active_iface;           /* Ifidx on which bcasts accepted, or -1. */
130     tag_type active_iface_tag;  /* Tag for bcast flows. */
131     tag_type no_ifaces_tag;     /* Tag for flows when all ifaces disabled. */
132     int updelay, downdelay;     /* Delay before iface goes up/down, in ms. */
133
134     /* Port mirroring info. */
135     mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
136     mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
137     bool is_mirror_output_port; /* Does port mirroring send frames here? */
138
139     /* Spanning tree info. */
140     enum stp_state stp_state;   /* Always STP_FORWARDING if STP not in use. */
141     tag_type stp_state_tag;     /* Tag for STP state change. */
142 };
143
144 #define DP_MAX_PORTS 255
145 struct bridge {
146     struct list node;           /* Node in global list of bridges. */
147     char *name;                 /* User-specified arbitrary name. */
148     struct mac_learning *ml;    /* MAC learning table, or null not to learn. */
149     bool sent_config_request;   /* Successfully sent config request? */
150     uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
151
152     /* Support for remote controllers. */
153     char *controller;           /* NULL if there is no remote controller;
154                                  * "discover" to do controller discovery;
155                                  * otherwise a vconn name. */
156
157     /* OpenFlow switch processing. */
158     struct ofproto *ofproto;    /* OpenFlow switch. */
159
160     /* Kernel datapath information. */
161     struct dpif *dpif;          /* Datapath. */
162     struct port_array ifaces;   /* Indexed by kernel datapath port number. */
163
164     /* Bridge ports. */
165     struct port **ports;
166     size_t n_ports, allocated_ports;
167
168     /* Bonding. */
169     bool has_bonded_ports;
170     long long int bond_next_rebalance;
171
172     /* Flow tracking. */
173     bool flush;
174
175     /* Flow statistics gathering. */
176     time_t next_stats_request;
177
178     /* Port mirroring. */
179     struct mirror *mirrors[MAX_MIRRORS];
180
181     /* Spanning tree. */
182     struct stp *stp;
183     long long int stp_last_tick;
184 };
185
186 /* List of all bridges. */
187 static struct list all_bridges = LIST_INITIALIZER(&all_bridges);
188
189 /* Maximum number of datapaths. */
190 enum { DP_MAX = 256 };
191
192 static struct bridge *bridge_create(const char *name);
193 static void bridge_destroy(struct bridge *);
194 static struct bridge *bridge_lookup(const char *name);
195 static int bridge_run_one(struct bridge *);
196 static void bridge_reconfigure_one(struct bridge *);
197 static void bridge_reconfigure_controller(struct bridge *);
198 static void bridge_get_all_ifaces(const struct bridge *, struct svec *ifaces);
199 static void bridge_fetch_dp_ifaces(struct bridge *);
200 static void bridge_flush(struct bridge *);
201 static void bridge_pick_local_hw_addr(struct bridge *,
202                                       uint8_t ea[ETH_ADDR_LEN],
203                                       const char **devname);
204 static uint64_t bridge_pick_datapath_id(struct bridge *,
205                                         const uint8_t bridge_ea[ETH_ADDR_LEN],
206                                         const char *devname);
207 static uint64_t dpid_from_hash(const void *, size_t nbytes);
208
209 static void bond_init(void);
210 static void bond_run(struct bridge *);
211 static void bond_wait(struct bridge *);
212 static void bond_rebalance_port(struct port *);
213 static void bond_send_learning_packets(struct port *);
214
215 static void port_create(struct bridge *, const char *name);
216 static void port_reconfigure(struct port *);
217 static void port_destroy(struct port *);
218 static struct port *port_lookup(const struct bridge *, const char *name);
219 static struct iface *port_lookup_iface(const struct port *, const char *name);
220 static struct port *port_from_dp_ifidx(const struct bridge *,
221                                        uint16_t dp_ifidx);
222 static void port_update_bond_compat(struct port *);
223 static void port_update_vlan_compat(struct port *);
224
225 static void mirror_create(struct bridge *, const char *name);
226 static void mirror_destroy(struct mirror *);
227 static void mirror_reconfigure(struct bridge *);
228 static void mirror_reconfigure_one(struct mirror *);
229 static bool vlan_is_mirrored(const struct mirror *, int vlan);
230
231 static void brstp_reconfigure(struct bridge *);
232 static void brstp_adjust_timers(struct bridge *);
233 static void brstp_run(struct bridge *);
234 static void brstp_wait(struct bridge *);
235
236 static void iface_create(struct port *, const char *name);
237 static void iface_destroy(struct iface *);
238 static struct iface *iface_lookup(const struct bridge *, const char *name);
239 static struct iface *iface_from_dp_ifidx(const struct bridge *,
240                                          uint16_t dp_ifidx);
241
242 /* Hooks into ofproto processing. */
243 static struct ofhooks bridge_ofhooks;
244 \f
245 /* Public functions. */
246
247 /* Adds the name of each interface used by a bridge, including local and
248  * internal ports, to 'svec'. */
249 void
250 bridge_get_ifaces(struct svec *svec) 
251 {
252     struct bridge *br, *next;
253     size_t i, j;
254
255     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
256         for (i = 0; i < br->n_ports; i++) {
257             struct port *port = br->ports[i];
258
259             for (j = 0; j < port->n_ifaces; j++) {
260                 struct iface *iface = port->ifaces[j];
261                 if (iface->dp_ifidx < 0) {
262                     VLOG_ERR("%s interface not in datapath %s, ignoring",
263                              iface->name, dpif_name(br->dpif));
264                 } else {
265                     if (iface->dp_ifidx != ODPP_LOCAL) {
266                         svec_add(svec, iface->name);
267                     }
268                 }
269             }
270         }
271     }
272 }
273
274 /* The caller must already have called cfg_read(). */
275 void
276 bridge_init(void)
277 {
278     struct svec dpif_names;
279     size_t i;
280
281     dp_enumerate(&dpif_names);
282     for (i = 0; i < dpif_names.n; i++) {
283         const char *dpif_name = dpif_names.names[i];
284         struct dpif *dpif;
285         int retval;
286
287         retval = dpif_open(dpif_name, &dpif);
288         if (!retval) {
289             struct svec all_names;
290             size_t j;
291
292             svec_init(&all_names);
293             dpif_get_all_names(dpif, &all_names);
294             for (j = 0; j < all_names.n; j++) {
295                 if (cfg_has("bridge.%s.port", all_names.names[j])) {
296                     goto found;
297                 }
298             }
299             dpif_delete(dpif);
300         found:
301             svec_destroy(&all_names);
302             dpif_close(dpif);
303         }
304     }
305
306     bond_init();
307     bridge_reconfigure();
308 }
309
310 #ifdef HAVE_OPENSSL
311 static bool
312 config_string_change(const char *key, char **valuep)
313 {
314     const char *value = cfg_get_string(0, "%s", key);
315     if (value && (!*valuep || strcmp(value, *valuep))) {
316         free(*valuep);
317         *valuep = xstrdup(value);
318         return true;
319     } else {
320         return false;
321     }
322 }
323
324 static void
325 bridge_configure_ssl(void)
326 {
327     /* XXX SSL should be configurable on a per-bridge basis.
328      * XXX should be possible to de-configure SSL. */
329     static char *private_key_file;
330     static char *certificate_file;
331     static char *cacert_file;
332     struct stat s;
333
334     if (config_string_change("ssl.private-key", &private_key_file)) {
335         vconn_ssl_set_private_key_file(private_key_file);
336     }
337
338     if (config_string_change("ssl.certificate", &certificate_file)) {
339         vconn_ssl_set_certificate_file(certificate_file);
340     }
341
342     /* We assume that even if the filename hasn't changed, if the CA cert 
343      * file has been removed, that we want to move back into
344      * boot-strapping mode.  This opens a small security hole, because
345      * the old certificate will still be trusted until vSwitch is
346      * restarted.  We may want to address this in vconn's SSL library. */
347     if (config_string_change("ssl.ca-cert", &cacert_file)
348         || (cacert_file && stat(cacert_file, &s) && errno == ENOENT)) {
349         vconn_ssl_set_ca_cert_file(cacert_file,
350                                    cfg_get_bool(0, "ssl.bootstrap-ca-cert"));
351     }
352 }
353 #endif
354
355 void
356 bridge_reconfigure(void)
357 {
358     struct svec old_br, new_br;
359     struct bridge *br, *next;
360     size_t i, j;
361
362     COVERAGE_INC(bridge_reconfigure);
363
364     /* Collect old and new bridges. */
365     svec_init(&old_br);
366     svec_init(&new_br);
367     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
368         svec_add(&old_br, br->name);
369     }
370     cfg_get_subsections(&new_br, "bridge");
371
372     /* Get rid of deleted bridges and add new bridges. */
373     svec_sort(&old_br);
374     svec_sort(&new_br);
375     assert(svec_is_unique(&old_br));
376     assert(svec_is_unique(&new_br));
377     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
378         if (!svec_contains(&new_br, br->name)) {
379             bridge_destroy(br);
380         }
381     }
382     for (i = 0; i < new_br.n; i++) {
383         const char *name = new_br.names[i];
384         if (!svec_contains(&old_br, name)) {
385             bridge_create(name);
386         }
387     }
388     svec_destroy(&old_br);
389     svec_destroy(&new_br);
390
391 #ifdef HAVE_OPENSSL
392     /* Configure SSL. */
393     bridge_configure_ssl();
394 #endif
395
396     /* Reconfigure all bridges. */
397     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
398         bridge_reconfigure_one(br);
399     }
400
401     /* Add and delete ports on all datapaths.
402      *
403      * The kernel will reject any attempt to add a given port to a datapath if
404      * that port already belongs to a different datapath, so we must do all
405      * port deletions before any port additions. */
406     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
407         struct odp_port *dpif_ports;
408         size_t n_dpif_ports;
409         struct svec want_ifaces;
410
411         dpif_port_list(br->dpif, &dpif_ports, &n_dpif_ports);
412         bridge_get_all_ifaces(br, &want_ifaces);
413         for (i = 0; i < n_dpif_ports; i++) {
414             const struct odp_port *p = &dpif_ports[i];
415             if (!svec_contains(&want_ifaces, p->devname)
416                 && strcmp(p->devname, br->name)) {
417                 int retval = dpif_port_del(br->dpif, p->port);
418                 if (retval) {
419                     VLOG_ERR("failed to remove %s interface from %s: %s",
420                              p->devname, dpif_name(br->dpif),
421                              strerror(retval));
422                 }
423             }
424         }
425         svec_destroy(&want_ifaces);
426         free(dpif_ports);
427     }
428     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
429         struct odp_port *dpif_ports;
430         size_t n_dpif_ports;
431         struct svec cur_ifaces, want_ifaces, add_ifaces;
432
433         dpif_port_list(br->dpif, &dpif_ports, &n_dpif_ports);
434         svec_init(&cur_ifaces);
435         for (i = 0; i < n_dpif_ports; i++) {
436             svec_add(&cur_ifaces, dpif_ports[i].devname);
437         }
438         free(dpif_ports);
439         svec_sort_unique(&cur_ifaces);
440         bridge_get_all_ifaces(br, &want_ifaces);
441         svec_diff(&want_ifaces, &cur_ifaces, &add_ifaces, NULL, NULL);
442
443         for (i = 0; i < add_ifaces.n; i++) {
444             const char *if_name = add_ifaces.names[i];
445             int internal = cfg_get_bool(0, "iface.%s.internal", if_name);
446             int flags = internal ? ODP_PORT_INTERNAL : 0;
447             int error = dpif_port_add(br->dpif, if_name, flags, NULL);
448             if (error == EXFULL) {
449                 VLOG_ERR("ran out of valid port numbers on %s",
450                          dpif_name(br->dpif));
451                 break;
452             } else if (error) {
453                 VLOG_ERR("failed to add %s interface to %s: %s",
454                          if_name, dpif_name(br->dpif), strerror(error));
455             }
456         }
457         svec_destroy(&cur_ifaces);
458         svec_destroy(&want_ifaces);
459         svec_destroy(&add_ifaces);
460     }
461     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
462         uint8_t ea[8];
463         uint64_t dpid;
464         struct iface *local_iface = NULL;
465         const char *devname;
466         uint8_t engine_type, engine_id;
467         bool add_id_to_iface = false;
468         struct svec nf_hosts;
469
470         bridge_fetch_dp_ifaces(br);
471         for (i = 0; i < br->n_ports; ) {
472             struct port *port = br->ports[i];
473
474             for (j = 0; j < port->n_ifaces; ) {
475                 struct iface *iface = port->ifaces[j];
476                 if (iface->dp_ifidx < 0) {
477                     VLOG_ERR("%s interface not in %s, dropping",
478                              iface->name, dpif_name(br->dpif));
479                     iface_destroy(iface);
480                 } else {
481                     if (iface->dp_ifidx == ODPP_LOCAL) {
482                         local_iface = iface;
483                     }
484                     VLOG_DBG("%s has interface %s on port %d",
485                              dpif_name(br->dpif),
486                              iface->name, iface->dp_ifidx);
487                     j++;
488                 }
489             }
490             if (!port->n_ifaces) {
491                 VLOG_ERR("%s port has no interfaces, dropping", port->name);
492                 port_destroy(port);
493                 continue;
494             }
495             i++;
496         }
497
498         /* Pick local port hardware address, datapath ID. */
499         bridge_pick_local_hw_addr(br, ea, &devname);
500         if (local_iface) {
501             int error = netdev_nodev_set_etheraddr(local_iface->name, ea);
502             if (error) {
503                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
504                 VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
505                             "Ethernet address: %s",
506                             br->name, strerror(error));
507             }
508         }
509
510         dpid = bridge_pick_datapath_id(br, ea, devname);
511         ofproto_set_datapath_id(br->ofproto, dpid);
512
513         /* Set NetFlow configuration on this bridge. */
514         dpif_get_netflow_ids(br->dpif, &engine_type, &engine_id);
515         if (cfg_has("netflow.%s.engine-type", br->name)) {
516             engine_type = cfg_get_int(0, "netflow.%s.engine-type", 
517                     br->name);
518         }
519         if (cfg_has("netflow.%s.engine-id", br->name)) {
520             engine_id = cfg_get_int(0, "netflow.%s.engine-id", br->name);
521         }
522         if (cfg_has("netflow.%s.add-id-to-iface", br->name)) {
523             add_id_to_iface = cfg_get_bool(0, "netflow.%s.add-id-to-iface",
524                     br->name);
525         }
526         if (add_id_to_iface && engine_id > 0x7f) {
527             VLOG_WARN("bridge %s: netflow port mangling may conflict with "
528                     "another vswitch, choose an engine id less than 128", 
529                     br->name);
530         }
531         if (add_id_to_iface && br->n_ports > 0x1ff) {
532             VLOG_WARN("bridge %s: netflow port mangling will conflict with "
533                     "another port when 512 or more ports are used", 
534                     br->name);
535         }
536         svec_init(&nf_hosts);
537         cfg_get_all_keys(&nf_hosts, "netflow.%s.host", br->name);
538         if (ofproto_set_netflow(br->ofproto, &nf_hosts,  engine_type, 
539                     engine_id, add_id_to_iface)) {
540             VLOG_ERR("bridge %s: problem setting netflow collectors", 
541                     br->name);
542         }
543
544         /* Update the controller and related settings.  It would be more
545          * straightforward to call this from bridge_reconfigure_one(), but we
546          * can't do it there for two reasons.  First, and most importantly, at
547          * that point we don't know the dp_ifidx of any interfaces that have
548          * been added to the bridge (because we haven't actually added them to
549          * the datapath).  Second, at that point we haven't set the datapath ID
550          * yet; when a controller is configured, resetting the datapath ID will
551          * immediately disconnect from the controller, so it's better to set
552          * the datapath ID before the controller. */
553         bridge_reconfigure_controller(br);
554     }
555     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
556         for (i = 0; i < br->n_ports; i++) {
557             struct port *port = br->ports[i];
558             port_update_vlan_compat(port);
559         }
560     }
561     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
562         brstp_reconfigure(br);
563     }
564 }
565
566 static void
567 bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
568                           const char **devname)
569 {
570     uint64_t requested_ea;
571     size_t i, j;
572     int error;
573
574     *devname = NULL;
575
576     /* Did the user request a particular MAC? */
577     requested_ea = cfg_get_mac(0, "bridge.%s.mac", br->name);
578     if (requested_ea) {
579         eth_addr_from_uint64(requested_ea, ea);
580         if (eth_addr_is_multicast(ea)) {
581             VLOG_ERR("bridge %s: cannot set MAC address to multicast "
582                      "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
583         } else if (eth_addr_is_zero(ea)) {
584             VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
585         } else {
586             return;
587         }
588     }
589
590     /* Otherwise choose the minimum MAC address among all of the interfaces.
591      * (Xen uses FE:FF:FF:FF:FF:FF for virtual interfaces so this will get the
592      * MAC of the physical interface in such an environment.) */
593     memset(ea, 0xff, sizeof ea);
594     for (i = 0; i < br->n_ports; i++) {
595         struct port *port = br->ports[i];
596         if (port->is_mirror_output_port) {
597             continue;
598         }
599         for (j = 0; j < port->n_ifaces; j++) {
600             struct iface *iface = port->ifaces[j];
601             uint8_t iface_ea[ETH_ADDR_LEN];
602             if (iface->dp_ifidx == ODPP_LOCAL
603                 || cfg_get_bool(0, "iface.%s.internal", iface->name)) {
604                 continue;
605             }
606             error = netdev_nodev_get_etheraddr(iface->name, iface_ea);
607             if (!error) {
608                 if (!eth_addr_is_multicast(iface_ea) &&
609                     !eth_addr_is_reserved(iface_ea) &&
610                     !eth_addr_is_zero(iface_ea) &&
611                     memcmp(iface_ea, ea, ETH_ADDR_LEN) < 0) {
612                     memcpy(ea, iface_ea, ETH_ADDR_LEN);
613                     *devname = iface->name;
614                 }
615             } else {
616                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
617                 VLOG_ERR_RL(&rl, "failed to obtain Ethernet address of %s: %s",
618                             iface->name, strerror(error));
619             }
620         }
621     }
622     if (eth_addr_is_multicast(ea) || eth_addr_is_vif(ea)) {
623         memcpy(ea, br->default_ea, ETH_ADDR_LEN);
624         *devname = NULL;
625         VLOG_WARN("bridge %s: using default bridge Ethernet "
626                   "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
627     } else {
628         VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT,
629                  br->name, ETH_ADDR_ARGS(ea));
630     }
631 }
632
633 /* Choose and returns the datapath ID for bridge 'br' given that the bridge
634  * Ethernet address is 'bridge_ea'.  If 'bridge_ea' is the Ethernet address of
635  * a network device, then that network device's name must be passed in as
636  * 'devname'; if 'bridge_ea' was derived some other way, then 'devname' must be
637  * passed in as a null pointer. */
638 static uint64_t
639 bridge_pick_datapath_id(struct bridge *br,
640                         const uint8_t bridge_ea[ETH_ADDR_LEN],
641                         const char *devname)
642 {
643     /*
644      * The procedure for choosing a bridge MAC address will, in the most
645      * ordinary case, also choose a unique MAC that we can use as a datapath
646      * ID.  In some special cases, though, multiple bridges will end up with
647      * the same MAC address.  This is OK for the bridges, but it will confuse
648      * the OpenFlow controller, because each datapath needs a unique datapath
649      * ID.
650      *
651      * Datapath IDs must be unique.  It is also very desirable that they be
652      * stable from one run to the next, so that policy set on a datapath
653      * "sticks".
654      */
655     uint64_t dpid;
656
657     dpid = cfg_get_dpid(0, "bridge.%s.datapath-id", br->name);
658     if (dpid) {
659         return dpid;
660     }
661
662     if (devname) {
663         int vlan;
664         if (!netdev_get_vlan_vid(devname, &vlan)) {
665             /*
666              * A bridge whose MAC address is taken from a VLAN network device
667              * (that is, a network device created with vconfig(8) or similar
668              * tool) will have the same MAC address as a bridge on the VLAN
669              * device's physical network device.
670              *
671              * Handle this case by hashing the physical network device MAC
672              * along with the VLAN identifier.
673              */
674             uint8_t buf[ETH_ADDR_LEN + 2];
675             memcpy(buf, bridge_ea, ETH_ADDR_LEN);
676             buf[ETH_ADDR_LEN] = vlan >> 8;
677             buf[ETH_ADDR_LEN + 1] = vlan;
678             return dpid_from_hash(buf, sizeof buf);
679         } else {
680             /*
681              * Assume that this bridge's MAC address is unique, since it
682              * doesn't fit any of the cases we handle specially.
683              */
684         }
685     } else {
686         /*
687          * A purely internal bridge, that is, one that has no non-virtual
688          * network devices on it at all, is more difficult because it has no
689          * natural unique identifier at all.
690          *
691          * When the host is a XenServer, we handle this case by hashing the
692          * host's UUID with the name of the bridge.  Names of bridges are
693          * persistent across XenServer reboots, although they can be reused if
694          * an internal network is destroyed and then a new one is later
695          * created, so this is fairly effective.
696          *
697          * When the host is not a XenServer, we punt by using a random MAC
698          * address on each run.
699          */
700         const char *host_uuid = xenserver_get_host_uuid();
701         if (host_uuid) {
702             char *combined = xasprintf("%s,%s", host_uuid, br->name);
703             dpid = dpid_from_hash(combined, strlen(combined));
704             free(combined);
705             return dpid;
706         }
707     }
708
709     return eth_addr_to_uint64(bridge_ea);
710 }
711
712 static uint64_t
713 dpid_from_hash(const void *data, size_t n)
714 {
715     uint8_t hash[SHA1_DIGEST_SIZE];
716
717     BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN);
718     sha1_bytes(data, n, hash);
719     eth_addr_mark_random(hash);
720     return eth_addr_to_uint64(hash);
721 }
722
723 int
724 bridge_run(void)
725 {
726     struct bridge *br, *next;
727     int retval;
728
729     retval = 0;
730     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
731         int error = bridge_run_one(br);
732         if (error) {
733             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
734             VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, "
735                         "forcing reconfiguration", br->name);
736             if (!retval) {
737                 retval = error;
738             }
739         }
740     }
741     return retval;
742 }
743
744 void
745 bridge_wait(void)
746 {
747     struct bridge *br;
748
749     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
750         ofproto_wait(br->ofproto);
751         if (br->controller) {
752             continue;
753         }
754
755         if (br->ml) {
756             mac_learning_wait(br->ml);
757         }
758         bond_wait(br);
759         brstp_wait(br);
760     }
761 }
762
763 /* Forces 'br' to revalidate all of its flows.  This is appropriate when 'br''s
764  * configuration changes.  */
765 static void
766 bridge_flush(struct bridge *br)
767 {
768     COVERAGE_INC(bridge_flush);
769     br->flush = true;
770     if (br->ml) {
771         mac_learning_flush(br->ml);
772     }
773 }
774 \f
775 /* Bridge reconfiguration functions. */
776
777 static struct bridge *
778 bridge_create(const char *name)
779 {
780     struct bridge *br;
781     int error;
782
783     assert(!bridge_lookup(name));
784     br = xcalloc(1, sizeof *br);
785
786     error = dpif_create(name, &br->dpif);
787     if (error == EEXIST || error == EBUSY) {
788         error = dpif_open(name, &br->dpif);
789         if (error) {
790             VLOG_ERR("datapath %s already exists but cannot be opened: %s",
791                      name, strerror(error));
792             free(br);
793             return NULL;
794         }
795         dpif_flow_flush(br->dpif);
796     } else if (error) {
797         VLOG_ERR("failed to create datapath %s: %s", name, strerror(error));
798         free(br);
799         return NULL;
800     }
801
802     error = ofproto_create(name, &bridge_ofhooks, br, &br->ofproto);
803     if (error) {
804         VLOG_ERR("failed to create switch %s: %s", name, strerror(error));
805         dpif_delete(br->dpif);
806         dpif_close(br->dpif);
807         free(br);
808         return NULL;
809     }
810
811     br->name = xstrdup(name);
812     br->ml = mac_learning_create();
813     br->sent_config_request = false;
814     eth_addr_random(br->default_ea);
815
816     port_array_init(&br->ifaces);
817
818     br->flush = false;
819     br->bond_next_rebalance = time_msec() + 10000;
820
821     list_push_back(&all_bridges, &br->node);
822
823     VLOG_INFO("created bridge %s on %s", br->name, dpif_name(br->dpif));
824
825     return br;
826 }
827
828 static void
829 bridge_destroy(struct bridge *br)
830 {
831     if (br) {
832         int error;
833
834         while (br->n_ports > 0) {
835             port_destroy(br->ports[br->n_ports - 1]);
836         }
837         list_remove(&br->node);
838         error = dpif_delete(br->dpif);
839         if (error && error != ENOENT) {
840             VLOG_ERR("failed to delete %s: %s",
841                      dpif_name(br->dpif), strerror(error));
842         }
843         dpif_close(br->dpif);
844         ofproto_destroy(br->ofproto);
845         free(br->controller);
846         mac_learning_destroy(br->ml);
847         port_array_destroy(&br->ifaces);
848         free(br->ports);
849         free(br->name);
850         free(br);
851     }
852 }
853
854 static struct bridge *
855 bridge_lookup(const char *name)
856 {
857     struct bridge *br;
858
859     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
860         if (!strcmp(br->name, name)) {
861             return br;
862         }
863     }
864     return NULL;
865 }
866
867 bool
868 bridge_exists(const char *name)
869 {
870     return bridge_lookup(name) ? true : false;
871 }
872
873 uint64_t
874 bridge_get_datapathid(const char *name)
875 {
876     struct bridge *br = bridge_lookup(name);
877     return br ? ofproto_get_datapath_id(br->ofproto) : 0;
878 }
879
880 static int
881 bridge_run_one(struct bridge *br)
882 {
883     int error;
884
885     error = ofproto_run1(br->ofproto);
886     if (error) {
887         return error;
888     }
889
890     if (br->ml) {
891         mac_learning_run(br->ml, ofproto_get_revalidate_set(br->ofproto));
892     }
893     bond_run(br);
894     brstp_run(br);
895
896     error = ofproto_run2(br->ofproto, br->flush);
897     br->flush = false;
898
899     return error;
900 }
901
902 static const char *
903 bridge_get_controller(const struct bridge *br)
904 {
905     const char *controller;
906
907     controller = cfg_get_string(0, "bridge.%s.controller", br->name);
908     if (!controller) {
909         controller = cfg_get_string(0, "mgmt.controller");
910     }
911     return controller && controller[0] ? controller : NULL;
912 }
913
914 static void
915 bridge_reconfigure_one(struct bridge *br)
916 {
917     struct svec old_ports, new_ports, ifaces;
918     struct svec listeners, old_listeners;
919     struct svec snoops, old_snoops;
920     size_t i, j;
921
922     /* Collect old ports. */
923     svec_init(&old_ports);
924     for (i = 0; i < br->n_ports; i++) {
925         svec_add(&old_ports, br->ports[i]->name);
926     }
927     svec_sort(&old_ports);
928     assert(svec_is_unique(&old_ports));
929
930     /* Collect new ports. */
931     svec_init(&new_ports);
932     cfg_get_all_keys(&new_ports, "bridge.%s.port", br->name);
933     svec_sort(&new_ports);
934     if (bridge_get_controller(br)) {
935         char local_name[IF_NAMESIZE];
936         int error;
937
938         error = dpif_port_get_name(br->dpif, ODPP_LOCAL,
939                                    local_name, sizeof local_name);
940         if (!error && !svec_contains(&new_ports, local_name)) {
941             svec_add(&new_ports, local_name);
942             svec_sort(&new_ports);
943         }
944     }
945     if (!svec_is_unique(&new_ports)) {
946         VLOG_WARN("bridge %s: %s specified twice as bridge port",
947                   br->name, svec_get_duplicate(&new_ports));
948         svec_unique(&new_ports);
949     }
950
951     ofproto_set_mgmt_id(br->ofproto, mgmt_id);
952
953     /* Get rid of deleted ports and add new ports. */
954     for (i = 0; i < br->n_ports; ) {
955         struct port *port = br->ports[i];
956         if (!svec_contains(&new_ports, port->name)) {
957             port_destroy(port);
958         } else {
959             i++;
960         }
961     }
962     for (i = 0; i < new_ports.n; i++) {
963         const char *name = new_ports.names[i];
964         if (!svec_contains(&old_ports, name)) {
965             port_create(br, name);
966         }
967     }
968     svec_destroy(&old_ports);
969     svec_destroy(&new_ports);
970
971     /* Reconfigure all ports. */
972     for (i = 0; i < br->n_ports; i++) {
973         port_reconfigure(br->ports[i]);
974     }
975
976     /* Check and delete duplicate interfaces. */
977     svec_init(&ifaces);
978     for (i = 0; i < br->n_ports; ) {
979         struct port *port = br->ports[i];
980         for (j = 0; j < port->n_ifaces; ) {
981             struct iface *iface = port->ifaces[j];
982             if (svec_contains(&ifaces, iface->name)) {
983                 VLOG_ERR("bridge %s: %s interface is on multiple ports, "
984                          "removing from %s",
985                          br->name, iface->name, port->name);
986                 iface_destroy(iface);
987             } else {
988                 svec_add(&ifaces, iface->name);
989                 svec_sort(&ifaces);
990                 j++;
991             }
992         }
993         if (!port->n_ifaces) {
994             VLOG_ERR("%s port has no interfaces, dropping", port->name);
995             port_destroy(port);
996         } else {
997             i++;
998         }
999     }
1000     svec_destroy(&ifaces);
1001
1002     /* Delete all flows if we're switching from connected to standalone or vice
1003      * versa.  (XXX Should we delete all flows if we are switching from one
1004      * controller to another?) */
1005
1006     /* Configure OpenFlow management listeners. */
1007     svec_init(&listeners);
1008     cfg_get_all_strings(&listeners, "bridge.%s.openflow.listeners", br->name);
1009     if (!listeners.n) {
1010         svec_add_nocopy(&listeners, xasprintf("punix:%s/%s.mgmt",
1011                                               ovs_rundir, br->name));
1012     } else if (listeners.n == 1 && !strcmp(listeners.names[0], "none")) {
1013         svec_clear(&listeners);
1014     }
1015     svec_sort_unique(&listeners);
1016
1017     svec_init(&old_listeners);
1018     ofproto_get_listeners(br->ofproto, &old_listeners);
1019     svec_sort_unique(&old_listeners);
1020
1021     if (!svec_equal(&listeners, &old_listeners)) {
1022         ofproto_set_listeners(br->ofproto, &listeners);
1023     }
1024     svec_destroy(&listeners);
1025     svec_destroy(&old_listeners);
1026
1027     /* Configure OpenFlow controller connection snooping. */
1028     svec_init(&snoops);
1029     cfg_get_all_strings(&snoops, "bridge.%s.openflow.snoops", br->name);
1030     if (!snoops.n) {
1031         svec_add_nocopy(&snoops, xasprintf("punix:%s/%s.snoop",
1032                                            ovs_rundir, br->name));
1033     } else if (snoops.n == 1 && !strcmp(snoops.names[0], "none")) {
1034         svec_clear(&snoops);
1035     }
1036     svec_sort_unique(&snoops);
1037
1038     svec_init(&old_snoops);
1039     ofproto_get_snoops(br->ofproto, &old_snoops);
1040     svec_sort_unique(&old_snoops);
1041
1042     if (!svec_equal(&snoops, &old_snoops)) {
1043         ofproto_set_snoops(br->ofproto, &snoops);
1044     }
1045     svec_destroy(&snoops);
1046     svec_destroy(&old_snoops);
1047
1048     mirror_reconfigure(br);
1049 }
1050
1051 static void
1052 bridge_reconfigure_controller(struct bridge *br)
1053 {
1054     char *pfx = xasprintf("bridge.%s.controller", br->name);
1055     const char *controller;
1056
1057     controller = bridge_get_controller(br);
1058     if ((br->controller != NULL) != (controller != NULL)) {
1059         ofproto_flush_flows(br->ofproto);
1060     }
1061     free(br->controller);
1062     br->controller = controller ? xstrdup(controller) : NULL;
1063
1064     if (controller) {
1065         const char *fail_mode;
1066         int max_backoff, probe;
1067         int rate_limit, burst_limit;
1068
1069         if (!strcmp(controller, "discover")) {
1070             ofproto_set_discovery(br->ofproto, true,
1071                                   cfg_get_string(0, "%s.accept-regex", pfx),
1072                                   cfg_get_bool(0, "%s.update-resolv.conf",
1073                                                pfx));
1074         } else {
1075             char local_name[IF_NAMESIZE];
1076             struct netdev *netdev;
1077             bool in_band;
1078             int error;
1079
1080             in_band = (!cfg_is_valid(CFG_BOOL | CFG_REQUIRED,
1081                                      "%s.in-band", pfx)
1082                        || cfg_get_bool(0, "%s.in-band", pfx));
1083             ofproto_set_discovery(br->ofproto, false, NULL, NULL);
1084             ofproto_set_in_band(br->ofproto, in_band);
1085
1086             error = dpif_port_get_name(br->dpif, ODPP_LOCAL,
1087                                        local_name, sizeof local_name);
1088             if (!error) {
1089                 error = netdev_open(local_name, NETDEV_ETH_TYPE_NONE, &netdev);
1090             }
1091             if (!error) {
1092                 if (cfg_is_valid(CFG_IP | CFG_REQUIRED, "%s.ip", pfx)) {
1093                     struct in_addr ip, mask, gateway;
1094                     ip.s_addr = cfg_get_ip(0, "%s.ip", pfx);
1095                     mask.s_addr = cfg_get_ip(0, "%s.netmask", pfx);
1096                     gateway.s_addr = cfg_get_ip(0, "%s.gateway", pfx);
1097
1098                     netdev_turn_flags_on(netdev, NETDEV_UP, true);
1099                     if (!mask.s_addr) {
1100                         mask.s_addr = guess_netmask(ip.s_addr);
1101                     }
1102                     if (!netdev_set_in4(netdev, ip, mask)) {
1103                         VLOG_INFO("bridge %s: configured IP address "IP_FMT", "
1104                                   "netmask "IP_FMT,
1105                                   br->name, IP_ARGS(&ip.s_addr),
1106                                   IP_ARGS(&mask.s_addr));
1107                     }
1108
1109                     if (gateway.s_addr) {
1110                         if (!netdev_add_router(gateway)) {
1111                             VLOG_INFO("bridge %s: configured gateway "IP_FMT,
1112                                       br->name, IP_ARGS(&gateway.s_addr));
1113                         }
1114                     }
1115                 }
1116                 netdev_close(netdev);
1117             }
1118         }
1119
1120         fail_mode = cfg_get_string(0, "%s.fail-mode", pfx);
1121         if (!fail_mode) {
1122             fail_mode = cfg_get_string(0, "mgmt.fail-mode");
1123         }
1124         ofproto_set_failure(br->ofproto,
1125                             (!fail_mode
1126                              || !strcmp(fail_mode, "standalone")
1127                              || !strcmp(fail_mode, "open")));
1128
1129         probe = cfg_get_int(0, "%s.inactivity-probe", pfx);
1130         if (probe < 5) {
1131             probe = cfg_get_int(0, "mgmt.inactivity-probe");
1132             if (probe < 5) {
1133                 probe = 15;
1134             }
1135         }
1136         ofproto_set_probe_interval(br->ofproto, probe);
1137
1138         max_backoff = cfg_get_int(0, "%s.max-backoff", pfx);
1139         if (!max_backoff) {
1140             max_backoff = cfg_get_int(0, "mgmt.max-backoff");
1141             if (!max_backoff) {
1142                 max_backoff = 15;
1143             }
1144         }
1145         ofproto_set_max_backoff(br->ofproto, max_backoff);
1146
1147         rate_limit = cfg_get_int(0, "%s.rate-limit", pfx);
1148         if (!rate_limit) {
1149             rate_limit = cfg_get_int(0, "mgmt.rate-limit");
1150         }
1151         burst_limit = cfg_get_int(0, "%s.burst-limit", pfx);
1152         if (!burst_limit) {
1153             burst_limit = cfg_get_int(0, "mgmt.burst-limit");
1154         }
1155         ofproto_set_rate_limit(br->ofproto, rate_limit, burst_limit);
1156
1157         ofproto_set_stp(br->ofproto, cfg_get_bool(0, "%s.stp", pfx));
1158
1159         if (cfg_has("%s.commands.acl", pfx)) {
1160             struct svec command_acls;
1161             char *command_acl;
1162
1163             svec_init(&command_acls);
1164             cfg_get_all_strings(&command_acls, "%s.commands.acl", pfx);
1165             command_acl = svec_join(&command_acls, ",", "");
1166
1167             ofproto_set_remote_execution(br->ofproto, command_acl,
1168                                          cfg_get_string(0, "%s.commands.dir",
1169                                                         pfx));
1170
1171             svec_destroy(&command_acls);
1172             free(command_acl);
1173         } else {
1174             ofproto_set_remote_execution(br->ofproto, NULL, NULL);
1175         }
1176     } else {
1177         union ofp_action action;
1178         flow_t flow;
1179
1180         /* Set up a flow that matches every packet and directs them to
1181          * OFPP_NORMAL (which goes to us). */
1182         memset(&action, 0, sizeof action);
1183         action.type = htons(OFPAT_OUTPUT);
1184         action.output.len = htons(sizeof action);
1185         action.output.port = htons(OFPP_NORMAL);
1186         memset(&flow, 0, sizeof flow);
1187         ofproto_add_flow(br->ofproto, &flow, OFPFW_ALL, 0,
1188                          &action, 1, 0);
1189
1190         ofproto_set_in_band(br->ofproto, false);
1191         ofproto_set_max_backoff(br->ofproto, 1);
1192         ofproto_set_probe_interval(br->ofproto, 5);
1193         ofproto_set_failure(br->ofproto, false);
1194         ofproto_set_stp(br->ofproto, false);
1195     }
1196     free(pfx);
1197
1198     ofproto_set_controller(br->ofproto, br->controller);
1199 }
1200
1201 static void
1202 bridge_get_all_ifaces(const struct bridge *br, struct svec *ifaces)
1203 {
1204     size_t i, j;
1205
1206     svec_init(ifaces);
1207     for (i = 0; i < br->n_ports; i++) {
1208         struct port *port = br->ports[i];
1209         for (j = 0; j < port->n_ifaces; j++) {
1210             struct iface *iface = port->ifaces[j];
1211             svec_add(ifaces, iface->name);
1212         }
1213     }
1214     svec_sort(ifaces);
1215     assert(svec_is_unique(ifaces));
1216 }
1217
1218 /* For robustness, in case the administrator moves around datapath ports behind
1219  * our back, we re-check all the datapath port numbers here.
1220  *
1221  * This function will set the 'dp_ifidx' members of interfaces that have
1222  * disappeared to -1, so only call this function from a context where those
1223  * 'struct iface's will be removed from the bridge.  Otherwise, the -1
1224  * 'dp_ifidx'es will cause trouble later when we try to send them to the
1225  * datapath, which doesn't support UINT16_MAX+1 ports. */
1226 static void
1227 bridge_fetch_dp_ifaces(struct bridge *br)
1228 {
1229     struct odp_port *dpif_ports;
1230     size_t n_dpif_ports;
1231     size_t i, j;
1232
1233     /* Reset all interface numbers. */
1234     for (i = 0; i < br->n_ports; i++) {
1235         struct port *port = br->ports[i];
1236         for (j = 0; j < port->n_ifaces; j++) {
1237             struct iface *iface = port->ifaces[j];
1238             iface->dp_ifidx = -1;
1239         }
1240     }
1241     port_array_clear(&br->ifaces);
1242
1243     dpif_port_list(br->dpif, &dpif_ports, &n_dpif_ports);
1244     for (i = 0; i < n_dpif_ports; i++) {
1245         struct odp_port *p = &dpif_ports[i];
1246         struct iface *iface = iface_lookup(br, p->devname);
1247         if (iface) {
1248             if (iface->dp_ifidx >= 0) {
1249                 VLOG_WARN("%s reported interface %s twice",
1250                           dpif_name(br->dpif), p->devname);
1251             } else if (iface_from_dp_ifidx(br, p->port)) {
1252                 VLOG_WARN("%s reported interface %"PRIu16" twice",
1253                           dpif_name(br->dpif), p->port);
1254             } else {
1255                 port_array_set(&br->ifaces, p->port, iface);
1256                 iface->dp_ifidx = p->port;
1257             }
1258         }
1259     }
1260     free(dpif_ports);
1261 }
1262 \f
1263 /* Bridge packet processing functions. */
1264
1265 static int
1266 bond_hash(const uint8_t mac[ETH_ADDR_LEN])
1267 {
1268     return hash_bytes(mac, ETH_ADDR_LEN, 0) & BOND_MASK;
1269 }
1270
1271 static struct bond_entry *
1272 lookup_bond_entry(const struct port *port, const uint8_t mac[ETH_ADDR_LEN])
1273 {
1274     return &port->bond_hash[bond_hash(mac)];
1275 }
1276
1277 static int
1278 bond_choose_iface(const struct port *port)
1279 {
1280     size_t i;
1281     for (i = 0; i < port->n_ifaces; i++) {
1282         if (port->ifaces[i]->enabled) {
1283             return i;
1284         }
1285     }
1286     return -1;
1287 }
1288
1289 static bool
1290 choose_output_iface(const struct port *port, const uint8_t *dl_src,
1291                     uint16_t *dp_ifidx, tag_type *tags)
1292 {
1293     struct iface *iface;
1294
1295     assert(port->n_ifaces);
1296     if (port->n_ifaces == 1) {
1297         iface = port->ifaces[0];
1298     } else {
1299         struct bond_entry *e = lookup_bond_entry(port, dl_src);
1300         if (e->iface_idx < 0 || e->iface_idx >= port->n_ifaces
1301             || !port->ifaces[e->iface_idx]->enabled) {
1302             /* XXX select interface properly.  The current interface selection
1303              * is only good for testing the rebalancing code. */
1304             e->iface_idx = bond_choose_iface(port);
1305             if (e->iface_idx < 0) {
1306                 *tags |= port->no_ifaces_tag;
1307                 return false;
1308             }
1309             e->iface_tag = tag_create_random();
1310         }
1311         *tags |= e->iface_tag;
1312         iface = port->ifaces[e->iface_idx];
1313     }
1314     *dp_ifidx = iface->dp_ifidx;
1315     *tags |= iface->tag;        /* Currently only used for bonding. */
1316     return true;
1317 }
1318
1319 static void
1320 bond_link_status_update(struct iface *iface, bool carrier)
1321 {
1322     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1323     struct port *port = iface->port;
1324
1325     if ((carrier == iface->enabled) == (iface->delay_expires == LLONG_MAX)) {
1326         /* Nothing to do. */
1327         return;
1328     }
1329     VLOG_INFO_RL(&rl, "interface %s: carrier %s",
1330                  iface->name, carrier ? "detected" : "dropped");
1331     if (carrier == iface->enabled) {
1332         iface->delay_expires = LLONG_MAX;
1333         VLOG_INFO_RL(&rl, "interface %s: will not be %s",
1334                      iface->name, carrier ? "disabled" : "enabled");
1335     } else {
1336         int delay = carrier ? port->updelay : port->downdelay;
1337         iface->delay_expires = time_msec() + delay;
1338         if (delay) {
1339             VLOG_INFO_RL(&rl,
1340                          "interface %s: will be %s if it stays %s for %d ms",
1341                          iface->name,
1342                          carrier ? "enabled" : "disabled",
1343                          carrier ? "up" : "down",
1344                          delay);
1345         }
1346     }
1347 }
1348
1349 static void
1350 bond_choose_active_iface(struct port *port)
1351 {
1352     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1353
1354     port->active_iface = bond_choose_iface(port);
1355     port->active_iface_tag = tag_create_random();
1356     if (port->active_iface >= 0) {
1357         VLOG_INFO_RL(&rl, "port %s: active interface is now %s",
1358                      port->name, port->ifaces[port->active_iface]->name);
1359     } else {
1360         VLOG_WARN_RL(&rl, "port %s: all ports disabled, no active interface",
1361                      port->name);
1362     }
1363 }
1364
1365 static void
1366 bond_enable_slave(struct iface *iface, bool enable)
1367 {
1368     struct port *port = iface->port;
1369     struct bridge *br = port->bridge;
1370
1371     iface->delay_expires = LLONG_MAX;
1372     if (enable == iface->enabled) {
1373         return;
1374     }
1375
1376     iface->enabled = enable;
1377     if (!iface->enabled) {
1378         VLOG_WARN("interface %s: enabled", iface->name);
1379         ofproto_revalidate(br->ofproto, iface->tag);
1380         if (iface->port_ifidx == port->active_iface) {
1381             ofproto_revalidate(br->ofproto,
1382                                port->active_iface_tag);
1383             bond_choose_active_iface(port);
1384         }
1385         bond_send_learning_packets(port);
1386     } else {
1387         VLOG_WARN("interface %s: disabled", iface->name);
1388         if (port->active_iface < 0) {
1389             ofproto_revalidate(br->ofproto, port->no_ifaces_tag);
1390             bond_choose_active_iface(port);
1391             bond_send_learning_packets(port);
1392         }
1393         iface->tag = tag_create_random();
1394     }
1395 }
1396
1397 static void
1398 bond_run(struct bridge *br)
1399 {
1400     size_t i, j;
1401
1402     for (i = 0; i < br->n_ports; i++) {
1403         struct port *port = br->ports[i];
1404         if (port->n_ifaces < 2) {
1405             continue;
1406         }
1407         for (j = 0; j < port->n_ifaces; j++) {
1408             struct iface *iface = port->ifaces[j];
1409             if (time_msec() >= iface->delay_expires) {
1410                 bond_enable_slave(iface, !iface->enabled);
1411             }
1412         }
1413     }
1414 }
1415
1416 static void
1417 bond_wait(struct bridge *br)
1418 {
1419     size_t i, j;
1420
1421     for (i = 0; i < br->n_ports; i++) {
1422         struct port *port = br->ports[i];
1423         if (port->n_ifaces < 2) {
1424             continue;
1425         }
1426         for (j = 0; j < port->n_ifaces; j++) {
1427             struct iface *iface = port->ifaces[j];
1428             if (iface->delay_expires != LLONG_MAX) {
1429                 poll_timer_wait(iface->delay_expires - time_msec());
1430             }
1431         }
1432     }
1433 }
1434
1435 static bool
1436 set_dst(struct dst *p, const flow_t *flow,
1437         const struct port *in_port, const struct port *out_port,
1438         tag_type *tags)
1439 {
1440     /* STP handling.
1441      *
1442      * XXX This uses too many tags: any broadcast flow will get one tag per
1443      * destination port, and thus a broadcast on a switch of any size is likely
1444      * to have all tag bits set.  We should figure out a way to be smarter.
1445      *
1446      * This is OK when STP is disabled, because stp_state_tag is 0 then. */
1447     *tags |= out_port->stp_state_tag;
1448     if (!(out_port->stp_state & (STP_DISABLED | STP_FORWARDING))) {
1449         return false;
1450     }
1451
1452     p->vlan = (out_port->vlan >= 0 ? OFP_VLAN_NONE
1453               : in_port->vlan >= 0 ? in_port->vlan
1454               : ntohs(flow->dl_vlan));
1455     return choose_output_iface(out_port, flow->dl_src, &p->dp_ifidx, tags);
1456 }
1457
1458 static void
1459 swap_dst(struct dst *p, struct dst *q)
1460 {
1461     struct dst tmp = *p;
1462     *p = *q;
1463     *q = tmp;
1464 }
1465
1466 /* Moves all the dsts with vlan == 'vlan' to the front of the 'n_dsts' in
1467  * 'dsts'.  (This may help performance by reducing the number of VLAN changes
1468  * that we push to the datapath.  We could in fact fully sort the array by
1469  * vlan, but in most cases there are at most two different vlan tags so that's
1470  * possibly overkill.) */
1471 static void
1472 partition_dsts(struct dst *dsts, size_t n_dsts, int vlan)
1473 {
1474     struct dst *first = dsts;
1475     struct dst *last = dsts + n_dsts;
1476
1477     while (first != last) {
1478         /* Invariants:
1479          *      - All dsts < first have vlan == 'vlan'.
1480          *      - All dsts >= last have vlan != 'vlan'.
1481          *      - first < last. */
1482         while (first->vlan == vlan) {
1483             if (++first == last) {
1484                 return;
1485             }
1486         }
1487
1488         /* Same invariants, plus one additional:
1489          *      - first->vlan != vlan.
1490          */
1491         while (last[-1].vlan != vlan) {
1492             if (--last == first) {
1493                 return;
1494             }
1495         }
1496
1497         /* Same invariants, plus one additional:
1498          *      - last[-1].vlan == vlan.*/
1499         swap_dst(first++, --last);
1500     }
1501 }
1502
1503 static int
1504 mirror_mask_ffs(mirror_mask_t mask)
1505 {
1506     BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
1507     return ffs(mask);
1508 }
1509
1510 static bool
1511 dst_is_duplicate(const struct dst *dsts, size_t n_dsts,
1512                  const struct dst *test)
1513 {
1514     size_t i;
1515     for (i = 0; i < n_dsts; i++) {
1516         if (dsts[i].vlan == test->vlan && dsts[i].dp_ifidx == test->dp_ifidx) {
1517             return true;
1518         }
1519     }
1520     return false;
1521 }
1522
1523 static bool
1524 port_trunks_vlan(const struct port *port, uint16_t vlan)
1525 {
1526     return port->vlan < 0 && bitmap_is_set(port->trunks, vlan);
1527 }
1528
1529 static bool
1530 port_includes_vlan(const struct port *port, uint16_t vlan)
1531 {
1532     return vlan == port->vlan || port_trunks_vlan(port, vlan);
1533 }
1534
1535 static size_t
1536 compose_dsts(const struct bridge *br, const flow_t *flow, uint16_t vlan,
1537              const struct port *in_port, const struct port *out_port,
1538              struct dst dsts[], tag_type *tags)
1539 {
1540     mirror_mask_t mirrors = in_port->src_mirrors;
1541     struct dst *dst = dsts;
1542     size_t i;
1543
1544     *tags |= in_port->stp_state_tag;
1545     if (out_port == FLOOD_PORT) {
1546         /* XXX use ODP_FLOOD if no vlans or bonding. */
1547         /* XXX even better, define each VLAN as a datapath port group */
1548         for (i = 0; i < br->n_ports; i++) {
1549             struct port *port = br->ports[i];
1550             if (port != in_port && port_includes_vlan(port, vlan)
1551                 && !port->is_mirror_output_port
1552                 && set_dst(dst, flow, in_port, port, tags)) {
1553                 mirrors |= port->dst_mirrors;
1554                 dst++;
1555             }
1556         }
1557     } else if (out_port && set_dst(dst, flow, in_port, out_port, tags)) {
1558         mirrors |= out_port->dst_mirrors;
1559         dst++;
1560     }
1561
1562     while (mirrors) {
1563         struct mirror *m = br->mirrors[mirror_mask_ffs(mirrors) - 1];
1564         if (!m->n_vlans || vlan_is_mirrored(m, vlan)) {
1565             if (m->out_port) {
1566                 if (set_dst(dst, flow, in_port, m->out_port, tags)
1567                     && !dst_is_duplicate(dsts, dst - dsts, dst)) {
1568                     dst++;
1569                 }
1570             } else {
1571                 for (i = 0; i < br->n_ports; i++) {
1572                     struct port *port = br->ports[i];
1573                     if (port_includes_vlan(port, m->out_vlan)
1574                         && set_dst(dst, flow, in_port, port, tags)
1575                         && !dst_is_duplicate(dsts, dst - dsts, dst))
1576                     {
1577                         if (port->vlan < 0) {
1578                             dst->vlan = m->out_vlan;
1579                         }
1580                         if (dst->dp_ifidx == flow->in_port
1581                             && dst->vlan == vlan) {
1582                             /* Don't send out input port on same VLAN. */
1583                             continue;
1584                         }
1585                         dst++;
1586                     }
1587                 }
1588             }
1589         }
1590         mirrors &= mirrors - 1;
1591     }
1592
1593     partition_dsts(dsts, dst - dsts, ntohs(flow->dl_vlan));
1594     return dst - dsts;
1595 }
1596
1597 static void UNUSED
1598 print_dsts(const struct dst *dsts, size_t n)
1599 {
1600     for (; n--; dsts++) {
1601         printf(">p%"PRIu16, dsts->dp_ifidx);
1602         if (dsts->vlan != OFP_VLAN_NONE) {
1603             printf("v%"PRIu16, dsts->vlan);
1604         }
1605     }
1606 }
1607
1608 static void
1609 compose_actions(struct bridge *br, const flow_t *flow, uint16_t vlan,
1610                 const struct port *in_port, const struct port *out_port,
1611                 tag_type *tags, struct odp_actions *actions)
1612 {
1613     struct dst dsts[DP_MAX_PORTS * (MAX_MIRRORS + 1)];
1614     size_t n_dsts;
1615     const struct dst *p;
1616     uint16_t cur_vlan;
1617
1618     n_dsts = compose_dsts(br, flow, vlan, in_port, out_port, dsts, tags);
1619
1620     cur_vlan = ntohs(flow->dl_vlan);
1621     for (p = dsts; p < &dsts[n_dsts]; p++) {
1622         union odp_action *a;
1623         if (p->vlan != cur_vlan) {
1624             if (p->vlan == OFP_VLAN_NONE) {
1625                 odp_actions_add(actions, ODPAT_STRIP_VLAN);
1626             } else {
1627                 a = odp_actions_add(actions, ODPAT_SET_VLAN_VID);
1628                 a->vlan_vid.vlan_vid = htons(p->vlan);
1629             }
1630             cur_vlan = p->vlan;
1631         }
1632         a = odp_actions_add(actions, ODPAT_OUTPUT);
1633         a->output.port = p->dp_ifidx;
1634     }
1635 }
1636
1637 static bool
1638 is_bcast_arp_reply(const flow_t *flow, const struct ofpbuf *packet)
1639 {
1640     struct arp_eth_header *arp = (struct arp_eth_header *) packet->data;
1641     return (flow->dl_type == htons(ETH_TYPE_ARP)
1642             && eth_addr_is_broadcast(flow->dl_dst)
1643             && packet->size >= sizeof(struct arp_eth_header)
1644             && arp->ar_op == ARP_OP_REQUEST);
1645 }
1646
1647 /* If the composed actions may be applied to any packet in the given 'flow',
1648  * returns true.  Otherwise, the actions should only be applied to 'packet', or
1649  * not at all, if 'packet' was NULL. */
1650 static bool
1651 process_flow(struct bridge *br, const flow_t *flow,
1652              const struct ofpbuf *packet, struct odp_actions *actions,
1653              tag_type *tags)
1654 {
1655     struct iface *in_iface;
1656     struct port *in_port;
1657     struct port *out_port = NULL; /* By default, drop the packet/flow. */
1658     int vlan;
1659
1660     /* Find the interface and port structure for the received packet. */
1661     in_iface = iface_from_dp_ifidx(br, flow->in_port);
1662     if (!in_iface) {
1663         /* No interface?  Something fishy... */
1664         if (packet != NULL) {
1665             /* Odd.  A few possible reasons here:
1666              *
1667              * - We deleted an interface but there are still a few packets
1668              *   queued up from it.
1669              *
1670              * - Someone externally added an interface (e.g. with "ovs-dpctl
1671              *   add-if") that we don't know about.
1672              *
1673              * - Packet arrived on the local port but the local port is not
1674              *   one of our bridge ports.
1675              */
1676             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1677
1678             VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
1679                          "interface %"PRIu16, br->name, flow->in_port); 
1680         }
1681
1682         /* Return without adding any actions, to drop packets on this flow. */
1683         return true;
1684     }
1685     in_port = in_iface->port;
1686
1687     /* Figure out what VLAN this packet belongs to.
1688      *
1689      * Note that dl_vlan of 0 and of OFP_VLAN_NONE both mean that the packet
1690      * belongs to VLAN 0, so we should treat both cases identically.  (In the
1691      * former case, the packet has an 802.1Q header that specifies VLAN 0,
1692      * presumably to allow a priority to be specified.  In the latter case, the
1693      * packet does not have any 802.1Q header.) */
1694     vlan = ntohs(flow->dl_vlan);
1695     if (vlan == OFP_VLAN_NONE) {
1696         vlan = 0;
1697     }
1698     if (in_port->vlan >= 0) {
1699         if (vlan) {
1700             /* XXX support double tagging? */
1701             if (packet != NULL) {
1702                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1703                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %"PRIu16" tagged "
1704                              "packet received on port %s configured with "
1705                              "implicit VLAN %"PRIu16,
1706                              br->name, ntohs(flow->dl_vlan),
1707                              in_port->name, in_port->vlan);
1708             }
1709             goto done;
1710         }
1711         vlan = in_port->vlan;
1712     } else {
1713         if (!port_includes_vlan(in_port, vlan)) {
1714             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1715             VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
1716                          "packet received on port %s not configured for "
1717                          "trunking VLAN %d",
1718                          br->name, vlan, in_port->name, vlan);
1719             goto done;
1720         }
1721     }
1722
1723     /* Drop frames for ports that STP wants entirely killed (both for
1724      * forwarding and for learning).  Later, after we do learning, we'll drop
1725      * the frames that STP wants to do learning but not forwarding on. */
1726     if (in_port->stp_state & (STP_LISTENING | STP_BLOCKING)) {
1727         goto done;
1728     }
1729
1730     /* Drop frames for reserved multicast addresses. */
1731     if (eth_addr_is_reserved(flow->dl_dst)) {
1732         goto done;
1733     }
1734
1735     /* Drop frames on ports reserved for mirroring. */
1736     if (in_port->is_mirror_output_port) {
1737         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1738         VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port %s, "
1739                      "which is reserved exclusively for mirroring",
1740                      br->name, in_port->name);
1741         goto done;
1742     }
1743
1744     /* Multicast (and broadcast) packets on bonds need special attention, to
1745      * avoid receiving duplicates. */
1746     if (in_port->n_ifaces > 1 && eth_addr_is_multicast(flow->dl_dst)) {
1747         *tags |= in_port->active_iface_tag;
1748         if (in_port->active_iface != in_iface->port_ifidx) {
1749             /* Drop all multicast packets on inactive slaves. */
1750             goto done;
1751         } else {
1752             /* Drop all multicast packets for which we have learned a different
1753              * input port, because we probably sent the packet on one slaves
1754              * and got it back on the active slave.  Broadcast ARP replies are
1755              * an exception to this rule: the host has moved to another
1756              * switch. */
1757             int src_idx = mac_learning_lookup(br->ml, flow->dl_src, vlan);
1758             if (src_idx != -1 && src_idx != in_port->port_idx) {
1759                 if (packet) {
1760                     if (!is_bcast_arp_reply(flow, packet)) {
1761                         goto done;
1762                     }
1763                 } else {
1764                     /* No way to know whether it's an ARP reply, because the
1765                      * flow entry doesn't include enough information and we
1766                      * don't have a packet.  Punt. */
1767                     return false;
1768                 }
1769             }
1770         }
1771     }
1772
1773     /* MAC learning. */
1774     out_port = FLOOD_PORT;
1775     if (br->ml) {
1776         int out_port_idx;
1777
1778         /* Learn source MAC (but don't try to learn from revalidation). */
1779         if (packet) {
1780             tag_type rev_tag = mac_learning_learn(br->ml, flow->dl_src,
1781                                                   vlan, in_port->port_idx);
1782             if (rev_tag) {
1783                 /* The log messages here could actually be useful in debugging,
1784                  * so keep the rate limit relatively high. */
1785                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30,
1786                                                                         300);
1787                 VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
1788                             "on port %s in VLAN %d",
1789                             br->name, ETH_ADDR_ARGS(flow->dl_src),
1790                             in_port->name, vlan);
1791                 ofproto_revalidate(br->ofproto, rev_tag);
1792             }
1793         }
1794
1795         /* Determine output port. */
1796         out_port_idx = mac_learning_lookup_tag(br->ml, flow->dl_dst, vlan,
1797                                                tags);
1798         if (out_port_idx >= 0 && out_port_idx < br->n_ports) {
1799             out_port = br->ports[out_port_idx];
1800         }
1801     }
1802
1803     /* Don't send packets out their input ports.  Don't forward frames that STP
1804      * wants us to discard. */
1805     if (in_port == out_port || in_port->stp_state == STP_LEARNING) {
1806         out_port = NULL;
1807     }
1808
1809 done:
1810     compose_actions(br, flow, vlan, in_port, out_port, tags, actions);
1811
1812     /*
1813      * We send out only a single packet, instead of setting up a flow, if the
1814      * packet is an ARP directed to broadcast that arrived on a bonded
1815      * interface.  In such a situation ARP requests and replies must be handled
1816      * differently, but OpenFlow unfortunately can't distinguish them.
1817      */
1818     return (in_port->n_ifaces < 2
1819             || flow->dl_type != htons(ETH_TYPE_ARP)
1820             || !eth_addr_is_broadcast(flow->dl_dst));
1821 }
1822
1823 /* Careful: 'opp' is in host byte order and opp->port_no is an OFP port
1824  * number. */
1825 static void
1826 bridge_port_changed_ofhook_cb(enum ofp_port_reason reason,
1827                               const struct ofp_phy_port *opp,
1828                               void *br_)
1829 {
1830     struct bridge *br = br_;
1831     struct iface *iface;
1832     struct port *port;
1833
1834     iface = iface_from_dp_ifidx(br, ofp_port_to_odp_port(opp->port_no));
1835     if (!iface) {
1836         return;
1837     }
1838     port = iface->port;
1839
1840     if (reason == OFPPR_DELETE) {
1841         VLOG_WARN("bridge %s: interface %s deleted unexpectedly",
1842                   br->name, iface->name);
1843         iface_destroy(iface);
1844         if (!port->n_ifaces) {
1845             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
1846                       br->name, port->name);
1847             port_destroy(port);
1848         }
1849
1850         bridge_flush(br);
1851     } else {
1852         memcpy(iface->mac, opp->hw_addr, ETH_ADDR_LEN);
1853         if (port->n_ifaces > 1) {
1854             bool up = !(opp->state & OFPPS_LINK_DOWN);
1855             bond_link_status_update(iface, up);
1856             port_update_bond_compat(port);
1857         }
1858     }
1859 }
1860
1861 static bool
1862 bridge_normal_ofhook_cb(const flow_t *flow, const struct ofpbuf *packet,
1863                         struct odp_actions *actions, tag_type *tags, void *br_)
1864 {
1865     struct bridge *br = br_;
1866
1867 #if 0
1868     if (flow->dl_type == htons(OFP_DL_TYPE_NOT_ETH_TYPE)
1869         && eth_addr_equals(flow->dl_dst, stp_eth_addr)) {
1870         brstp_receive(br, flow, payload);
1871         return true;
1872     }
1873 #endif
1874
1875     COVERAGE_INC(bridge_process_flow);
1876     return process_flow(br, flow, packet, actions, tags);
1877 }
1878
1879 static void
1880 bridge_account_flow_ofhook_cb(const flow_t *flow,
1881                               const union odp_action *actions,
1882                               size_t n_actions, unsigned long long int n_bytes,
1883                               void *br_)
1884 {
1885     struct bridge *br = br_;
1886     const union odp_action *a;
1887
1888     if (!br->has_bonded_ports) {
1889         return;
1890     }
1891
1892     for (a = actions; a < &actions[n_actions]; a++) {
1893         if (a->type == ODPAT_OUTPUT) {
1894             struct port *port = port_from_dp_ifidx(br, a->output.port);
1895             if (port && port->n_ifaces >= 2) {
1896                 struct bond_entry *e = lookup_bond_entry(port, flow->dl_src);
1897                 e->tx_bytes += n_bytes;
1898             }
1899         }
1900     }
1901 }
1902
1903 static void
1904 bridge_account_checkpoint_ofhook_cb(void *br_)
1905 {
1906     struct bridge *br = br_;
1907     size_t i;
1908
1909     if (!br->has_bonded_ports) {
1910         return;
1911     }
1912
1913     /* The current ofproto implementation calls this callback at least once a
1914      * second, so this timer implementation is sufficient. */
1915     if (time_msec() < br->bond_next_rebalance) {
1916         return;
1917     }
1918     br->bond_next_rebalance = time_msec() + 10000;
1919
1920     for (i = 0; i < br->n_ports; i++) {
1921         struct port *port = br->ports[i];
1922         if (port->n_ifaces > 1) {
1923             bond_rebalance_port(port);
1924         }
1925     }
1926 }
1927
1928 static struct ofhooks bridge_ofhooks = {
1929     bridge_port_changed_ofhook_cb,
1930     bridge_normal_ofhook_cb,
1931     bridge_account_flow_ofhook_cb,
1932     bridge_account_checkpoint_ofhook_cb,
1933 };
1934 \f
1935 /* Bonding functions. */
1936
1937 /* Statistics for a single interface on a bonded port, used for load-based
1938  * bond rebalancing.  */
1939 struct slave_balance {
1940     struct iface *iface;        /* The interface. */
1941     uint64_t tx_bytes;          /* Sum of hashes[*]->tx_bytes. */
1942
1943     /* All the "bond_entry"s that are assigned to this interface, in order of
1944      * increasing tx_bytes. */
1945     struct bond_entry **hashes;
1946     size_t n_hashes;
1947 };
1948
1949 /* Sorts pointers to pointers to bond_entries in ascending order by the
1950  * interface to which they are assigned, and within a single interface in
1951  * ascending order of bytes transmitted. */
1952 static int
1953 compare_bond_entries(const void *a_, const void *b_)
1954 {
1955     const struct bond_entry *const *ap = a_;
1956     const struct bond_entry *const *bp = b_;
1957     const struct bond_entry *a = *ap;
1958     const struct bond_entry *b = *bp;
1959     if (a->iface_idx != b->iface_idx) {
1960         return a->iface_idx > b->iface_idx ? 1 : -1;
1961     } else if (a->tx_bytes != b->tx_bytes) {
1962         return a->tx_bytes > b->tx_bytes ? 1 : -1;
1963     } else {
1964         return 0;
1965     }
1966 }
1967
1968 /* Sorts slave_balances so that enabled ports come first, and otherwise in
1969  * *descending* order by number of bytes transmitted. */
1970 static int
1971 compare_slave_balance(const void *a_, const void *b_)
1972 {
1973     const struct slave_balance *a = a_;
1974     const struct slave_balance *b = b_;
1975     if (a->iface->enabled != b->iface->enabled) {
1976         return a->iface->enabled ? -1 : 1;
1977     } else if (a->tx_bytes != b->tx_bytes) {
1978         return a->tx_bytes > b->tx_bytes ? -1 : 1;
1979     } else {
1980         return 0;
1981     }
1982 }
1983
1984 static void
1985 swap_bals(struct slave_balance *a, struct slave_balance *b)
1986 {
1987     struct slave_balance tmp = *a;
1988     *a = *b;
1989     *b = tmp;
1990 }
1991
1992 /* Restores the 'n_bals' slave_balance structures in 'bals' to sorted order
1993  * given that 'p' (and only 'p') might be in the wrong location.
1994  *
1995  * This function invalidates 'p', since it might now be in a different memory
1996  * location. */
1997 static void
1998 resort_bals(struct slave_balance *p,
1999             struct slave_balance bals[], size_t n_bals)
2000 {
2001     if (n_bals > 1) {
2002         for (; p > bals && p->tx_bytes > p[-1].tx_bytes; p--) {
2003             swap_bals(p, p - 1);
2004         }
2005         for (; p < &bals[n_bals - 1] && p->tx_bytes < p[1].tx_bytes; p++) {
2006             swap_bals(p, p + 1);
2007         }
2008     }
2009 }
2010
2011 static void
2012 log_bals(const struct slave_balance *bals, size_t n_bals, struct port *port)
2013 {
2014     if (VLOG_IS_DBG_ENABLED()) {
2015         struct ds ds = DS_EMPTY_INITIALIZER;
2016         const struct slave_balance *b;
2017
2018         for (b = bals; b < bals + n_bals; b++) {
2019             size_t i;
2020
2021             if (b > bals) {
2022                 ds_put_char(&ds, ',');
2023             }
2024             ds_put_format(&ds, " %s %"PRIu64"kB",
2025                           b->iface->name, b->tx_bytes / 1024);
2026
2027             if (!b->iface->enabled) {
2028                 ds_put_cstr(&ds, " (disabled)");
2029             }
2030             if (b->n_hashes > 0) {
2031                 ds_put_cstr(&ds, " (");
2032                 for (i = 0; i < b->n_hashes; i++) {
2033                     const struct bond_entry *e = b->hashes[i];
2034                     if (i > 0) {
2035                         ds_put_cstr(&ds, " + ");
2036                     }
2037                     ds_put_format(&ds, "h%td: %"PRIu64"kB",
2038                                   e - port->bond_hash, e->tx_bytes / 1024);
2039                 }
2040                 ds_put_cstr(&ds, ")");
2041             }
2042         }
2043         VLOG_DBG("bond %s:%s", port->name, ds_cstr(&ds));
2044         ds_destroy(&ds);
2045     }
2046 }
2047
2048 /* Shifts 'hash' from 'from' to 'to' within 'port'. */
2049 static void
2050 bond_shift_load(struct slave_balance *from, struct slave_balance *to,
2051                 struct bond_entry *hash)
2052 {
2053     struct port *port = from->iface->port;
2054     uint64_t delta = hash->tx_bytes;
2055
2056     VLOG_INFO("bond %s: shift %"PRIu64"kB of load (with hash %td) "
2057               "from %s to %s (now carrying %"PRIu64"kB and "
2058               "%"PRIu64"kB load, respectively)",
2059               port->name, delta / 1024, hash - port->bond_hash,
2060               from->iface->name, to->iface->name,
2061               (from->tx_bytes - delta) / 1024,
2062               (to->tx_bytes + delta) / 1024);
2063
2064     /* Delete element from from->hashes.
2065      *
2066      * We don't bother to add the element to to->hashes because not only would
2067      * it require more work, the only purpose it would be to allow that hash to
2068      * be migrated to another slave in this rebalancing run, and there is no
2069      * point in doing that.  */
2070     if (from->hashes[0] == hash) {
2071         from->hashes++;
2072     } else {
2073         int i = hash - from->hashes[0];
2074         memmove(from->hashes + i, from->hashes + i + 1,
2075                 (from->n_hashes - (i + 1)) * sizeof *from->hashes);
2076     }
2077     from->n_hashes--;
2078
2079     /* Shift load away from 'from' to 'to'. */
2080     from->tx_bytes -= delta;
2081     to->tx_bytes += delta;
2082
2083     /* Arrange for flows to be revalidated. */
2084     ofproto_revalidate(port->bridge->ofproto, hash->iface_tag);
2085     hash->iface_idx = to->iface->port_ifidx;
2086     hash->iface_tag = tag_create_random();
2087 }
2088
2089 static void
2090 bond_rebalance_port(struct port *port)
2091 {
2092     struct slave_balance bals[DP_MAX_PORTS];
2093     size_t n_bals;
2094     struct bond_entry *hashes[BOND_MASK + 1];
2095     struct slave_balance *b, *from, *to;
2096     struct bond_entry *e;
2097     size_t i;
2098
2099     /* Sets up 'bals' to describe each of the port's interfaces, sorted in
2100      * descending order of tx_bytes, so that bals[0] represents the most
2101      * heavily loaded slave and bals[n_bals - 1] represents the least heavily
2102      * loaded slave.
2103      *
2104      * The code is a bit tricky: to avoid dynamically allocating a 'hashes'
2105      * array for each slave_balance structure, we sort our local array of
2106      * hashes in order by slave, so that all of the hashes for a given slave
2107      * become contiguous in memory, and then we point each 'hashes' members of
2108      * a slave_balance structure to the start of a contiguous group. */
2109     n_bals = port->n_ifaces;
2110     for (b = bals; b < &bals[n_bals]; b++) {
2111         b->iface = port->ifaces[b - bals];
2112         b->tx_bytes = 0;
2113         b->hashes = NULL;
2114         b->n_hashes = 0;
2115     }
2116     for (i = 0; i <= BOND_MASK; i++) {
2117         hashes[i] = &port->bond_hash[i];
2118     }
2119     qsort(hashes, BOND_MASK + 1, sizeof *hashes, compare_bond_entries);
2120     for (i = 0; i <= BOND_MASK; i++) {
2121         e = hashes[i];
2122         if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
2123             b = &bals[e->iface_idx];
2124             b->tx_bytes += e->tx_bytes;
2125             if (!b->hashes) {
2126                 b->hashes = &hashes[i];
2127             }
2128             b->n_hashes++;
2129         }
2130     }
2131     qsort(bals, n_bals, sizeof *bals, compare_slave_balance);
2132     log_bals(bals, n_bals, port);
2133
2134     /* Discard slaves that aren't enabled (which were sorted to the back of the
2135      * array earlier). */
2136     while (!bals[n_bals - 1].iface->enabled) {
2137         n_bals--;
2138         if (!n_bals) {
2139             return;
2140         }
2141     }
2142
2143     /* Shift load from the most-loaded slaves to the least-loaded slaves. */
2144     to = &bals[n_bals - 1];
2145     for (from = bals; from < to; ) {
2146         uint64_t overload = from->tx_bytes - to->tx_bytes;
2147         if (overload < to->tx_bytes >> 5 || overload < 100000) {
2148             /* The extra load on 'from' (and all less-loaded slaves), compared
2149              * to that of 'to' (the least-loaded slave), is less than ~3%, or
2150              * it is less than ~1Mbps.  No point in rebalancing. */
2151             break;
2152         } else if (from->n_hashes == 1) {
2153             /* 'from' only carries a single MAC hash, so we can't shift any
2154              * load away from it, even though we want to. */
2155             from++;
2156         } else {
2157             /* 'from' is carrying significantly more load than 'to', and that
2158              * load is split across at least two different hashes.  Pick a hash
2159              * to migrate to 'to' (the least-loaded slave), given that doing so
2160              * must not cause 'to''s load to exceed 'from''s load.
2161              *
2162              * The sort order we use means that we prefer to shift away the
2163              * smallest hashes instead of the biggest ones.  There is little
2164              * reason behind this decision; we could use the opposite sort
2165              * order to shift away big hashes ahead of small ones. */
2166             size_t i;
2167
2168             for (i = 0; i < from->n_hashes; i++) {
2169                 uint64_t delta = from->hashes[i]->tx_bytes;
2170                 if (to->tx_bytes + delta < from->tx_bytes - delta) {
2171                     break;
2172                 }
2173             }
2174             if (i < from->n_hashes) {
2175                 bond_shift_load(from, to, from->hashes[i]);
2176
2177                 /* Re-sort 'bals'.  Note that this may make 'from' and 'to'
2178                  * point to different slave_balance structures.  It is only
2179                  * valid to do these two operations in a row at all because we
2180                  * know that 'from' will not move past 'to' and vice versa. */
2181                 resort_bals(from, bals, n_bals);
2182                 resort_bals(to, bals, n_bals);
2183             } else {
2184                 from++;
2185             }
2186         }
2187     }
2188
2189     /* Implement exponentially weighted moving average.  A weight of 1/2 causes
2190      * historical data to decay to <1% in 7 rebalancing runs.  */
2191     for (e = &port->bond_hash[0]; e <= &port->bond_hash[BOND_MASK]; e++) {
2192         e->tx_bytes /= 2;
2193     }
2194 }
2195
2196 static void
2197 bond_send_learning_packets(struct port *port)
2198 {
2199     struct bridge *br = port->bridge;
2200     struct mac_entry *e;
2201     struct ofpbuf packet;
2202     int error, n_packets, n_errors;
2203
2204     if (!port->n_ifaces || port->active_iface < 0 || !br->ml) {
2205         return;
2206     }
2207
2208     ofpbuf_init(&packet, 128);
2209     error = n_packets = n_errors = 0;
2210     LIST_FOR_EACH (e, struct mac_entry, lru_node, &br->ml->lrus) {
2211         static const char s[] = "Open vSwitch Bond Failover";
2212         union ofp_action actions[2], *a;
2213         struct eth_header *eth;
2214         struct llc_snap_header *llc_snap;
2215         uint16_t dp_ifidx;
2216         tag_type tags = 0;
2217         flow_t flow;
2218         int retval;
2219
2220         if (e->port == port->port_idx
2221             || !choose_output_iface(port, e->mac, &dp_ifidx, &tags)) {
2222             continue;
2223         }
2224
2225         /* Compose packet to send. */
2226         ofpbuf_clear(&packet);
2227         eth = ofpbuf_put_zeros(&packet, ETH_HEADER_LEN);
2228         llc_snap = ofpbuf_put_zeros(&packet, LLC_SNAP_HEADER_LEN);
2229         ofpbuf_put(&packet, s, sizeof s); /* Includes null byte. */
2230         ofpbuf_put(&packet, e->mac, ETH_ADDR_LEN);
2231
2232         memcpy(eth->eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
2233         memcpy(eth->eth_src, e->mac, ETH_ADDR_LEN);
2234         eth->eth_type = htons(packet.size - ETH_HEADER_LEN);
2235
2236         llc_snap->llc.llc_dsap = LLC_DSAP_SNAP;
2237         llc_snap->llc.llc_ssap = LLC_SSAP_SNAP;
2238         llc_snap->llc.llc_cntl = LLC_CNTL_SNAP;
2239         memcpy(llc_snap->snap.snap_org, "\x00\x23\x20", 3);
2240         llc_snap->snap.snap_type = htons(0xf177); /* Random number. */
2241
2242         /* Compose actions. */
2243         memset(actions, 0, sizeof actions);
2244         a = actions;
2245         if (e->vlan) {
2246             a->vlan_vid.type = htons(OFPAT_SET_VLAN_VID);
2247             a->vlan_vid.len = htons(sizeof *a);
2248             a->vlan_vid.vlan_vid = htons(e->vlan);
2249             a++;
2250         }
2251         a->output.type = htons(OFPAT_OUTPUT);
2252         a->output.len = htons(sizeof *a);
2253         a->output.port = htons(odp_port_to_ofp_port(dp_ifidx));
2254         a++;
2255
2256         /* Send packet. */
2257         n_packets++;
2258         flow_extract(&packet, ODPP_NONE, &flow);
2259         retval = ofproto_send_packet(br->ofproto, &flow, actions, a - actions,
2260                                      &packet);
2261         if (retval) {
2262             error = retval;
2263             n_errors++;
2264         }
2265     }
2266     ofpbuf_uninit(&packet);
2267
2268     if (n_errors) {
2269         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2270         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
2271                      "packets, last error was: %s",
2272                      port->name, n_errors, n_packets, strerror(error));
2273     } else {
2274         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
2275                  port->name, n_packets);
2276     }
2277 }
2278 \f
2279 /* Bonding unixctl user interface functions. */
2280
2281 static void
2282 bond_unixctl_list(struct unixctl_conn *conn, const char *args UNUSED)
2283 {
2284     struct ds ds = DS_EMPTY_INITIALIZER;
2285     const struct bridge *br;
2286
2287     ds_put_cstr(&ds, "bridge\tbond\tslaves\n");
2288
2289     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2290         size_t i;
2291
2292         for (i = 0; i < br->n_ports; i++) {
2293             const struct port *port = br->ports[i];
2294             if (port->n_ifaces > 1) {
2295                 size_t j;
2296
2297                 ds_put_format(&ds, "%s\t%s\t", br->name, port->name);
2298                 for (j = 0; j < port->n_ifaces; j++) {
2299                     const struct iface *iface = port->ifaces[j];
2300                     if (j) {
2301                         ds_put_cstr(&ds, ", ");
2302                     }
2303                     ds_put_cstr(&ds, iface->name);
2304                 }
2305                 ds_put_char(&ds, '\n');
2306             }
2307         }
2308     }
2309     unixctl_command_reply(conn, 200, ds_cstr(&ds));
2310     ds_destroy(&ds);
2311 }
2312
2313 static struct port *
2314 bond_find(const char *name)
2315 {
2316     const struct bridge *br;
2317
2318     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2319         size_t i;
2320
2321         for (i = 0; i < br->n_ports; i++) {
2322             struct port *port = br->ports[i];
2323             if (!strcmp(port->name, name) && port->n_ifaces > 1) {
2324                 return port;
2325             }
2326         }
2327     }
2328     return NULL;
2329 }
2330
2331 static void
2332 bond_unixctl_show(struct unixctl_conn *conn, const char *args)
2333 {
2334     struct ds ds = DS_EMPTY_INITIALIZER;
2335     const struct port *port;
2336     size_t j;
2337
2338     port = bond_find(args);
2339     if (!port) {
2340         unixctl_command_reply(conn, 501, "no such bond");
2341         return;
2342     }
2343
2344     ds_put_format(&ds, "updelay: %d ms\n", port->updelay);
2345     ds_put_format(&ds, "downdelay: %d ms\n", port->downdelay);
2346     ds_put_format(&ds, "next rebalance: %lld ms\n",
2347                   port->bridge->bond_next_rebalance - time_msec());
2348     for (j = 0; j < port->n_ifaces; j++) {
2349         const struct iface *iface = port->ifaces[j];
2350         struct bond_entry *be;
2351
2352         /* Basic info. */
2353         ds_put_format(&ds, "slave %s: %s\n",
2354                       iface->name, iface->enabled ? "enabled" : "disabled");
2355         if (j == port->active_iface) {
2356             ds_put_cstr(&ds, "\tactive slave\n");
2357         }
2358         if (iface->delay_expires != LLONG_MAX) {
2359             ds_put_format(&ds, "\t%s expires in %lld ms\n",
2360                           iface->enabled ? "downdelay" : "updelay",
2361                           iface->delay_expires - time_msec());
2362         }
2363
2364         /* Hashes. */
2365         for (be = port->bond_hash; be <= &port->bond_hash[BOND_MASK]; be++) {
2366             int hash = be - port->bond_hash;
2367             struct mac_entry *me;
2368
2369             if (be->iface_idx != j) {
2370                 continue;
2371             }
2372
2373             ds_put_format(&ds, "\thash %d: %lld kB load\n",
2374                           hash, be->tx_bytes / 1024);
2375
2376             /* MACs. */
2377             if (!port->bridge->ml) {
2378                 break;
2379             }
2380
2381             LIST_FOR_EACH (me, struct mac_entry, lru_node,
2382                            &port->bridge->ml->lrus) {
2383                 uint16_t dp_ifidx;
2384                 tag_type tags = 0;
2385                 if (bond_hash(me->mac) == hash
2386                     && me->port != port->port_idx
2387                     && choose_output_iface(port, me->mac, &dp_ifidx, &tags)
2388                     && dp_ifidx == iface->dp_ifidx)
2389                 {
2390                     ds_put_format(&ds, "\t\t"ETH_ADDR_FMT"\n",
2391                                   ETH_ADDR_ARGS(me->mac));
2392                 }
2393             }
2394         }
2395     }
2396     unixctl_command_reply(conn, 200, ds_cstr(&ds));
2397     ds_destroy(&ds);
2398 }
2399
2400 static void
2401 bond_unixctl_migrate(struct unixctl_conn *conn, const char *args_)
2402 {
2403     char *args = (char *) args_;
2404     char *save_ptr = NULL;
2405     char *bond_s, *hash_s, *slave_s;
2406     uint8_t mac[ETH_ADDR_LEN];
2407     struct port *port;
2408     struct iface *iface;
2409     struct bond_entry *entry;
2410     int hash;
2411
2412     bond_s = strtok_r(args, " ", &save_ptr);
2413     hash_s = strtok_r(NULL, " ", &save_ptr);
2414     slave_s = strtok_r(NULL, " ", &save_ptr);
2415     if (!slave_s) {
2416         unixctl_command_reply(conn, 501,
2417                               "usage: bond/migrate BOND HASH SLAVE");
2418         return;
2419     }
2420
2421     port = bond_find(bond_s);
2422     if (!port) {
2423         unixctl_command_reply(conn, 501, "no such bond");
2424         return;
2425     }
2426
2427     if (sscanf(hash_s, "%"SCNx8":%"SCNx8":%"SCNx8":%"SCNx8":%"SCNx8":%"SCNx8,
2428                &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]) == 6) {
2429         hash = bond_hash(mac);
2430     } else if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
2431         hash = atoi(hash_s) & BOND_MASK;
2432     } else {
2433         unixctl_command_reply(conn, 501, "bad hash");
2434         return;
2435     }
2436
2437     iface = port_lookup_iface(port, slave_s);
2438     if (!iface) {
2439         unixctl_command_reply(conn, 501, "no such slave");
2440         return;
2441     }
2442
2443     if (!iface->enabled) {
2444         unixctl_command_reply(conn, 501, "cannot migrate to disabled slave");
2445         return;
2446     }
2447
2448     entry = &port->bond_hash[hash];
2449     ofproto_revalidate(port->bridge->ofproto, entry->iface_tag);
2450     entry->iface_idx = iface->port_ifidx;
2451     entry->iface_tag = tag_create_random();
2452     unixctl_command_reply(conn, 200, "migrated");
2453 }
2454
2455 static void
2456 bond_unixctl_set_active_slave(struct unixctl_conn *conn, const char *args_)
2457 {
2458     char *args = (char *) args_;
2459     char *save_ptr = NULL;
2460     char *bond_s, *slave_s;
2461     struct port *port;
2462     struct iface *iface;
2463
2464     bond_s = strtok_r(args, " ", &save_ptr);
2465     slave_s = strtok_r(NULL, " ", &save_ptr);
2466     if (!slave_s) {
2467         unixctl_command_reply(conn, 501,
2468                               "usage: bond/set-active-slave BOND SLAVE");
2469         return;
2470     }
2471
2472     port = bond_find(bond_s);
2473     if (!port) {
2474         unixctl_command_reply(conn, 501, "no such bond");
2475         return;
2476     }
2477
2478     iface = port_lookup_iface(port, slave_s);
2479     if (!iface) {
2480         unixctl_command_reply(conn, 501, "no such slave");
2481         return;
2482     }
2483
2484     if (!iface->enabled) {
2485         unixctl_command_reply(conn, 501, "cannot make disabled slave active");
2486         return;
2487     }
2488
2489     if (port->active_iface != iface->port_ifidx) {
2490         ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
2491         port->active_iface = iface->port_ifidx;
2492         port->active_iface_tag = tag_create_random();
2493         VLOG_INFO("port %s: active interface is now %s",
2494                   port->name, iface->name);
2495         bond_send_learning_packets(port);
2496         unixctl_command_reply(conn, 200, "done");
2497     } else {
2498         unixctl_command_reply(conn, 200, "no change");
2499     }
2500 }
2501
2502 static void
2503 enable_slave(struct unixctl_conn *conn, const char *args_, bool enable)
2504 {
2505     char *args = (char *) args_;
2506     char *save_ptr = NULL;
2507     char *bond_s, *slave_s;
2508     struct port *port;
2509     struct iface *iface;
2510
2511     bond_s = strtok_r(args, " ", &save_ptr);
2512     slave_s = strtok_r(NULL, " ", &save_ptr);
2513     if (!slave_s) {
2514         unixctl_command_reply(conn, 501,
2515                               "usage: bond/enable/disable-slave BOND SLAVE");
2516         return;
2517     }
2518
2519     port = bond_find(bond_s);
2520     if (!port) {
2521         unixctl_command_reply(conn, 501, "no such bond");
2522         return;
2523     }
2524
2525     iface = port_lookup_iface(port, slave_s);
2526     if (!iface) {
2527         unixctl_command_reply(conn, 501, "no such slave");
2528         return;
2529     }
2530
2531     bond_enable_slave(iface, enable);
2532     unixctl_command_reply(conn, 501, enable ? "enabled" : "disabled");
2533 }
2534
2535 static void
2536 bond_unixctl_enable_slave(struct unixctl_conn *conn, const char *args)
2537 {
2538     enable_slave(conn, args, true);
2539 }
2540
2541 static void
2542 bond_unixctl_disable_slave(struct unixctl_conn *conn, const char *args)
2543 {
2544     enable_slave(conn, args, false);
2545 }
2546
2547 static void
2548 bond_init(void)
2549 {
2550     unixctl_command_register("bond/list", bond_unixctl_list);
2551     unixctl_command_register("bond/show", bond_unixctl_show);
2552     unixctl_command_register("bond/migrate", bond_unixctl_migrate);
2553     unixctl_command_register("bond/set-active-slave",
2554                              bond_unixctl_set_active_slave);
2555     unixctl_command_register("bond/enable-slave", bond_unixctl_enable_slave);
2556     unixctl_command_register("bond/disable-slave", bond_unixctl_disable_slave);
2557 }
2558 \f
2559 /* Port functions. */
2560
2561 static void
2562 port_create(struct bridge *br, const char *name)
2563 {
2564     struct port *port;
2565
2566     port = xcalloc(1, sizeof *port);
2567     port->bridge = br;
2568     port->port_idx = br->n_ports;
2569     port->vlan = -1;
2570     port->trunks = NULL;
2571     port->name = xstrdup(name);
2572     port->active_iface = -1;
2573     port->stp_state = STP_DISABLED;
2574     port->stp_state_tag = 0;
2575
2576     if (br->n_ports >= br->allocated_ports) {
2577         br->ports = x2nrealloc(br->ports, &br->allocated_ports,
2578                                sizeof *br->ports);
2579     }
2580     br->ports[br->n_ports++] = port;
2581
2582     VLOG_INFO("created port %s on bridge %s", port->name, br->name);
2583     bridge_flush(br);
2584 }
2585
2586 static void
2587 port_reconfigure(struct port *port)
2588 {
2589     bool bonded = cfg_has_section("bonding.%s", port->name);
2590     struct svec old_ifaces, new_ifaces;
2591     unsigned long *trunks;
2592     int vlan;
2593     size_t i;
2594
2595     /* Collect old and new interfaces. */
2596     svec_init(&old_ifaces);
2597     svec_init(&new_ifaces);
2598     for (i = 0; i < port->n_ifaces; i++) {
2599         svec_add(&old_ifaces, port->ifaces[i]->name);
2600     }
2601     svec_sort(&old_ifaces);
2602     if (bonded) {
2603         cfg_get_all_keys(&new_ifaces, "bonding.%s.slave", port->name);
2604         if (!new_ifaces.n) {
2605             VLOG_ERR("port %s: no interfaces specified for bonded port",
2606                      port->name);
2607         } else if (new_ifaces.n == 1) {
2608             VLOG_WARN("port %s: only 1 interface specified for bonded port",
2609                       port->name);
2610         }
2611
2612         port->updelay = cfg_get_int(0, "bonding.%s.updelay", port->name);
2613         if (port->updelay < 0) {
2614             port->updelay = 0;
2615         }
2616         port->downdelay = cfg_get_int(0, "bonding.%s.downdelay", port->name);
2617         if (port->downdelay < 0) {
2618             port->downdelay = 0;
2619         }
2620     } else {
2621         svec_init(&new_ifaces);
2622         svec_add(&new_ifaces, port->name);
2623     }
2624
2625     /* Get rid of deleted interfaces and add new interfaces. */
2626     for (i = 0; i < port->n_ifaces; i++) {
2627         struct iface *iface = port->ifaces[i];
2628         if (!svec_contains(&new_ifaces, iface->name)) {
2629             iface_destroy(iface);
2630         } else {
2631             i++;
2632         }
2633     }
2634     for (i = 0; i < new_ifaces.n; i++) {
2635         const char *name = new_ifaces.names[i];
2636         if (!svec_contains(&old_ifaces, name)) {
2637             iface_create(port, name);
2638         }
2639     }
2640
2641     /* Get VLAN tag. */
2642     vlan = -1;
2643     if (cfg_has("vlan.%s.tag", port->name)) {
2644         if (!bonded) {
2645             vlan = cfg_get_vlan(0, "vlan.%s.tag", port->name);
2646             if (vlan >= 0 && vlan <= 4095) {
2647                 VLOG_DBG("port %s: assigning VLAN tag %d", port->name, vlan);
2648             }
2649         } else {
2650             /* It's possible that bonded, VLAN-tagged ports make sense.  Maybe
2651              * they even work as-is.  But they have not been tested. */
2652             VLOG_WARN("port %s: VLAN tags not supported on bonded ports",
2653                       port->name);
2654         }
2655     }
2656     if (port->vlan != vlan) {
2657         port->vlan = vlan;
2658         bridge_flush(port->bridge);
2659     }
2660
2661     /* Get trunked VLANs. */
2662     trunks = NULL;
2663     if (vlan < 0) {
2664         size_t n_trunks, n_errors;
2665         size_t i;
2666
2667         trunks = bitmap_allocate(4096);
2668         n_trunks = cfg_count("vlan.%s.trunks", port->name);
2669         n_errors = 0;
2670         for (i = 0; i < n_trunks; i++) {
2671             int trunk = cfg_get_vlan(i, "vlan.%s.trunks", port->name);
2672             if (trunk >= 0) {
2673                 bitmap_set1(trunks, trunk);
2674             } else {
2675                 n_errors++;
2676             }
2677         }
2678         if (n_errors) {
2679             VLOG_ERR("port %s: invalid values for %zu trunk VLANs",
2680                      port->name, n_trunks);
2681         }
2682         if (n_errors == n_trunks) {
2683             if (n_errors) {
2684                 VLOG_ERR("port %s: no valid trunks, trunking all VLANs",
2685                          port->name);
2686             }
2687             bitmap_set_multiple(trunks, 0, 4096, 1);
2688         }
2689     } else {
2690         if (cfg_has("vlan.%s.trunks", port->name)) {
2691             VLOG_ERR("ignoring vlan.%s.trunks in favor of vlan.%s.vlan",
2692                      port->name, port->name);
2693         }
2694     }
2695     if (trunks == NULL
2696         ? port->trunks != NULL
2697         : port->trunks == NULL || !bitmap_equal(trunks, port->trunks, 4096)) {
2698         bridge_flush(port->bridge);
2699     }
2700     bitmap_free(port->trunks);
2701     port->trunks = trunks;
2702
2703     svec_destroy(&old_ifaces);
2704     svec_destroy(&new_ifaces);
2705 }
2706
2707 static void
2708 port_destroy(struct port *port)
2709 {
2710     if (port) {
2711         struct bridge *br = port->bridge;
2712         struct port *del;
2713         size_t i;
2714
2715         proc_net_compat_update_vlan(port->name, NULL, 0);
2716
2717         for (i = 0; i < MAX_MIRRORS; i++) {
2718             struct mirror *m = br->mirrors[i];
2719             if (m && m->out_port == port) {
2720                 mirror_destroy(m);
2721             }
2722         }
2723
2724         while (port->n_ifaces > 0) {
2725             iface_destroy(port->ifaces[port->n_ifaces - 1]);
2726         }
2727
2728         del = br->ports[port->port_idx] = br->ports[--br->n_ports];
2729         del->port_idx = port->port_idx;
2730
2731         free(port->ifaces);
2732         bitmap_free(port->trunks);
2733         free(port->name);
2734         free(port);
2735         bridge_flush(br);
2736     }
2737 }
2738
2739 static struct port *
2740 port_from_dp_ifidx(const struct bridge *br, uint16_t dp_ifidx)
2741 {
2742     struct iface *iface = iface_from_dp_ifidx(br, dp_ifidx);
2743     return iface ? iface->port : NULL;
2744 }
2745
2746 static struct port *
2747 port_lookup(const struct bridge *br, const char *name)
2748 {
2749     size_t i;
2750
2751     for (i = 0; i < br->n_ports; i++) {
2752         struct port *port = br->ports[i];
2753         if (!strcmp(port->name, name)) {
2754             return port;
2755         }
2756     }
2757     return NULL;
2758 }
2759
2760 static struct iface *
2761 port_lookup_iface(const struct port *port, const char *name)
2762 {
2763     size_t j;
2764
2765     for (j = 0; j < port->n_ifaces; j++) {
2766         struct iface *iface = port->ifaces[j];
2767         if (!strcmp(iface->name, name)) {
2768             return iface;
2769         }
2770     }
2771     return NULL;
2772 }
2773
2774 static void
2775 port_update_bonding(struct port *port)
2776 {
2777     if (port->n_ifaces < 2) {
2778         /* Not a bonded port. */
2779         if (port->bond_hash) {
2780             free(port->bond_hash);
2781             port->bond_hash = NULL;
2782             proc_net_compat_update_bond(port->name, NULL);
2783         }
2784     } else {
2785         if (!port->bond_hash) {
2786             size_t i;
2787
2788             port->bond_hash = xcalloc(BOND_MASK + 1, sizeof *port->bond_hash);
2789             for (i = 0; i <= BOND_MASK; i++) {
2790                 struct bond_entry *e = &port->bond_hash[i];
2791                 e->iface_idx = -1;
2792                 e->tx_bytes = 0;
2793             }
2794             port->no_ifaces_tag = tag_create_random();
2795             bond_choose_active_iface(port);
2796         }
2797         port_update_bond_compat(port);
2798     }
2799 }
2800
2801 static void
2802 port_update_bond_compat(struct port *port)
2803 {
2804     struct compat_bond bond;
2805     size_t i;
2806
2807     if (port->n_ifaces < 2) {
2808         return;
2809     }
2810
2811     bond.up = false;
2812     bond.updelay = port->updelay;
2813     bond.downdelay = port->downdelay;
2814     bond.n_slaves = port->n_ifaces;
2815     bond.slaves = xmalloc(port->n_ifaces * sizeof *bond.slaves);
2816     for (i = 0; i < port->n_ifaces; i++) {
2817         struct iface *iface = port->ifaces[i];
2818         struct compat_bond_slave *slave = &bond.slaves[i];
2819         slave->name = iface->name;
2820         slave->up = ((iface->enabled && iface->delay_expires == LLONG_MAX) ||
2821                      (!iface->enabled && iface->delay_expires != LLONG_MAX));
2822         if (slave->up) {
2823             bond.up = true;
2824         }
2825         memcpy(slave->mac, iface->mac, ETH_ADDR_LEN);
2826     }
2827     proc_net_compat_update_bond(port->name, &bond);
2828     free(bond.slaves);
2829 }
2830
2831 static void
2832 port_update_vlan_compat(struct port *port)
2833 {
2834     struct bridge *br = port->bridge;
2835     char *vlandev_name = NULL;
2836
2837     if (port->vlan > 0) {
2838         /* Figure out the name that the VLAN device should actually have, if it
2839          * existed.  This takes some work because the VLAN device would not
2840          * have port->name in its name; rather, it would have the trunk port's
2841          * name, and 'port' would be attached to a bridge that also had the
2842          * VLAN device one of its ports.  So we need to find a trunk port that
2843          * includes port->vlan.
2844          *
2845          * There might be more than one candidate.  This doesn't happen on
2846          * XenServer, so if it happens we just pick the first choice in
2847          * alphabetical order instead of creating multiple VLAN devices. */
2848         size_t i;
2849         for (i = 0; i < br->n_ports; i++) {
2850             struct port *p = br->ports[i];
2851             if (port_trunks_vlan(p, port->vlan)
2852                 && p->n_ifaces
2853                 && (!vlandev_name || strcmp(p->name, vlandev_name) <= 0))
2854             {
2855                 const uint8_t *ea = p->ifaces[0]->mac;
2856                 if (!eth_addr_is_multicast(ea) &&
2857                     !eth_addr_is_reserved(ea) &&
2858                     !eth_addr_is_zero(ea)) {
2859                     vlandev_name = p->name;
2860                 }
2861             }
2862         }
2863     }
2864     proc_net_compat_update_vlan(port->name, vlandev_name, port->vlan);
2865 }
2866 \f
2867 /* Interface functions. */
2868
2869 static void
2870 iface_create(struct port *port, const char *name)
2871 {
2872     struct iface *iface;
2873
2874     iface = xcalloc(1, sizeof *iface);
2875     iface->port = port;
2876     iface->port_ifidx = port->n_ifaces;
2877     iface->name = xstrdup(name);
2878     iface->dp_ifidx = -1;
2879     iface->tag = tag_create_random();
2880     iface->delay_expires = LLONG_MAX;
2881
2882     netdev_nodev_get_etheraddr(name, iface->mac);
2883     netdev_nodev_get_carrier(name, &iface->enabled);
2884
2885     if (port->n_ifaces >= port->allocated_ifaces) {
2886         port->ifaces = x2nrealloc(port->ifaces, &port->allocated_ifaces,
2887                                   sizeof *port->ifaces);
2888     }
2889     port->ifaces[port->n_ifaces++] = iface;
2890     if (port->n_ifaces > 1) {
2891         port->bridge->has_bonded_ports = true;
2892     }
2893
2894     VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
2895
2896     port_update_bonding(port);
2897     bridge_flush(port->bridge);
2898 }
2899
2900 static void
2901 iface_destroy(struct iface *iface)
2902 {
2903     if (iface) {
2904         struct port *port = iface->port;
2905         struct bridge *br = port->bridge;
2906         bool del_active = port->active_iface == iface->port_ifidx;
2907         struct iface *del;
2908
2909         if (iface->dp_ifidx >= 0) {
2910             port_array_set(&br->ifaces, iface->dp_ifidx, NULL);
2911         }
2912
2913         del = port->ifaces[iface->port_ifidx] = port->ifaces[--port->n_ifaces];
2914         del->port_ifidx = iface->port_ifidx;
2915
2916         free(iface->name);
2917         free(iface);
2918
2919         if (del_active) {
2920             ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
2921             bond_choose_active_iface(port);
2922             bond_send_learning_packets(port);
2923         }
2924
2925         port_update_bonding(port);
2926         bridge_flush(port->bridge);
2927     }
2928 }
2929
2930 static struct iface *
2931 iface_lookup(const struct bridge *br, const char *name)
2932 {
2933     size_t i, j;
2934
2935     for (i = 0; i < br->n_ports; i++) {
2936         struct port *port = br->ports[i];
2937         for (j = 0; j < port->n_ifaces; j++) {
2938             struct iface *iface = port->ifaces[j];
2939             if (!strcmp(iface->name, name)) {
2940                 return iface;
2941             }
2942         }
2943     }
2944     return NULL;
2945 }
2946
2947 static struct iface *
2948 iface_from_dp_ifidx(const struct bridge *br, uint16_t dp_ifidx)
2949 {
2950     return port_array_get(&br->ifaces, dp_ifidx);
2951 }
2952 \f
2953 /* Port mirroring. */
2954
2955 static void
2956 mirror_reconfigure(struct bridge *br)
2957 {
2958     struct svec old_mirrors, new_mirrors;
2959     size_t i;
2960
2961     /* Collect old and new mirrors. */
2962     svec_init(&old_mirrors);
2963     svec_init(&new_mirrors);
2964     cfg_get_subsections(&new_mirrors, "mirror.%s", br->name);
2965     for (i = 0; i < MAX_MIRRORS; i++) {
2966         if (br->mirrors[i]) {
2967             svec_add(&old_mirrors, br->mirrors[i]->name);
2968         }
2969     }
2970
2971     /* Get rid of deleted mirrors and add new mirrors. */
2972     svec_sort(&old_mirrors);
2973     assert(svec_is_unique(&old_mirrors));
2974     svec_sort(&new_mirrors);
2975     assert(svec_is_unique(&new_mirrors));
2976     for (i = 0; i < MAX_MIRRORS; i++) {
2977         struct mirror *m = br->mirrors[i];
2978         if (m && !svec_contains(&new_mirrors, m->name)) {
2979             mirror_destroy(m);
2980         }
2981     }
2982     for (i = 0; i < new_mirrors.n; i++) {
2983         const char *name = new_mirrors.names[i];
2984         if (!svec_contains(&old_mirrors, name)) {
2985             mirror_create(br, name);
2986         }
2987     }
2988     svec_destroy(&old_mirrors);
2989     svec_destroy(&new_mirrors);
2990
2991     /* Reconfigure all mirrors. */
2992     for (i = 0; i < MAX_MIRRORS; i++) {
2993         if (br->mirrors[i]) {
2994             mirror_reconfigure_one(br->mirrors[i]);
2995         }
2996     }
2997
2998     /* Update port reserved status. */
2999     for (i = 0; i < br->n_ports; i++) {
3000         br->ports[i]->is_mirror_output_port = false;
3001     }
3002     for (i = 0; i < MAX_MIRRORS; i++) {
3003         struct mirror *m = br->mirrors[i];
3004         if (m && m->out_port) {
3005             m->out_port->is_mirror_output_port = true;
3006         }
3007     }
3008 }
3009
3010 static void
3011 mirror_create(struct bridge *br, const char *name)
3012 {
3013     struct mirror *m;
3014     size_t i;
3015
3016     for (i = 0; ; i++) {
3017         if (i >= MAX_MIRRORS) {
3018             VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
3019                       "cannot create %s", br->name, MAX_MIRRORS, name);
3020             return;
3021         }
3022         if (!br->mirrors[i]) {
3023             break;
3024         }
3025     }
3026
3027     VLOG_INFO("created port mirror %s on bridge %s", name, br->name);
3028     bridge_flush(br);
3029
3030     br->mirrors[i] = m = xcalloc(1, sizeof *m);
3031     m->bridge = br;
3032     m->idx = i;
3033     m->name = xstrdup(name);
3034     svec_init(&m->src_ports);
3035     svec_init(&m->dst_ports);
3036     m->vlans = NULL;
3037     m->n_vlans = 0;
3038     m->out_vlan = -1;
3039     m->out_port = NULL;
3040 }
3041
3042 static void
3043 mirror_destroy(struct mirror *m)
3044 {
3045     if (m) {
3046         struct bridge *br = m->bridge;
3047         size_t i;
3048
3049         for (i = 0; i < br->n_ports; i++) {
3050             br->ports[i]->src_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3051             br->ports[i]->dst_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3052         }
3053
3054         svec_destroy(&m->src_ports);
3055         svec_destroy(&m->dst_ports);
3056         free(m->vlans);
3057
3058         m->bridge->mirrors[m->idx] = NULL;
3059         free(m);
3060
3061         bridge_flush(br);
3062     }
3063 }
3064
3065 static void
3066 prune_ports(struct mirror *m, struct svec *ports)
3067 {
3068     struct svec tmp;
3069     size_t i;
3070
3071     svec_sort_unique(ports);
3072
3073     svec_init(&tmp);
3074     for (i = 0; i < ports->n; i++) {
3075         const char *name = ports->names[i];
3076         if (port_lookup(m->bridge, name)) {
3077             svec_add(&tmp, name);
3078         } else {
3079             VLOG_WARN("mirror.%s.%s: cannot match on nonexistent port %s",
3080                       m->bridge->name, m->name, name);
3081         }
3082     }
3083     svec_swap(ports, &tmp);
3084     svec_destroy(&tmp);
3085 }
3086
3087 static size_t
3088 prune_vlans(struct mirror *m, struct svec *vlan_strings, int **vlans)
3089 {
3090     size_t n_vlans, i;
3091
3092     /* This isn't perfect: it won't combine "0" and "00", and the textual sort
3093      * order won't give us numeric sort order.  But that's good enough for what
3094      * we need right now. */
3095     svec_sort_unique(vlan_strings);
3096
3097     *vlans = xmalloc(sizeof *vlans * vlan_strings->n);
3098     n_vlans = 0;
3099     for (i = 0; i < vlan_strings->n; i++) {
3100         const char *name = vlan_strings->names[i];
3101         int vlan;
3102         if (!str_to_int(name, 10, &vlan) || vlan < 0 || vlan > 4095) {
3103             VLOG_WARN("mirror.%s.%s.select.vlan: ignoring invalid VLAN %s",
3104                       m->bridge->name, m->name, name);
3105         } else {
3106             (*vlans)[n_vlans++] = vlan;
3107         }
3108     }
3109     return n_vlans;
3110 }
3111
3112 static bool
3113 vlan_is_mirrored(const struct mirror *m, int vlan)
3114 {
3115     size_t i;
3116
3117     for (i = 0; i < m->n_vlans; i++) {
3118         if (m->vlans[i] == vlan) {
3119             return true;
3120         }
3121     }
3122     return false;
3123 }
3124
3125 static bool
3126 port_trunks_any_mirrored_vlan(const struct mirror *m, const struct port *p)
3127 {
3128     size_t i;
3129
3130     for (i = 0; i < m->n_vlans; i++) {
3131         if (port_trunks_vlan(p, m->vlans[i])) {
3132             return true;
3133         }
3134     }
3135     return false;
3136 }
3137
3138 static void
3139 mirror_reconfigure_one(struct mirror *m)
3140 {
3141     char *pfx = xasprintf("mirror.%s.%s", m->bridge->name, m->name);
3142     struct svec src_ports, dst_ports, ports;
3143     struct svec vlan_strings;
3144     mirror_mask_t mirror_bit;
3145     const char *out_port_name;
3146     struct port *out_port;
3147     int out_vlan;
3148     size_t n_vlans;
3149     int *vlans;
3150     size_t i;
3151     bool mirror_all_ports;
3152
3153     /* Get output port. */
3154     out_port_name = cfg_get_key(0, "mirror.%s.%s.output.port",
3155                                 m->bridge->name, m->name);
3156     if (out_port_name) {
3157         out_port = port_lookup(m->bridge, out_port_name);
3158         if (!out_port) {
3159             VLOG_ERR("%s.output.port: bridge %s does not have a port "
3160                       "named %s", pfx, m->bridge->name, out_port_name);
3161             mirror_destroy(m);
3162             free(pfx);
3163             return;
3164         }
3165         out_vlan = -1;
3166
3167         if (cfg_has("%s.output.vlan", pfx)) {
3168             VLOG_ERR("%s.output.port and %s.output.vlan both specified; "
3169                      "ignoring %s.output.vlan", pfx, pfx, pfx);
3170         }
3171     } else if (cfg_has("%s.output.vlan", pfx)) {
3172         out_port = NULL;
3173         out_vlan = cfg_get_vlan(0, "%s.output.vlan", pfx);
3174     } else {
3175         VLOG_ERR("%s: neither %s.output.port nor %s.output.vlan specified, "
3176                  "but exactly one is required; disabling port mirror %s",
3177                  pfx, pfx, pfx, pfx);
3178         mirror_destroy(m);
3179         free(pfx);
3180         return;
3181     }
3182
3183     /* Get all the ports, and drop duplicates and ports that don't exist. */
3184     svec_init(&src_ports);
3185     svec_init(&dst_ports);
3186     svec_init(&ports);
3187     cfg_get_all_keys(&src_ports, "%s.select.src-port", pfx);
3188     cfg_get_all_keys(&dst_ports, "%s.select.dst-port", pfx);
3189     cfg_get_all_keys(&ports, "%s.select.port", pfx);
3190     svec_append(&src_ports, &ports);
3191     svec_append(&dst_ports, &ports);
3192     svec_destroy(&ports);
3193     prune_ports(m, &src_ports);
3194     prune_ports(m, &dst_ports);
3195
3196     /* Get all the vlans, and drop duplicate and invalid vlans. */
3197     svec_init(&vlan_strings);
3198     cfg_get_all_keys(&vlan_strings, "%s.select.vlan", pfx);
3199     n_vlans = prune_vlans(m, &vlan_strings, &vlans);
3200     svec_destroy(&vlan_strings);
3201
3202     /* Update mirror data. */
3203     if (!svec_equal(&m->src_ports, &src_ports)
3204         || !svec_equal(&m->dst_ports, &dst_ports)
3205         || m->n_vlans != n_vlans
3206         || memcmp(m->vlans, vlans, sizeof *vlans * n_vlans)
3207         || m->out_port != out_port
3208         || m->out_vlan != out_vlan) {
3209         bridge_flush(m->bridge);
3210     }
3211     svec_swap(&m->src_ports, &src_ports);
3212     svec_swap(&m->dst_ports, &dst_ports);
3213     free(m->vlans);
3214     m->vlans = vlans;
3215     m->n_vlans = n_vlans;
3216     m->out_port = out_port;
3217     m->out_vlan = out_vlan;
3218
3219     /* If no selection criteria have been given, mirror for all ports. */
3220     mirror_all_ports = (!m->src_ports.n) && (!m->dst_ports.n) && (!m->n_vlans);
3221
3222     /* Update ports. */
3223     mirror_bit = MIRROR_MASK_C(1) << m->idx;
3224     for (i = 0; i < m->bridge->n_ports; i++) {
3225         struct port *port = m->bridge->ports[i];
3226
3227         if (mirror_all_ports
3228             || svec_contains(&m->src_ports, port->name)
3229             || (m->n_vlans
3230                 && (!port->vlan
3231                     ? port_trunks_any_mirrored_vlan(m, port)
3232                     : vlan_is_mirrored(m, port->vlan)))) {
3233             port->src_mirrors |= mirror_bit;
3234         } else {
3235             port->src_mirrors &= ~mirror_bit;
3236         }
3237
3238         if (mirror_all_ports || svec_contains(&m->dst_ports, port->name)) {
3239             port->dst_mirrors |= mirror_bit;
3240         } else {
3241             port->dst_mirrors &= ~mirror_bit;
3242         }
3243     }
3244
3245     /* Clean up. */
3246     svec_destroy(&src_ports);
3247     svec_destroy(&dst_ports);
3248     free(pfx);
3249 }
3250 \f
3251 /* Spanning tree protocol. */
3252
3253 static void brstp_update_port_state(struct port *);
3254
3255 static void
3256 brstp_send_bpdu(struct ofpbuf *pkt, int port_no, void *br_)
3257 {
3258     struct bridge *br = br_;
3259     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
3260     struct iface *iface = iface_from_dp_ifidx(br, port_no);
3261     if (!iface) {
3262         VLOG_WARN_RL(&rl, "%s: cannot send BPDU on unknown port %d",
3263                      br->name, port_no);
3264     } else if (eth_addr_is_zero(iface->mac)) {
3265         VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d with unknown MAC",
3266                      br->name, port_no);
3267     } else {
3268         union ofp_action action;
3269         struct eth_header *eth = pkt->l2;
3270         flow_t flow;
3271
3272         memcpy(eth->eth_src, iface->mac, ETH_ADDR_LEN);
3273
3274         memset(&action, 0, sizeof action);
3275         action.type = htons(OFPAT_OUTPUT);
3276         action.output.len = htons(sizeof action);
3277         action.output.port = htons(port_no);
3278
3279         flow_extract(pkt, ODPP_NONE, &flow);
3280         ofproto_send_packet(br->ofproto, &flow, &action, 1, pkt);
3281     }
3282     ofpbuf_delete(pkt);
3283 }
3284
3285 static void
3286 brstp_reconfigure(struct bridge *br)
3287 {
3288     size_t i;
3289
3290     if (!cfg_get_bool(0, "stp.%s.enabled", br->name)) {
3291         if (br->stp) {
3292             stp_destroy(br->stp);
3293             br->stp = NULL;
3294
3295             bridge_flush(br);
3296         }
3297     } else {
3298         uint64_t bridge_address, bridge_id;
3299         int bridge_priority;
3300
3301         bridge_address = cfg_get_mac(0, "stp.%s.address", br->name);
3302         if (!bridge_address) {
3303             if (br->stp) {
3304                 bridge_address = (stp_get_bridge_id(br->stp)
3305                                   & ((UINT64_C(1) << 48) - 1));
3306             } else {
3307                 uint8_t mac[ETH_ADDR_LEN];
3308                 eth_addr_random(mac);
3309                 bridge_address = eth_addr_to_uint64(mac);
3310             }
3311         }
3312
3313         if (cfg_is_valid(CFG_INT | CFG_REQUIRED, "stp.%s.priority",
3314                          br->name)) {
3315             bridge_priority = cfg_get_int(0, "stp.%s.priority", br->name);
3316         } else {
3317             bridge_priority = STP_DEFAULT_BRIDGE_PRIORITY;
3318         }
3319
3320         bridge_id = bridge_address | ((uint64_t) bridge_priority << 48);
3321         if (!br->stp) {
3322             br->stp = stp_create(br->name, bridge_id, brstp_send_bpdu, br);
3323             br->stp_last_tick = time_msec();
3324             bridge_flush(br);
3325         } else {
3326             if (bridge_id != stp_get_bridge_id(br->stp)) {
3327                 stp_set_bridge_id(br->stp, bridge_id);
3328                 bridge_flush(br);
3329             }
3330         }
3331
3332         for (i = 0; i < br->n_ports; i++) {
3333             struct port *p = br->ports[i];
3334             int dp_ifidx;
3335             struct stp_port *sp;
3336             int path_cost, priority;
3337             bool enable;
3338
3339             if (!p->n_ifaces) {
3340                 continue;
3341             }
3342             dp_ifidx = p->ifaces[0]->dp_ifidx;
3343             if (dp_ifidx < 0 || dp_ifidx >= STP_MAX_PORTS) {
3344                 continue;
3345             }
3346
3347             sp = stp_get_port(br->stp, dp_ifidx);
3348             enable = (!cfg_is_valid(CFG_BOOL | CFG_REQUIRED,
3349                                     "stp.%s.port.%s.enabled",
3350                                     br->name, p->name)
3351                       || cfg_get_bool(0, "stp.%s.port.%s.enabled",
3352                                       br->name, p->name));
3353             if (p->is_mirror_output_port) {
3354                 enable = false;
3355             }
3356             if (enable != (stp_port_get_state(sp) != STP_DISABLED)) {
3357                 bridge_flush(br); /* Might not be necessary. */
3358                 if (enable) {
3359                     stp_port_enable(sp);
3360                 } else {
3361                     stp_port_disable(sp);
3362                 }
3363             }
3364
3365             path_cost = cfg_get_int(0, "stp.%s.port.%s.path-cost",
3366                                     br->name, p->name);
3367             stp_port_set_path_cost(sp, path_cost ? path_cost : 19 /* XXX */);
3368
3369             priority = (cfg_is_valid(CFG_INT | CFG_REQUIRED,
3370                                      "stp.%s.port.%s.priority",
3371                                      br->name, p->name)
3372                         ? cfg_get_int(0, "stp.%s.port.%s.priority",
3373                                       br->name, p->name)
3374                         : STP_DEFAULT_PORT_PRIORITY);
3375             stp_port_set_priority(sp, priority);
3376         }
3377
3378         brstp_adjust_timers(br);
3379     }
3380     for (i = 0; i < br->n_ports; i++) {
3381         brstp_update_port_state(br->ports[i]);
3382     }
3383 }
3384
3385 static void
3386 brstp_update_port_state(struct port *p)
3387 {
3388     struct bridge *br = p->bridge;
3389     enum stp_state state;
3390
3391     /* Figure out new state. */
3392     state = STP_DISABLED;
3393     if (br->stp && p->n_ifaces > 0) {
3394         int dp_ifidx = p->ifaces[0]->dp_ifidx;
3395         if (dp_ifidx >= 0 && dp_ifidx < STP_MAX_PORTS) {
3396             state = stp_port_get_state(stp_get_port(br->stp, dp_ifidx));
3397         }
3398     }
3399
3400     /* Update state. */
3401     if (p->stp_state != state) {
3402         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(10, 10);
3403         VLOG_INFO_RL(&rl, "port %s: STP state changed from %s to %s",
3404                      p->name, stp_state_name(p->stp_state),
3405                      stp_state_name(state));
3406         if (p->stp_state == STP_DISABLED) {
3407             bridge_flush(br);
3408         } else {
3409             ofproto_revalidate(p->bridge->ofproto, p->stp_state_tag);
3410         }
3411         p->stp_state = state;
3412         p->stp_state_tag = (p->stp_state == STP_DISABLED ? 0
3413                             : tag_create_random());
3414     }
3415 }
3416
3417 static void
3418 brstp_adjust_timers(struct bridge *br)
3419 {
3420     int hello_time = cfg_get_int(0, "stp.%s.hello-time", br->name);
3421     int max_age = cfg_get_int(0, "stp.%s.max-age", br->name);
3422     int forward_delay = cfg_get_int(0, "stp.%s.forward-delay", br->name);
3423
3424     stp_set_hello_time(br->stp, hello_time ? hello_time : 2000);
3425     stp_set_max_age(br->stp, max_age ? max_age : 20000);
3426     stp_set_forward_delay(br->stp, forward_delay ? forward_delay : 15000);
3427 }
3428
3429 static void
3430 brstp_run(struct bridge *br)
3431 {
3432     if (br->stp) {
3433         long long int now = time_msec();
3434         long long int elapsed = now - br->stp_last_tick;
3435         struct stp_port *sp;
3436
3437         if (elapsed > 0) {
3438             stp_tick(br->stp, MIN(INT_MAX, elapsed));
3439             br->stp_last_tick = now;
3440         }
3441         while (stp_get_changed_port(br->stp, &sp)) {
3442             struct port *p = port_from_dp_ifidx(br, stp_port_no(sp));
3443             if (p) {
3444                 brstp_update_port_state(p);
3445             }
3446         }
3447     }
3448 }
3449
3450 static void
3451 brstp_wait(struct bridge *br)
3452 {
3453     if (br->stp) {
3454         poll_timer_wait(1000);
3455     }
3456 }