Merge "master" into "wdp".
[sliver-openvswitch.git] / vswitchd / bridge.c
1 /* Copyright (c) 2008, 2009, 2010 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 <sys/socket.h>
24 #include <net/if.h>
25 #include <openflow/openflow.h>
26 #include <signal.h>
27 #include <stdlib.h>
28 #include <strings.h>
29 #include <sys/stat.h>
30 #include <sys/socket.h>
31 #include <sys/types.h>
32 #include <unistd.h>
33 #include "bitmap.h"
34 #include "coverage.h"
35 #include "dirs.h"
36 #include "dynamic-string.h"
37 #include "flow.h"
38 #include "hash.h"
39 #include "jsonrpc.h"
40 #include "list.h"
41 #include "mac-learning.h"
42 #include "netdev.h"
43 #include "xflow-util.h"
44 #include "ofp-print.h"
45 #include "ofpbuf.h"
46 #include "ofproto/netflow.h"
47 #include "ofproto/ofproto.h"
48 #include "ovsdb-data.h"
49 #include "packets.h"
50 #include "poll-loop.h"
51 #include "port-array.h"
52 #include "proc-net-compat.h"
53 #include "process.h"
54 #include "sha1.h"
55 #include "shash.h"
56 #include "socket-util.h"
57 #include "stream-ssl.h"
58 #include "svec.h"
59 #include "timeval.h"
60 #include "util.h"
61 #include "unixctl.h"
62 #include "vconn.h"
63 #include "vswitchd/vswitch-idl.h"
64 #include "xenserver.h"
65 #include "vlog.h"
66 #include "xfif.h"
67 #include "xtoxll.h"
68 #include "sflow_api.h"
69
70 VLOG_DEFINE_THIS_MODULE(bridge)
71
72 struct dst {
73     uint16_t vlan;
74     uint16_t xf_ifidx;
75 };
76
77 struct iface {
78     /* These members are always valid. */
79     struct port *port;          /* Containing port. */
80     size_t port_ifidx;          /* Index within containing port. */
81     char *name;                 /* Host network device name. */
82     tag_type tag;               /* Tag associated with this interface. */
83     long long delay_expires;    /* Time after which 'enabled' may change. */
84
85     /* These members are valid only after bridge_reconfigure() causes them to
86      * be initialized. */
87     int xf_ifidx;               /* Index within kernel datapath. */
88     struct netdev *netdev;      /* Network device. */
89     bool enabled;               /* May be chosen for flows? */
90     const struct ovsrec_interface *cfg;
91 };
92
93 #define BOND_MASK 0xff
94 struct bond_entry {
95     int iface_idx;              /* Index of assigned iface, or -1 if none. */
96     uint64_t tx_bytes;          /* Count of bytes recently transmitted. */
97     tag_type iface_tag;         /* Tag associated with iface_idx. */
98 };
99
100 #define MAX_MIRRORS 32
101 typedef uint32_t mirror_mask_t;
102 #define MIRROR_MASK_C(X) UINT32_C(X)
103 BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
104 struct mirror {
105     struct bridge *bridge;
106     size_t idx;
107     char *name;
108     struct uuid uuid;           /* UUID of this "mirror" record in database. */
109
110     /* Selection criteria. */
111     struct shash src_ports;     /* Name is port name; data is always NULL. */
112     struct shash dst_ports;     /* Name is port name; data is always NULL. */
113     int *vlans;
114     size_t n_vlans;
115
116     /* Output. */
117     struct port *out_port;
118     int out_vlan;
119 };
120
121 #define FLOOD_PORT ((struct port *) 1) /* The 'flood' output port. */
122 struct port {
123     struct bridge *bridge;
124     size_t port_idx;
125     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
126     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
127                                  * NULL if all VLANs are trunked. */
128     const struct ovsrec_port *cfg;
129     char *name;
130
131     /* An ordinary bridge port has 1 interface.
132      * A bridge port for bonding has at least 2 interfaces. */
133     struct iface **ifaces;
134     size_t n_ifaces, allocated_ifaces;
135
136     /* Bonding info. */
137     struct bond_entry *bond_hash; /* An array of (BOND_MASK + 1) elements. */
138     int active_iface;           /* Ifidx on which bcasts accepted, or -1. */
139     tag_type active_iface_tag;  /* Tag for bcast flows. */
140     tag_type no_ifaces_tag;     /* Tag for flows when all ifaces disabled. */
141     int updelay, downdelay;     /* Delay before iface goes up/down, in ms. */
142     bool bond_compat_is_stale;  /* Need to call port_update_bond_compat()? */
143     bool bond_fake_iface;       /* Fake a bond interface for legacy compat? */
144     long bond_next_fake_iface_update; /* Next update to fake bond stats. */
145     int bond_rebalance_interval; /* Interval between rebalances, in ms. */
146     long long int bond_next_rebalance; /* Next rebalancing time. */
147
148     /* Port mirroring info. */
149     mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
150     mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
151     bool is_mirror_output_port; /* Does port mirroring send frames here? */
152 };
153
154 #define DP_MAX_PORTS 255
155 struct bridge {
156     struct list node;           /* Node in global list of bridges. */
157     char *name;                 /* User-specified arbitrary name. */
158     struct mac_learning *ml;    /* MAC learning table. */
159     uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
160     const struct ovsrec_bridge *cfg;
161
162     /* OpenFlow switch processing. */
163     struct ofproto *ofproto;    /* OpenFlow switch. */
164
165     /* Kernel datapath information. */
166     struct xfif *xfif;          /* Datapath. */
167     struct port_array ifaces;   /* Indexed by kernel datapath port number. */
168
169     /* Bridge ports. */
170     struct port **ports;
171     size_t n_ports, allocated_ports;
172     struct shash iface_by_name; /* "struct iface"s indexed by name. */
173     struct shash port_by_name;  /* "struct port"s indexed by name. */
174
175     /* Bonding. */
176     bool has_bonded_ports;
177
178     /* Flow tracking. */
179     bool flush;
180
181     /* Port mirroring. */
182     struct mirror *mirrors[MAX_MIRRORS];
183 };
184
185 /* List of all bridges. */
186 static struct list all_bridges = LIST_INITIALIZER(&all_bridges);
187
188 /* OVSDB IDL used to obtain configuration. */
189 static struct ovsdb_idl *idl;
190
191 /* Each time this timer expires, the bridge fetches statistics for every
192  * interface and pushes them into the database. */
193 #define IFACE_STATS_INTERVAL (5 * 1000) /* In milliseconds. */
194 static long long int iface_stats_timer = LLONG_MIN;
195
196 static struct bridge *bridge_create(const struct ovsrec_bridge *br_cfg);
197 static void bridge_destroy(struct bridge *);
198 static struct bridge *bridge_lookup(const char *name);
199 static unixctl_cb_func bridge_unixctl_dump_flows;
200 static unixctl_cb_func bridge_unixctl_reconnect;
201 static int bridge_run_one(struct bridge *);
202 static size_t bridge_get_controllers(const struct bridge *br,
203                                      struct ovsrec_controller ***controllersp);
204 static void bridge_reconfigure_one(struct bridge *);
205 static void bridge_reconfigure_remotes(struct bridge *,
206                                        const struct sockaddr_in *managers,
207                                        size_t n_managers);
208 static void bridge_get_all_ifaces(const struct bridge *, struct shash *ifaces);
209 static void bridge_fetch_dp_ifaces(struct bridge *);
210 static void bridge_flush(struct bridge *);
211 static void bridge_pick_local_hw_addr(struct bridge *,
212                                       uint8_t ea[ETH_ADDR_LEN],
213                                       struct iface **hw_addr_iface);
214 static uint64_t bridge_pick_datapath_id(struct bridge *,
215                                         const uint8_t bridge_ea[ETH_ADDR_LEN],
216                                         struct iface *hw_addr_iface);
217 static struct iface *bridge_get_local_iface(struct bridge *);
218 static uint64_t dpid_from_hash(const void *, size_t nbytes);
219
220 static unixctl_cb_func bridge_unixctl_fdb_show;
221
222 static void bond_init(void);
223 static void bond_run(struct bridge *);
224 static void bond_wait(struct bridge *);
225 static void bond_rebalance_port(struct port *);
226 static void bond_send_learning_packets(struct port *);
227 static void bond_enable_slave(struct iface *iface, bool enable);
228
229 static struct port *port_create(struct bridge *, const char *name);
230 static void port_reconfigure(struct port *, const struct ovsrec_port *);
231 static void port_del_ifaces(struct port *, const struct ovsrec_port *);
232 static void port_destroy(struct port *);
233 static struct port *port_lookup(const struct bridge *, const char *name);
234 static struct iface *port_lookup_iface(const struct port *, const char *name);
235 static struct port *port_from_xf_ifidx(const struct bridge *,
236                                        uint16_t xf_ifidx);
237 static void port_update_bond_compat(struct port *);
238 static void port_update_vlan_compat(struct port *);
239 static void port_update_bonding(struct port *);
240
241 static void mirror_create(struct bridge *, struct ovsrec_mirror *);
242 static void mirror_destroy(struct mirror *);
243 static void mirror_reconfigure(struct bridge *);
244 static void mirror_reconfigure_one(struct mirror *, struct ovsrec_mirror *);
245 static bool vlan_is_mirrored(const struct mirror *, int vlan);
246
247 static struct iface *iface_create(struct port *port, 
248                                   const struct ovsrec_interface *if_cfg);
249 static void iface_destroy(struct iface *);
250 static struct iface *iface_lookup(const struct bridge *, const char *name);
251 static struct iface *iface_from_xf_ifidx(const struct bridge *,
252                                          uint16_t xf_ifidx);
253 static bool iface_is_internal(const struct bridge *, const char *name);
254 static void iface_set_mac(struct iface *);
255 static void iface_update_qos(struct iface *, const struct ovsrec_qos *);
256
257 /* Hooks into ofproto processing. */
258 static struct ofhooks bridge_ofhooks;
259 \f
260 /* Public functions. */
261
262 /* Initializes the bridge module, configuring it to obtain its configuration
263  * from an OVSDB server accessed over 'remote', which should be a string in a
264  * form acceptable to ovsdb_idl_create(). */
265 void
266 bridge_init(const char *remote)
267 {
268     /* Create connection to database. */
269     idl = ovsdb_idl_create(remote, &ovsrec_idl_class);
270
271     /* Register unixctl commands. */
272     unixctl_command_register("fdb/show", bridge_unixctl_fdb_show, NULL);
273     unixctl_command_register("bridge/dump-flows", bridge_unixctl_dump_flows,
274                              NULL);
275     unixctl_command_register("bridge/reconnect", bridge_unixctl_reconnect,
276                              NULL);
277     bond_init();
278 }
279
280 /* Performs configuration that is only necessary once at ovs-vswitchd startup,
281  * but for which the ovs-vswitchd configuration 'cfg' is required. */
282 static void
283 bridge_configure_once(const struct ovsrec_open_vswitch *cfg)
284 {
285     static bool already_configured_once;
286     struct svec bridge_names;
287     struct svec xfif_names, xfif_types;
288     size_t i;
289
290     /* Only do this once per ovs-vswitchd run. */
291     if (already_configured_once) {
292         return;
293     }
294     already_configured_once = true;
295
296     iface_stats_timer = time_msec() + IFACE_STATS_INTERVAL;
297
298     /* Get all the configured bridges' names from 'cfg' into 'bridge_names'. */
299     svec_init(&bridge_names);
300     for (i = 0; i < cfg->n_bridges; i++) {
301         svec_add(&bridge_names, cfg->bridges[i]->name);
302     }
303     svec_sort(&bridge_names);
304
305     /* Iterate over all system xfifs and delete any of them that do not appear
306      * in 'cfg'. */
307     svec_init(&xfif_names);
308     svec_init(&xfif_types);
309     xf_enumerate_types(&xfif_types);
310     for (i = 0; i < xfif_types.n; i++) {
311         struct xfif *xfif;
312         int retval;
313         size_t j;
314
315         xf_enumerate_names(xfif_types.names[i], &xfif_names);
316
317         /* For each xfif... */
318         for (j = 0; j < xfif_names.n; j++) {
319             retval = xfif_open(xfif_names.names[j], xfif_types.names[i], &xfif);
320             if (!retval) {
321                 struct svec all_names;
322                 size_t k;
323
324                 /* ...check whether any of its names is in 'bridge_names'. */
325                 svec_init(&all_names);
326                 xfif_get_all_names(xfif, &all_names);
327                 for (k = 0; k < all_names.n; k++) {
328                     if (svec_contains(&bridge_names, all_names.names[k])) {
329                         goto found;
330                     }
331                 }
332
333                 /* No.  Delete the xfif. */
334                 xfif_delete(xfif);
335
336             found:
337                 svec_destroy(&all_names);
338                 xfif_close(xfif);
339             }
340         }
341     }
342     svec_destroy(&bridge_names);
343     svec_destroy(&xfif_names);
344     svec_destroy(&xfif_types);
345 }
346
347 /* Attempt to create the network device 'iface_name' through the netdev
348  * library. */
349 static int
350 set_up_iface(const struct ovsrec_interface *iface_cfg, struct iface *iface,
351              bool create)
352 {
353     struct shash options;
354     int error = 0;
355     size_t i;
356
357     shash_init(&options);
358     for (i = 0; i < iface_cfg->n_options; i++) {
359         shash_add(&options, iface_cfg->key_options[i],
360                   xstrdup(iface_cfg->value_options[i]));
361     }
362
363     if (create) {
364         struct netdev_options netdev_options;
365
366         memset(&netdev_options, 0, sizeof netdev_options);
367         netdev_options.name = iface_cfg->name;
368         if (!strcmp(iface_cfg->type, "internal")) {
369             /* An "internal" config type maps to a netdev "system" type. */
370             netdev_options.type = "system";
371         } else {
372             netdev_options.type = iface_cfg->type;
373         }
374         netdev_options.args = &options;
375         netdev_options.ethertype = NETDEV_ETH_TYPE_NONE;
376         error = netdev_open(&netdev_options, &iface->netdev);
377
378         if (iface->netdev) {
379             netdev_get_carrier(iface->netdev, &iface->enabled);
380         }
381     } else if (iface->netdev) {
382         const char *netdev_type = netdev_get_type(iface->netdev);
383         const char *iface_type = iface_cfg->type && strlen(iface_cfg->type)
384                                   ? iface_cfg->type : NULL;
385
386         /* An "internal" config type maps to a netdev "system" type. */
387         if (iface_type && !strcmp(iface_type, "internal")) {
388             iface_type = "system";
389         }
390
391         if (!iface_type || !strcmp(netdev_type, iface_type)) {
392             error = netdev_reconfigure(iface->netdev, &options);
393         } else {
394             VLOG_WARN("%s: attempting change device type from %s to %s",
395                       iface_cfg->name, netdev_type, iface_type);
396             error = EINVAL;
397         }
398     }
399     shash_destroy_free_data(&options);
400
401     return error;
402 }
403
404 static int
405 reconfigure_iface(const struct ovsrec_interface *iface_cfg, struct iface *iface)
406 {
407     return set_up_iface(iface_cfg, iface, false);
408 }
409
410 static bool
411 check_iface_netdev(struct bridge *br OVS_UNUSED, struct iface *iface,
412                    void *aux OVS_UNUSED)
413 {
414     if (!iface->netdev) {
415         int error = set_up_iface(iface->cfg, iface, true);
416         if (error) {
417             VLOG_WARN("could not open netdev on %s, dropping: %s", iface->name,
418                                                                strerror(error));
419             return false;
420         }
421     }
422
423     return true;
424 }
425
426 static bool
427 check_iface_xf_ifidx(struct bridge *br, struct iface *iface,
428                      void *aux OVS_UNUSED)
429 {
430     if (iface->xf_ifidx >= 0) {
431         VLOG_DBG("%s has interface %s on port %d",
432                  xfif_name(br->xfif),
433                  iface->name, iface->xf_ifidx);
434         return true;
435     } else {
436         VLOG_ERR("%s interface not in %s, dropping",
437                  iface->name, xfif_name(br->xfif));
438         return false;
439     }
440 }
441
442 static bool
443 set_iface_properties(struct bridge *br OVS_UNUSED, struct iface *iface,
444                      void *aux OVS_UNUSED)
445 {
446     /* Set policing attributes. */
447     netdev_set_policing(iface->netdev,
448                         iface->cfg->ingress_policing_rate,
449                         iface->cfg->ingress_policing_burst);
450
451     /* Set MAC address of internal interfaces other than the local
452      * interface. */
453     if (iface->xf_ifidx != XFLOWP_LOCAL
454         && iface_is_internal(br, iface->name)) {
455         iface_set_mac(iface);
456     }
457
458     return true;
459 }
460
461 /* Calls 'cb' for each interfaces in 'br', passing along the 'aux' argument.
462  * Deletes from 'br' all the interfaces for which 'cb' returns false, and then
463  * deletes from 'br' any ports that no longer have any interfaces. */
464 static void
465 iterate_and_prune_ifaces(struct bridge *br,
466                          bool (*cb)(struct bridge *, struct iface *,
467                                     void *aux),
468                          void *aux)
469 {
470     size_t i, j;
471
472     for (i = 0; i < br->n_ports; ) {
473         struct port *port = br->ports[i];
474         for (j = 0; j < port->n_ifaces; ) {
475             struct iface *iface = port->ifaces[j];
476             if (cb(br, iface, aux)) {
477                 j++;
478             } else {
479                 iface_destroy(iface);
480             }
481         }
482
483         if (port->n_ifaces) {
484             i++;
485         } else  {
486             VLOG_ERR("%s port has no interfaces, dropping", port->name);
487             port_destroy(port);
488         }
489     }
490 }
491
492 /* Looks at the list of managers in 'ovs_cfg' and extracts their remote IP
493  * addresses and ports into '*managersp' and '*n_managersp'.  The caller is
494  * responsible for freeing '*managersp' (with free()).
495  *
496  * You may be asking yourself "why does ovs-vswitchd care?", because
497  * ovsdb-server is responsible for connecting to the managers, and ovs-vswitchd
498  * should not be and in fact is not directly involved in that.  But
499  * ovs-vswitchd needs to make sure that ovsdb-server can reach the managers, so
500  * it has to tell in-band control where the managers are to enable that.
501  */
502 static void
503 collect_managers(const struct ovsrec_open_vswitch *ovs_cfg,
504                  struct sockaddr_in **managersp, size_t *n_managersp)
505 {
506     struct sockaddr_in *managers = NULL;
507     size_t n_managers = 0;
508
509     if (ovs_cfg->n_managers > 0) {
510         size_t i;
511
512         managers = xmalloc(ovs_cfg->n_managers * sizeof *managers);
513         for (i = 0; i < ovs_cfg->n_managers; i++) {
514             const char *name = ovs_cfg->managers[i];
515             struct sockaddr_in *sin = &managers[i];
516
517             if ((!strncmp(name, "tcp:", 4)
518                  && inet_parse_active(name + 4, JSONRPC_TCP_PORT, sin)) ||
519                 (!strncmp(name, "ssl:", 4)
520                  && inet_parse_active(name + 4, JSONRPC_SSL_PORT, sin))) {
521                 n_managers++;
522             }
523         }
524     }
525
526     *managersp = managers;
527     *n_managersp = n_managers;
528 }
529
530 static void
531 bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
532 {
533     struct shash old_br, new_br;
534     struct shash_node *node;
535     struct bridge *br, *next;
536     struct sockaddr_in *managers;
537     size_t n_managers;
538     size_t i;
539     int sflow_bridge_number;
540
541     COVERAGE_INC(bridge_reconfigure);
542
543     collect_managers(ovs_cfg, &managers, &n_managers);
544
545     /* Collect old and new bridges. */
546     shash_init(&old_br);
547     shash_init(&new_br);
548     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
549         shash_add(&old_br, br->name, br);
550     }
551     for (i = 0; i < ovs_cfg->n_bridges; i++) {
552         const struct ovsrec_bridge *br_cfg = ovs_cfg->bridges[i];
553         if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) {
554             VLOG_WARN("more than one bridge named %s", br_cfg->name);
555         }
556     }
557
558     /* Get rid of deleted bridges and add new bridges. */
559     LIST_FOR_EACH_SAFE (br, next, struct bridge, node, &all_bridges) {
560         struct ovsrec_bridge *br_cfg = shash_find_data(&new_br, br->name);
561         if (br_cfg) {
562             br->cfg = br_cfg;
563         } else {
564             bridge_destroy(br);
565         }
566     }
567     SHASH_FOR_EACH (node, &new_br) {
568         const char *br_name = node->name;
569         const struct ovsrec_bridge *br_cfg = node->data;
570         br = shash_find_data(&old_br, br_name);
571         if (br) {
572             /* If the bridge datapath type has changed, we need to tear it
573              * down and recreate. */
574             if (strcmp(br->cfg->datapath_type, br_cfg->datapath_type)) {
575                 bridge_destroy(br);
576                 bridge_create(br_cfg);
577             }
578         } else {
579             bridge_create(br_cfg);
580         }
581     }
582     shash_destroy(&old_br);
583     shash_destroy(&new_br);
584
585     /* Reconfigure all bridges. */
586     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
587         bridge_reconfigure_one(br);
588     }
589
590     /* Add and delete ports on all datapaths.
591      *
592      * The kernel will reject any attempt to add a given port to a datapath if
593      * that port already belongs to a different datapath, so we must do all
594      * port deletions before any port additions. */
595     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
596         struct xflow_port *xfif_ports;
597         size_t n_xfif_ports;
598         struct shash want_ifaces;
599
600         xfif_port_list(br->xfif, &xfif_ports, &n_xfif_ports);
601         bridge_get_all_ifaces(br, &want_ifaces);
602         for (i = 0; i < n_xfif_ports; i++) {
603             const struct xflow_port *p = &xfif_ports[i];
604             if (!shash_find(&want_ifaces, p->devname)
605                 && strcmp(p->devname, br->name)) {
606                 int retval = xfif_port_del(br->xfif, p->port);
607                 if (retval) {
608                     VLOG_ERR("failed to remove %s interface from %s: %s",
609                              p->devname, xfif_name(br->xfif),
610                              strerror(retval));
611                 }
612             }
613         }
614         shash_destroy(&want_ifaces);
615         free(xfif_ports);
616     }
617     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
618         struct xflow_port *xfif_ports;
619         size_t n_xfif_ports;
620         struct shash cur_ifaces, want_ifaces;
621         struct shash_node *node;
622
623         /* Get the set of interfaces currently in this datapath. */
624         xfif_port_list(br->xfif, &xfif_ports, &n_xfif_ports);
625         shash_init(&cur_ifaces);
626         for (i = 0; i < n_xfif_ports; i++) {
627             const char *name = xfif_ports[i].devname;
628             shash_add_once(&cur_ifaces, name, NULL);
629         }
630         free(xfif_ports);
631
632         /* Get the set of interfaces we want on this datapath. */
633         bridge_get_all_ifaces(br, &want_ifaces);
634
635         SHASH_FOR_EACH (node, &want_ifaces) {
636             const char *if_name = node->name;
637             struct iface *iface = node->data;
638
639             if (shash_find(&cur_ifaces, if_name)) {
640                 /* Already exists, just reconfigure it. */
641                 if (iface) {
642                     reconfigure_iface(iface->cfg, iface);
643                 }
644             } else {
645                 /* Need to add to datapath. */
646                 bool internal;
647                 int error;
648
649                 /* Add to datapath. */
650                 internal = iface_is_internal(br, if_name);
651                 error = xfif_port_add(br->xfif, if_name,
652                                       internal ? XFLOW_PORT_INTERNAL : 0, NULL);
653                 if (error == EFBIG) {
654                     VLOG_ERR("ran out of valid port numbers on %s",
655                              xfif_name(br->xfif));
656                     break;
657                 } else if (error) {
658                     VLOG_ERR("failed to add %s interface to %s: %s",
659                              if_name, xfif_name(br->xfif), strerror(error));
660                 }
661             }
662         }
663         shash_destroy(&cur_ifaces);
664         shash_destroy(&want_ifaces);
665     }
666     sflow_bridge_number = 0;
667     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
668         uint8_t ea[8];
669         uint64_t dpid;
670         struct iface *local_iface;
671         struct iface *hw_addr_iface;
672         char *dpid_string;
673
674         bridge_fetch_dp_ifaces(br);
675
676         iterate_and_prune_ifaces(br, check_iface_netdev, NULL);
677         iterate_and_prune_ifaces(br, check_iface_xf_ifidx, NULL);
678
679         /* Pick local port hardware address, datapath ID. */
680         bridge_pick_local_hw_addr(br, ea, &hw_addr_iface);
681         local_iface = bridge_get_local_iface(br);
682         if (local_iface) {
683             int error = netdev_set_etheraddr(local_iface->netdev, ea);
684             if (error) {
685                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
686                 VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
687                             "Ethernet address: %s",
688                             br->name, strerror(error));
689             }
690         }
691
692         dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface);
693         ofproto_set_datapath_id(br->ofproto, dpid);
694
695         dpid_string = xasprintf("%016"PRIx64, dpid);
696         ovsrec_bridge_set_datapath_id(br->cfg, dpid_string);
697         free(dpid_string);
698
699         /* Set NetFlow configuration on this bridge. */
700         if (br->cfg->netflow) {
701             struct ovsrec_netflow *nf_cfg = br->cfg->netflow;
702             struct netflow_options opts;
703
704             memset(&opts, 0, sizeof opts);
705
706             xfif_get_netflow_ids(br->xfif, &opts.engine_type, &opts.engine_id);
707             if (nf_cfg->engine_type) {
708                 opts.engine_type = *nf_cfg->engine_type;
709             }
710             if (nf_cfg->engine_id) {
711                 opts.engine_id = *nf_cfg->engine_id;
712             }
713
714             opts.active_timeout = nf_cfg->active_timeout;
715             if (!opts.active_timeout) {
716                 opts.active_timeout = -1;
717             } else if (opts.active_timeout < 0) {
718                 VLOG_WARN("bridge %s: active timeout interval set to negative "
719                           "value, using default instead (%d seconds)", br->name,
720                           NF_ACTIVE_TIMEOUT_DEFAULT);
721                 opts.active_timeout = -1;
722             }
723
724             opts.add_id_to_iface = nf_cfg->add_id_to_interface;
725             if (opts.add_id_to_iface) {
726                 if (opts.engine_id > 0x7f) {
727                     VLOG_WARN("bridge %s: netflow port mangling may conflict "
728                               "with another vswitch, choose an engine id less "
729                               "than 128", br->name);
730                 }
731                 if (br->n_ports > 508) {
732                     VLOG_WARN("bridge %s: netflow port mangling will conflict "
733                               "with another port when more than 508 ports are "
734                               "used", br->name);
735                 }
736             }
737
738             opts.collectors.n = nf_cfg->n_targets;
739             opts.collectors.names = nf_cfg->targets;
740             if (ofproto_set_netflow(br->ofproto, &opts)) {
741                 VLOG_ERR("bridge %s: problem setting netflow collectors", 
742                          br->name);
743             }
744         } else {
745             ofproto_set_netflow(br->ofproto, NULL);
746         }
747
748         /* Set sFlow configuration on this bridge. */
749         if (br->cfg->sflow) {
750             const struct ovsrec_sflow *sflow_cfg = br->cfg->sflow;
751             struct ovsrec_controller **controllers;
752             struct ofproto_sflow_options oso;
753             size_t n_controllers;
754             size_t i;
755
756             memset(&oso, 0, sizeof oso);
757
758             oso.targets.n = sflow_cfg->n_targets;
759             oso.targets.names = sflow_cfg->targets;
760
761             oso.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
762             if (sflow_cfg->sampling) {
763                 oso.sampling_rate = *sflow_cfg->sampling;
764             }
765
766             oso.polling_interval = SFL_DEFAULT_POLLING_INTERVAL;
767             if (sflow_cfg->polling) {
768                 oso.polling_interval = *sflow_cfg->polling;
769             }
770
771             oso.header_len = SFL_DEFAULT_HEADER_SIZE;
772             if (sflow_cfg->header) {
773                 oso.header_len = *sflow_cfg->header;
774             }
775
776             oso.sub_id = sflow_bridge_number++;
777             oso.agent_device = sflow_cfg->agent;
778
779             oso.control_ip = NULL;
780             n_controllers = bridge_get_controllers(br, &controllers);
781             for (i = 0; i < n_controllers; i++) {
782                 if (controllers[i]->local_ip) {
783                     oso.control_ip = controllers[i]->local_ip;
784                     break;
785                 }
786             }
787             ofproto_set_sflow(br->ofproto, &oso);
788
789             /* Do not destroy oso.targets because it is owned by sflow_cfg. */
790         } else {
791             ofproto_set_sflow(br->ofproto, NULL);
792         }
793
794         /* Update the controller and related settings.  It would be more
795          * straightforward to call this from bridge_reconfigure_one(), but we
796          * can't do it there for two reasons.  First, and most importantly, at
797          * that point we don't know the xf_ifidx of any interfaces that have
798          * been added to the bridge (because we haven't actually added them to
799          * the datapath).  Second, at that point we haven't set the datapath ID
800          * yet; when a controller is configured, resetting the datapath ID will
801          * immediately disconnect from the controller, so it's better to set
802          * the datapath ID before the controller. */
803         bridge_reconfigure_remotes(br, managers, n_managers);
804     }
805     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
806         for (i = 0; i < br->n_ports; i++) {
807             struct port *port = br->ports[i];
808             int j;
809
810             port_update_vlan_compat(port);
811             port_update_bonding(port);
812
813             for (j = 0; j < port->n_ifaces; j++) {
814                 iface_update_qos(port->ifaces[j], port->cfg->qos);
815             }
816         }
817     }
818     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
819         iterate_and_prune_ifaces(br, set_iface_properties, NULL);
820     }
821
822     free(managers);
823 }
824
825 static const char *
826 get_ovsrec_key_value(const struct ovsdb_idl_row *row,
827                      const struct ovsdb_idl_column *column,
828                      const char *key)
829 {
830     const struct ovsdb_datum *datum;
831     union ovsdb_atom atom;
832     unsigned int idx;
833
834     datum = ovsdb_idl_get(row, column, OVSDB_TYPE_STRING, OVSDB_TYPE_STRING);
835     atom.string = (char *) key;
836     idx = ovsdb_datum_find_key(datum, &atom, OVSDB_TYPE_STRING);
837     return idx == UINT_MAX ? NULL : datum->values[idx].string;
838 }
839
840 static const char *
841 bridge_get_other_config(const struct ovsrec_bridge *br_cfg, const char *key)
842 {
843     return get_ovsrec_key_value(&br_cfg->header_,
844                                 &ovsrec_bridge_col_other_config, key);
845 }
846
847 static void
848 bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
849                           struct iface **hw_addr_iface)
850 {
851     const char *hwaddr;
852     size_t i, j;
853     int error;
854
855     *hw_addr_iface = NULL;
856
857     /* Did the user request a particular MAC? */
858     hwaddr = bridge_get_other_config(br->cfg, "hwaddr");
859     if (hwaddr && eth_addr_from_string(hwaddr, ea)) {
860         if (eth_addr_is_multicast(ea)) {
861             VLOG_ERR("bridge %s: cannot set MAC address to multicast "
862                      "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
863         } else if (eth_addr_is_zero(ea)) {
864             VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
865         } else {
866             return;
867         }
868     }
869
870     /* Otherwise choose the minimum non-local MAC address among all of the
871      * interfaces. */
872     memset(ea, 0xff, sizeof ea);
873     for (i = 0; i < br->n_ports; i++) {
874         struct port *port = br->ports[i];
875         uint8_t iface_ea[ETH_ADDR_LEN];
876         struct iface *iface;
877
878         /* Mirror output ports don't participate. */
879         if (port->is_mirror_output_port) {
880             continue;
881         }
882
883         /* Choose the MAC address to represent the port. */
884         if (port->cfg->mac && eth_addr_from_string(port->cfg->mac, iface_ea)) {
885             /* Find the interface with this Ethernet address (if any) so that
886              * we can provide the correct devname to the caller. */
887             iface = NULL;
888             for (j = 0; j < port->n_ifaces; j++) {
889                 struct iface *candidate = port->ifaces[j];
890                 uint8_t candidate_ea[ETH_ADDR_LEN];
891                 if (!netdev_get_etheraddr(candidate->netdev, candidate_ea)
892                     && eth_addr_equals(iface_ea, candidate_ea)) {
893                     iface = candidate;
894                 }
895             }
896         } else {
897             /* Choose the interface whose MAC address will represent the port.
898              * The Linux kernel bonding code always chooses the MAC address of
899              * the first slave added to a bond, and the Fedora networking
900              * scripts always add slaves to a bond in alphabetical order, so
901              * for compatibility we choose the interface with the name that is
902              * first in alphabetical order. */
903             iface = port->ifaces[0];
904             for (j = 1; j < port->n_ifaces; j++) {
905                 struct iface *candidate = port->ifaces[j];
906                 if (strcmp(candidate->name, iface->name) < 0) {
907                     iface = candidate;
908                 }
909             }
910
911             /* The local port doesn't count (since we're trying to choose its
912              * MAC address anyway). */
913             if (iface->xf_ifidx == XFLOWP_LOCAL) {
914                 continue;
915             }
916
917             /* Grab MAC. */
918             error = netdev_get_etheraddr(iface->netdev, iface_ea);
919             if (error) {
920                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
921                 VLOG_ERR_RL(&rl, "failed to obtain Ethernet address of %s: %s",
922                             iface->name, strerror(error));
923                 continue;
924             }
925         }
926
927         /* Compare against our current choice. */
928         if (!eth_addr_is_multicast(iface_ea) &&
929             !eth_addr_is_local(iface_ea) &&
930             !eth_addr_is_reserved(iface_ea) &&
931             !eth_addr_is_zero(iface_ea) &&
932             memcmp(iface_ea, ea, ETH_ADDR_LEN) < 0)
933         {
934             memcpy(ea, iface_ea, ETH_ADDR_LEN);
935             *hw_addr_iface = iface;
936         }
937     }
938     if (eth_addr_is_multicast(ea)) {
939         memcpy(ea, br->default_ea, ETH_ADDR_LEN);
940         *hw_addr_iface = NULL;
941         VLOG_WARN("bridge %s: using default bridge Ethernet "
942                   "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
943     } else {
944         VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT,
945                  br->name, ETH_ADDR_ARGS(ea));
946     }
947 }
948
949 /* Choose and returns the datapath ID for bridge 'br' given that the bridge
950  * Ethernet address is 'bridge_ea'.  If 'bridge_ea' is the Ethernet address of
951  * an interface on 'br', then that interface must be passed in as
952  * 'hw_addr_iface'; if 'bridge_ea' was derived some other way, then
953  * 'hw_addr_iface' must be passed in as a null pointer. */
954 static uint64_t
955 bridge_pick_datapath_id(struct bridge *br,
956                         const uint8_t bridge_ea[ETH_ADDR_LEN],
957                         struct iface *hw_addr_iface)
958 {
959     /*
960      * The procedure for choosing a bridge MAC address will, in the most
961      * ordinary case, also choose a unique MAC that we can use as a datapath
962      * ID.  In some special cases, though, multiple bridges will end up with
963      * the same MAC address.  This is OK for the bridges, but it will confuse
964      * the OpenFlow controller, because each datapath needs a unique datapath
965      * ID.
966      *
967      * Datapath IDs must be unique.  It is also very desirable that they be
968      * stable from one run to the next, so that policy set on a datapath
969      * "sticks".
970      */
971     const char *datapath_id;
972     uint64_t dpid;
973
974     datapath_id = bridge_get_other_config(br->cfg, "datapath-id");
975     if (datapath_id && dpid_from_string(datapath_id, &dpid)) {
976         return dpid;
977     }
978
979     if (hw_addr_iface) {
980         int vlan;
981         if (!netdev_get_vlan_vid(hw_addr_iface->netdev, &vlan)) {
982             /*
983              * A bridge whose MAC address is taken from a VLAN network device
984              * (that is, a network device created with vconfig(8) or similar
985              * tool) will have the same MAC address as a bridge on the VLAN
986              * device's physical network device.
987              *
988              * Handle this case by hashing the physical network device MAC
989              * along with the VLAN identifier.
990              */
991             uint8_t buf[ETH_ADDR_LEN + 2];
992             memcpy(buf, bridge_ea, ETH_ADDR_LEN);
993             buf[ETH_ADDR_LEN] = vlan >> 8;
994             buf[ETH_ADDR_LEN + 1] = vlan;
995             return dpid_from_hash(buf, sizeof buf);
996         } else {
997             /*
998              * Assume that this bridge's MAC address is unique, since it
999              * doesn't fit any of the cases we handle specially.
1000              */
1001         }
1002     } else {
1003         /*
1004          * A purely internal bridge, that is, one that has no non-virtual
1005          * network devices on it at all, is more difficult because it has no
1006          * natural unique identifier at all.
1007          *
1008          * When the host is a XenServer, we handle this case by hashing the
1009          * host's UUID with the name of the bridge.  Names of bridges are
1010          * persistent across XenServer reboots, although they can be reused if
1011          * an internal network is destroyed and then a new one is later
1012          * created, so this is fairly effective.
1013          *
1014          * When the host is not a XenServer, we punt by using a random MAC
1015          * address on each run.
1016          */
1017         const char *host_uuid = xenserver_get_host_uuid();
1018         if (host_uuid) {
1019             char *combined = xasprintf("%s,%s", host_uuid, br->name);
1020             dpid = dpid_from_hash(combined, strlen(combined));
1021             free(combined);
1022             return dpid;
1023         }
1024     }
1025
1026     return eth_addr_to_uint64(bridge_ea);
1027 }
1028
1029 static uint64_t
1030 dpid_from_hash(const void *data, size_t n)
1031 {
1032     uint8_t hash[SHA1_DIGEST_SIZE];
1033
1034     BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN);
1035     sha1_bytes(data, n, hash);
1036     eth_addr_mark_random(hash);
1037     return eth_addr_to_uint64(hash);
1038 }
1039
1040 static void
1041 iface_refresh_stats(struct iface *iface)
1042 {
1043     struct iface_stat {
1044         char *name;
1045         int offset;
1046     };
1047     static const struct iface_stat iface_stats[] = {
1048         { "rx_packets", offsetof(struct netdev_stats, rx_packets) },
1049         { "tx_packets", offsetof(struct netdev_stats, tx_packets) },
1050         { "rx_bytes", offsetof(struct netdev_stats, rx_bytes) },
1051         { "tx_bytes", offsetof(struct netdev_stats, tx_bytes) },
1052         { "rx_dropped", offsetof(struct netdev_stats, rx_dropped) },
1053         { "tx_dropped", offsetof(struct netdev_stats, tx_dropped) },
1054         { "rx_errors", offsetof(struct netdev_stats, rx_errors) },
1055         { "tx_errors", offsetof(struct netdev_stats, tx_errors) },
1056         { "rx_frame_err", offsetof(struct netdev_stats, rx_frame_errors) },
1057         { "rx_over_err", offsetof(struct netdev_stats, rx_over_errors) },
1058         { "rx_crc_err", offsetof(struct netdev_stats, rx_crc_errors) },
1059         { "collisions", offsetof(struct netdev_stats, collisions) },
1060     };
1061     enum { N_STATS = ARRAY_SIZE(iface_stats) };
1062     const struct iface_stat *s;
1063
1064     char *keys[N_STATS];
1065     int64_t values[N_STATS];
1066     int n;
1067
1068     struct netdev_stats stats;
1069
1070     /* Intentionally ignore return value, since errors will set 'stats' to
1071      * all-1s, and we will deal with that correctly below. */
1072     netdev_get_stats(iface->netdev, &stats);
1073
1074     n = 0;
1075     for (s = iface_stats; s < &iface_stats[N_STATS]; s++) {
1076         uint64_t value = *(uint64_t *) (((char *) &stats) + s->offset);
1077         if (value != UINT64_MAX) {
1078             keys[n] = s->name;
1079             values[n] = value;
1080             n++;
1081         }
1082     }
1083
1084     ovsrec_interface_set_statistics(iface->cfg, keys, values, n);
1085 }
1086
1087 void
1088 bridge_run(void)
1089 {
1090     const struct ovsrec_open_vswitch *cfg;
1091
1092     bool datapath_destroyed;
1093     bool database_changed;
1094     struct bridge *br;
1095
1096     /* Let each bridge do the work that it needs to do. */
1097     datapath_destroyed = false;
1098     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1099         int error = bridge_run_one(br);
1100         if (error) {
1101             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1102             VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, "
1103                         "forcing reconfiguration", br->name);
1104             datapath_destroyed = true;
1105         }
1106     }
1107
1108     /* (Re)configure if necessary. */
1109     database_changed = ovsdb_idl_run(idl);
1110     cfg = ovsrec_open_vswitch_first(idl);
1111     if (database_changed || datapath_destroyed) {
1112         if (cfg) {
1113             struct ovsdb_idl_txn *txn = ovsdb_idl_txn_create(idl);
1114
1115             bridge_configure_once(cfg);
1116             bridge_reconfigure(cfg);
1117
1118             ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg);
1119             ovsdb_idl_txn_commit(txn);
1120             ovsdb_idl_txn_destroy(txn); /* XXX */
1121         } else {
1122             /* We still need to reconfigure to avoid dangling pointers to
1123              * now-destroyed ovsrec structures inside bridge data. */
1124             static const struct ovsrec_open_vswitch null_cfg;
1125
1126             bridge_reconfigure(&null_cfg);
1127         }
1128     }
1129
1130 #ifdef HAVE_OPENSSL
1131     /* Re-configure SSL.  We do this on every trip through the main loop,
1132      * instead of just when the database changes, because the contents of the
1133      * key and certificate files can change without the database changing. */
1134     if (cfg && cfg->ssl) {
1135         const struct ovsrec_ssl *ssl = cfg->ssl;
1136
1137         stream_ssl_set_key_and_cert(ssl->private_key, ssl->certificate);
1138         stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert);
1139     }
1140 #endif
1141
1142     /* Refresh interface stats if necessary. */
1143     if (time_msec() >= iface_stats_timer) {
1144         struct ovsdb_idl_txn *txn;
1145
1146         txn = ovsdb_idl_txn_create(idl);
1147         LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1148             size_t i;
1149
1150             for (i = 0; i < br->n_ports; i++) {
1151                 struct port *port = br->ports[i];
1152                 size_t j;
1153
1154                 for (j = 0; j < port->n_ifaces; j++) {
1155                     struct iface *iface = port->ifaces[j];
1156                     iface_refresh_stats(iface);
1157                 }
1158             }
1159         }
1160         ovsdb_idl_txn_commit(txn);
1161         ovsdb_idl_txn_destroy(txn); /* XXX */
1162
1163         iface_stats_timer = time_msec() + IFACE_STATS_INTERVAL;
1164     }
1165 }
1166
1167 void
1168 bridge_wait(void)
1169 {
1170     struct bridge *br;
1171
1172     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1173         ofproto_wait(br->ofproto);
1174         if (ofproto_has_primary_controller(br->ofproto)) {
1175             continue;
1176         }
1177
1178         mac_learning_wait(br->ml);
1179         bond_wait(br);
1180     }
1181     ovsdb_idl_wait(idl);
1182     poll_timer_wait_until(iface_stats_timer);
1183 }
1184
1185 /* Forces 'br' to revalidate all of its flows.  This is appropriate when 'br''s
1186  * configuration changes.  */
1187 static void
1188 bridge_flush(struct bridge *br)
1189 {
1190     COVERAGE_INC(bridge_flush);
1191     ofproto_revalidate_all(br->ofproto);
1192     mac_learning_flush(br->ml);
1193 }
1194
1195 /* Returns the 'br' interface for the XFLOWP_LOCAL port, or null if 'br' has no
1196  * such interface. */
1197 static struct iface *
1198 bridge_get_local_iface(struct bridge *br)
1199 {
1200     size_t i, j;
1201
1202     for (i = 0; i < br->n_ports; i++) {
1203         struct port *port = br->ports[i];
1204         for (j = 0; j < port->n_ifaces; j++) {
1205             struct iface *iface = port->ifaces[j];
1206             if (iface->xf_ifidx == XFLOWP_LOCAL) {
1207                 return iface;
1208             }
1209         }
1210     }
1211
1212     return NULL;
1213 }
1214 \f
1215 /* Bridge unixctl user interface functions. */
1216 static void
1217 bridge_unixctl_fdb_show(struct unixctl_conn *conn,
1218                         const char *args, void *aux OVS_UNUSED)
1219 {
1220     struct ds ds = DS_EMPTY_INITIALIZER;
1221     const struct bridge *br;
1222     const struct mac_entry *e;
1223
1224     br = bridge_lookup(args);
1225     if (!br) {
1226         unixctl_command_reply(conn, 501, "no such bridge");
1227         return;
1228     }
1229
1230     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
1231     LIST_FOR_EACH (e, struct mac_entry, lru_node, &br->ml->lrus) {
1232         if (e->port < 0 || e->port >= br->n_ports) {
1233             continue;
1234         }
1235         ds_put_format(&ds, "%5d  %4d  "ETH_ADDR_FMT"  %3d\n",
1236                       br->ports[e->port]->ifaces[0]->xf_ifidx,
1237                       e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
1238     }
1239     unixctl_command_reply(conn, 200, ds_cstr(&ds));
1240     ds_destroy(&ds);
1241 }
1242 \f
1243 /* Bridge reconfiguration functions. */
1244 static struct bridge *
1245 bridge_create(const struct ovsrec_bridge *br_cfg)
1246 {
1247     struct bridge *br;
1248     int error;
1249
1250     assert(!bridge_lookup(br_cfg->name));
1251     br = xzalloc(sizeof *br);
1252
1253     error = xfif_create_and_open(br_cfg->name, br_cfg->datapath_type,
1254                                  &br->xfif);
1255     if (error) {
1256         free(br);
1257         return NULL;
1258     }
1259     xfif_flow_flush(br->xfif);
1260
1261     error = ofproto_create(br_cfg->name, br_cfg->datapath_type, &bridge_ofhooks,
1262                            br, &br->ofproto);
1263     if (error) {
1264         VLOG_ERR("failed to create switch %s: %s", br_cfg->name,
1265                  strerror(error));
1266         xfif_delete(br->xfif);
1267         xfif_close(br->xfif);
1268         free(br);
1269         return NULL;
1270     }
1271
1272     br->name = xstrdup(br_cfg->name);
1273     br->cfg = br_cfg;
1274     br->ml = mac_learning_create();
1275     eth_addr_nicira_random(br->default_ea);
1276
1277     port_array_init(&br->ifaces);
1278
1279     shash_init(&br->port_by_name);
1280     shash_init(&br->iface_by_name);
1281
1282     list_push_back(&all_bridges, &br->node);
1283
1284     VLOG_INFO("created bridge %s on %s", br->name, xfif_name(br->xfif));
1285
1286     return br;
1287 }
1288
1289 static void
1290 bridge_destroy(struct bridge *br)
1291 {
1292     if (br) {
1293         int error;
1294
1295         while (br->n_ports > 0) {
1296             port_destroy(br->ports[br->n_ports - 1]);
1297         }
1298         list_remove(&br->node);
1299         error = xfif_delete(br->xfif);
1300         if (error && error != ENOENT) {
1301             VLOG_ERR("failed to delete %s: %s",
1302                      xfif_name(br->xfif), strerror(error));
1303         }
1304         xfif_close(br->xfif);
1305         ofproto_destroy(br->ofproto);
1306         mac_learning_destroy(br->ml);
1307         port_array_destroy(&br->ifaces);
1308         shash_destroy(&br->port_by_name);
1309         shash_destroy(&br->iface_by_name);
1310         free(br->ports);
1311         free(br->name);
1312         free(br);
1313     }
1314 }
1315
1316 static struct bridge *
1317 bridge_lookup(const char *name)
1318 {
1319     struct bridge *br;
1320
1321     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1322         if (!strcmp(br->name, name)) {
1323             return br;
1324         }
1325     }
1326     return NULL;
1327 }
1328
1329 /* Handle requests for a listing of all flows known by the OpenFlow
1330  * stack, including those normally hidden. */
1331 static void
1332 bridge_unixctl_dump_flows(struct unixctl_conn *conn,
1333                           const char *args, void *aux OVS_UNUSED)
1334 {
1335     struct bridge *br;
1336     struct ds results;
1337     
1338     br = bridge_lookup(args);
1339     if (!br) {
1340         unixctl_command_reply(conn, 501, "Unknown bridge");
1341         return;
1342     }
1343
1344     ds_init(&results);
1345     ofproto_get_all_flows(br->ofproto, &results);
1346
1347     unixctl_command_reply(conn, 200, ds_cstr(&results));
1348     ds_destroy(&results);
1349 }
1350
1351 /* "bridge/reconnect [BRIDGE]": makes BRIDGE drop all of its controller
1352  * connections and reconnect.  If BRIDGE is not specified, then all bridges
1353  * drop their controller connections and reconnect. */
1354 static void
1355 bridge_unixctl_reconnect(struct unixctl_conn *conn,
1356                          const char *args, void *aux OVS_UNUSED)
1357 {
1358     struct bridge *br;
1359     if (args[0] != '\0') {
1360         br = bridge_lookup(args);
1361         if (!br) {
1362             unixctl_command_reply(conn, 501, "Unknown bridge");
1363             return;
1364         }
1365         ofproto_reconnect_controllers(br->ofproto);
1366     } else {
1367         LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
1368             ofproto_reconnect_controllers(br->ofproto);
1369         }
1370     }
1371     unixctl_command_reply(conn, 200, NULL);
1372 }
1373
1374 static int
1375 bridge_run_one(struct bridge *br)
1376 {
1377     ofproto_revalidate(br->ofproto, mac_learning_run(br->ml));
1378     bond_run(br);
1379     return ofproto_run(br->ofproto);
1380 }
1381
1382 static size_t
1383 bridge_get_controllers(const struct bridge *br,
1384                        struct ovsrec_controller ***controllersp)
1385 {
1386     struct ovsrec_controller **controllers;
1387     size_t n_controllers;
1388
1389     controllers = br->cfg->controller;
1390     n_controllers = br->cfg->n_controller;
1391
1392     if (n_controllers == 1 && !strcmp(controllers[0]->target, "none")) {
1393         controllers = NULL;
1394         n_controllers = 0;
1395     }
1396
1397     if (controllersp) {
1398         *controllersp = controllers;
1399     }
1400     return n_controllers;
1401 }
1402
1403 static void
1404 bridge_reconfigure_one(struct bridge *br)
1405 {
1406     struct shash old_ports, new_ports;
1407     struct svec snoops, old_snoops;
1408     struct shash_node *node;
1409     enum ofproto_fail_mode fail_mode;
1410     size_t i;
1411
1412     /* Collect old ports. */
1413     shash_init(&old_ports);
1414     for (i = 0; i < br->n_ports; i++) {
1415         shash_add(&old_ports, br->ports[i]->name, br->ports[i]);
1416     }
1417
1418     /* Collect new ports. */
1419     shash_init(&new_ports);
1420     for (i = 0; i < br->cfg->n_ports; i++) {
1421         const char *name = br->cfg->ports[i]->name;
1422         if (!shash_add_once(&new_ports, name, br->cfg->ports[i])) {
1423             VLOG_WARN("bridge %s: %s specified twice as bridge port",
1424                       br->name, name);
1425         }
1426     }
1427
1428     /* If we have a controller, then we need a local port.  Complain if the
1429      * user didn't specify one.
1430      *
1431      * XXX perhaps we should synthesize a port ourselves in this case. */
1432     if (bridge_get_controllers(br, NULL)) {
1433         char local_name[IF_NAMESIZE];
1434         int error;
1435
1436         error = xfif_port_get_name(br->xfif, XFLOWP_LOCAL,
1437                                    local_name, sizeof local_name);
1438         if (!error && !shash_find(&new_ports, local_name)) {
1439             VLOG_WARN("bridge %s: controller specified but no local port "
1440                       "(port named %s) defined",
1441                       br->name, local_name);
1442         }
1443     }
1444
1445     /* Get rid of deleted ports.
1446      * Get rid of deleted interfaces on ports that still exist. */
1447     SHASH_FOR_EACH (node, &old_ports) {
1448         struct port *port = node->data;
1449         const struct ovsrec_port *port_cfg;
1450
1451         port_cfg = shash_find_data(&new_ports, node->name);
1452         if (!port_cfg) {
1453             port_destroy(port);
1454         } else {
1455             port_del_ifaces(port, port_cfg);
1456         }
1457     }
1458
1459     /* Create new ports.
1460      * Add new interfaces to existing ports.
1461      * Reconfigure existing ports. */
1462     SHASH_FOR_EACH (node, &new_ports) {
1463         struct port *port = shash_find_data(&old_ports, node->name);
1464         if (!port) {
1465             port = port_create(br, node->name);
1466         }
1467
1468         port_reconfigure(port, node->data);
1469         if (!port->n_ifaces) {
1470             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
1471                       br->name, port->name);
1472             port_destroy(port);
1473         }
1474     }
1475     shash_destroy(&old_ports);
1476     shash_destroy(&new_ports);
1477
1478     /* Set the fail-mode */
1479     fail_mode = !br->cfg->fail_mode
1480                 || !strcmp(br->cfg->fail_mode, "standalone")
1481                     ? OFPROTO_FAIL_STANDALONE
1482                     : OFPROTO_FAIL_SECURE;
1483     if (ofproto_get_fail_mode(br->ofproto) != fail_mode
1484         && !ofproto_has_primary_controller(br->ofproto)) {
1485         ofproto_flush_flows(br->ofproto);
1486     }
1487     ofproto_set_fail_mode(br->ofproto, fail_mode);
1488
1489     /* Delete all flows if we're switching from connected to standalone or vice
1490      * versa.  (XXX Should we delete all flows if we are switching from one
1491      * controller to another?) */
1492
1493     /* Configure OpenFlow controller connection snooping. */
1494     svec_init(&snoops);
1495     svec_add_nocopy(&snoops, xasprintf("punix:%s/%s.snoop",
1496                                        ovs_rundir, br->name));
1497     svec_init(&old_snoops);
1498     ofproto_get_snoops(br->ofproto, &old_snoops);
1499     if (!svec_equal(&snoops, &old_snoops)) {
1500         ofproto_set_snoops(br->ofproto, &snoops);
1501     }
1502     svec_destroy(&snoops);
1503     svec_destroy(&old_snoops);
1504
1505     mirror_reconfigure(br);
1506 }
1507
1508 /* Initializes 'oc' appropriately as a management service controller for
1509  * 'br'.
1510  *
1511  * The caller must free oc->target when it is no longer needed. */
1512 static void
1513 bridge_ofproto_controller_for_mgmt(const struct bridge *br,
1514                                    struct ofproto_controller *oc)
1515 {
1516     oc->target = xasprintf("punix:%s/%s.mgmt", ovs_rundir, br->name);
1517     oc->max_backoff = 0;
1518     oc->probe_interval = 60;
1519     oc->band = OFPROTO_OUT_OF_BAND;
1520     oc->accept_re = NULL;
1521     oc->update_resolv_conf = false;
1522     oc->rate_limit = 0;
1523     oc->burst_limit = 0;
1524 }
1525
1526 /* Converts ovsrec_controller 'c' into an ofproto_controller in 'oc'.  */
1527 static void
1528 bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c,
1529                                       struct ofproto_controller *oc)
1530 {
1531     oc->target = c->target;
1532     oc->max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8;
1533     oc->probe_interval = c->inactivity_probe ? *c->inactivity_probe / 1000 : 5;
1534     oc->band = (!c->connection_mode || !strcmp(c->connection_mode, "in-band")
1535                 ? OFPROTO_IN_BAND : OFPROTO_OUT_OF_BAND);
1536     oc->accept_re = c->discover_accept_regex;
1537     oc->update_resolv_conf = c->discover_update_resolv_conf;
1538     oc->rate_limit = c->controller_rate_limit ? *c->controller_rate_limit : 0;
1539     oc->burst_limit = (c->controller_burst_limit
1540                        ? *c->controller_burst_limit : 0);
1541 }
1542
1543 /* Configures the IP stack for 'br''s local interface properly according to the
1544  * configuration in 'c'.  */
1545 static void
1546 bridge_configure_local_iface_netdev(struct bridge *br,
1547                                     struct ovsrec_controller *c)
1548 {
1549     struct netdev *netdev;
1550     struct in_addr mask, gateway;
1551
1552     struct iface *local_iface;
1553     struct in_addr ip;
1554
1555     /* Controller discovery does its own TCP/IP configuration later. */
1556     if (strcmp(c->target, "discover")) {
1557         return;
1558     }
1559
1560     /* If there's no local interface or no IP address, give up. */
1561     local_iface = bridge_get_local_iface(br);
1562     if (!local_iface || !c->local_ip || !inet_aton(c->local_ip, &ip)) {
1563         return;
1564     }
1565
1566     /* Bring up the local interface. */
1567     netdev = local_iface->netdev;
1568     netdev_turn_flags_on(netdev, NETDEV_UP, true);
1569
1570     /* Configure the IP address and netmask. */
1571     if (!c->local_netmask
1572         || !inet_aton(c->local_netmask, &mask)
1573         || !mask.s_addr) {
1574         mask.s_addr = guess_netmask(ip.s_addr);
1575     }
1576     if (!netdev_set_in4(netdev, ip, mask)) {
1577         VLOG_INFO("bridge %s: configured IP address "IP_FMT", netmask "IP_FMT,
1578                   br->name, IP_ARGS(&ip.s_addr), IP_ARGS(&mask.s_addr));
1579     }
1580
1581     /* Configure the default gateway. */
1582     if (c->local_gateway
1583         && inet_aton(c->local_gateway, &gateway)
1584         && gateway.s_addr) {
1585         if (!netdev_add_router(netdev, gateway)) {
1586             VLOG_INFO("bridge %s: configured gateway "IP_FMT,
1587                       br->name, IP_ARGS(&gateway.s_addr));
1588         }
1589     }
1590 }
1591
1592 static void
1593 bridge_reconfigure_remotes(struct bridge *br,
1594                            const struct sockaddr_in *managers,
1595                            size_t n_managers)
1596 {
1597     struct ovsrec_controller **controllers;
1598     size_t n_controllers;
1599     bool had_primary;
1600
1601     struct ofproto_controller *ocs;
1602     size_t n_ocs;
1603     size_t i;
1604
1605     ofproto_set_extra_in_band_remotes(br->ofproto, managers, n_managers);
1606     had_primary = ofproto_has_primary_controller(br->ofproto);
1607
1608     n_controllers = bridge_get_controllers(br, &controllers);
1609
1610     ocs = xmalloc((n_controllers + 1) * sizeof *ocs);
1611     n_ocs = 0;
1612
1613     bridge_ofproto_controller_for_mgmt(br, &ocs[n_ocs++]);
1614     for (i = 0; i < n_controllers; i++) {
1615         struct ovsrec_controller *c = controllers[i];
1616
1617         if (!strncmp(c->target, "punix:", 6)
1618             || !strncmp(c->target, "unix:", 5)) {
1619             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1620
1621             /* Prevent remote ovsdb-server users from accessing arbitrary Unix
1622              * domain sockets and overwriting arbitrary local files. */
1623             VLOG_ERR_RL(&rl, "%s: not adding Unix domain socket controller "
1624                         "\"%s\" due to possibility for remote exploit",
1625                         br->name, c->target);
1626             continue;
1627         }
1628
1629         bridge_configure_local_iface_netdev(br, c);
1630         bridge_ofproto_controller_from_ovsrec(c, &ocs[n_ocs++]);
1631     }
1632
1633     ofproto_set_controllers(br->ofproto, ocs, n_ocs);
1634     free(ocs[0].target); /* From bridge_ofproto_controller_for_mgmt(). */
1635     free(ocs);
1636
1637     if (had_primary != ofproto_has_primary_controller(br->ofproto)) {
1638         ofproto_flush_flows(br->ofproto);
1639     }
1640
1641     /* If there are no controllers and the bridge is in standalone
1642      * mode, set up a flow that matches every packet and directs
1643      * them to OFPP_NORMAL (which goes to us).  Otherwise, the
1644      * switch is in secure mode and we won't pass any traffic until
1645      * a controller has been defined and it tells us to do so. */
1646     if (!n_controllers
1647         && ofproto_get_fail_mode(br->ofproto) == OFPROTO_FAIL_STANDALONE) {
1648         union ofp_action action;
1649         flow_t flow;
1650
1651         memset(&action, 0, sizeof action);
1652         action.type = htons(OFPAT_OUTPUT);
1653         action.output.len = htons(sizeof action);
1654         action.output.port = htons(OFPP_NORMAL);
1655         memset(&flow, 0, sizeof flow);
1656         flow.wildcards = OVSFW_ALL;
1657         ofproto_add_flow(br->ofproto, &flow, &action, 1, 0);
1658     }
1659 }
1660
1661 static void
1662 bridge_get_all_ifaces(const struct bridge *br, struct shash *ifaces)
1663 {
1664     size_t i, j;
1665
1666     shash_init(ifaces);
1667     for (i = 0; i < br->n_ports; i++) {
1668         struct port *port = br->ports[i];
1669         for (j = 0; j < port->n_ifaces; j++) {
1670             struct iface *iface = port->ifaces[j];
1671             shash_add_once(ifaces, iface->name, iface);
1672         }
1673         if (port->n_ifaces > 1 && port->cfg->bond_fake_iface) {
1674             shash_add_once(ifaces, port->name, NULL);
1675         }
1676     }
1677 }
1678
1679 /* For robustness, in case the administrator moves around datapath ports behind
1680  * our back, we re-check all the datapath port numbers here.
1681  *
1682  * This function will set the 'xf_ifidx' members of interfaces that have
1683  * disappeared to -1, so only call this function from a context where those
1684  * 'struct iface's will be removed from the bridge.  Otherwise, the -1
1685  * 'xf_ifidx'es will cause trouble later when we try to send them to the
1686  * datapath, which doesn't support UINT16_MAX+1 ports. */
1687 static void
1688 bridge_fetch_dp_ifaces(struct bridge *br)
1689 {
1690     struct xflow_port *xfif_ports;
1691     size_t n_xfif_ports;
1692     size_t i, j;
1693
1694     /* Reset all interface numbers. */
1695     for (i = 0; i < br->n_ports; i++) {
1696         struct port *port = br->ports[i];
1697         for (j = 0; j < port->n_ifaces; j++) {
1698             struct iface *iface = port->ifaces[j];
1699             iface->xf_ifidx = -1;
1700         }
1701     }
1702     port_array_clear(&br->ifaces);
1703
1704     xfif_port_list(br->xfif, &xfif_ports, &n_xfif_ports);
1705     for (i = 0; i < n_xfif_ports; i++) {
1706         struct xflow_port *p = &xfif_ports[i];
1707         struct iface *iface = iface_lookup(br, p->devname);
1708         if (iface) {
1709             if (iface->xf_ifidx >= 0) {
1710                 VLOG_WARN("%s reported interface %s twice",
1711                           xfif_name(br->xfif), p->devname);
1712             } else if (iface_from_xf_ifidx(br, p->port)) {
1713                 VLOG_WARN("%s reported interface %"PRIu16" twice",
1714                           xfif_name(br->xfif), p->port);
1715             } else {
1716                 port_array_set(&br->ifaces, p->port, iface);
1717                 iface->xf_ifidx = p->port;
1718             }
1719
1720             if (iface->cfg) {
1721                 int64_t ofport = (iface->xf_ifidx >= 0
1722                                   ? xflow_port_to_ofp_port(iface->xf_ifidx)
1723                                   : -1);
1724                 ovsrec_interface_set_ofport(iface->cfg, &ofport, 1);
1725             }
1726         }
1727     }
1728     free(xfif_ports);
1729 }
1730 \f
1731 /* Bridge packet processing functions. */
1732
1733 static int
1734 bond_hash(const uint8_t mac[ETH_ADDR_LEN])
1735 {
1736     return hash_bytes(mac, ETH_ADDR_LEN, 0) & BOND_MASK;
1737 }
1738
1739 static struct bond_entry *
1740 lookup_bond_entry(const struct port *port, const uint8_t mac[ETH_ADDR_LEN])
1741 {
1742     return &port->bond_hash[bond_hash(mac)];
1743 }
1744
1745 static int
1746 bond_choose_iface(const struct port *port)
1747 {
1748     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1749     size_t i, best_down_slave = -1;
1750     long long next_delay_expiration = LLONG_MAX;
1751
1752     for (i = 0; i < port->n_ifaces; i++) {
1753         struct iface *iface = port->ifaces[i];
1754
1755         if (iface->enabled) {
1756             return i;
1757         } else if (iface->delay_expires < next_delay_expiration) {
1758             best_down_slave = i;
1759             next_delay_expiration = iface->delay_expires;
1760         }
1761     }
1762
1763     if (best_down_slave != -1) {
1764         struct iface *iface = port->ifaces[best_down_slave];
1765
1766         VLOG_INFO_RL(&rl, "interface %s: skipping remaining %lli ms updelay "
1767                      "since no other interface is up", iface->name,
1768                      iface->delay_expires - time_msec());
1769         bond_enable_slave(iface, true);
1770     }
1771
1772     return best_down_slave;
1773 }
1774
1775 static bool
1776 choose_output_iface(const struct port *port, const uint8_t *dl_src,
1777                     uint16_t *xf_ifidx, tag_type *tags)
1778 {
1779     struct iface *iface;
1780
1781     assert(port->n_ifaces);
1782     if (port->n_ifaces == 1) {
1783         iface = port->ifaces[0];
1784     } else {
1785         struct bond_entry *e = lookup_bond_entry(port, dl_src);
1786         if (e->iface_idx < 0 || e->iface_idx >= port->n_ifaces
1787             || !port->ifaces[e->iface_idx]->enabled) {
1788             /* XXX select interface properly.  The current interface selection
1789              * is only good for testing the rebalancing code. */
1790             e->iface_idx = bond_choose_iface(port);
1791             if (e->iface_idx < 0) {
1792                 *tags |= port->no_ifaces_tag;
1793                 return false;
1794             }
1795             e->iface_tag = tag_create_random();
1796             ((struct port *) port)->bond_compat_is_stale = true;
1797         }
1798         *tags |= e->iface_tag;
1799         iface = port->ifaces[e->iface_idx];
1800     }
1801     *xf_ifidx = iface->xf_ifidx;
1802     *tags |= iface->tag;        /* Currently only used for bonding. */
1803     return true;
1804 }
1805
1806 static void
1807 bond_link_status_update(struct iface *iface, bool carrier)
1808 {
1809     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1810     struct port *port = iface->port;
1811
1812     if ((carrier == iface->enabled) == (iface->delay_expires == LLONG_MAX)) {
1813         /* Nothing to do. */
1814         return;
1815     }
1816     VLOG_INFO_RL(&rl, "interface %s: carrier %s",
1817                  iface->name, carrier ? "detected" : "dropped");
1818     if (carrier == iface->enabled) {
1819         iface->delay_expires = LLONG_MAX;
1820         VLOG_INFO_RL(&rl, "interface %s: will not be %s",
1821                      iface->name, carrier ? "disabled" : "enabled");
1822     } else if (carrier && port->active_iface < 0) {
1823         bond_enable_slave(iface, true);
1824         if (port->updelay) {
1825             VLOG_INFO_RL(&rl, "interface %s: skipping %d ms updelay since no "
1826                          "other interface is up", iface->name, port->updelay);
1827         }
1828     } else {
1829         int delay = carrier ? port->updelay : port->downdelay;
1830         iface->delay_expires = time_msec() + delay;
1831         if (delay) {
1832             VLOG_INFO_RL(&rl,
1833                          "interface %s: will be %s if it stays %s for %d ms",
1834                          iface->name,
1835                          carrier ? "enabled" : "disabled",
1836                          carrier ? "up" : "down",
1837                          delay);
1838         }
1839     }
1840 }
1841
1842 static void
1843 bond_choose_active_iface(struct port *port)
1844 {
1845     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
1846
1847     port->active_iface = bond_choose_iface(port);
1848     port->active_iface_tag = tag_create_random();
1849     if (port->active_iface >= 0) {
1850         VLOG_INFO_RL(&rl, "port %s: active interface is now %s",
1851                      port->name, port->ifaces[port->active_iface]->name);
1852     } else {
1853         VLOG_WARN_RL(&rl, "port %s: all ports disabled, no active interface",
1854                      port->name);
1855     }
1856 }
1857
1858 static void
1859 bond_enable_slave(struct iface *iface, bool enable)
1860 {
1861     struct port *port = iface->port;
1862     struct bridge *br = port->bridge;
1863
1864     /* This acts as a recursion check.  If the act of disabling a slave
1865      * causes a different slave to be enabled, the flag will allow us to
1866      * skip redundant work when we reenter this function.  It must be
1867      * cleared on exit to keep things safe with multiple bonds. */
1868     static bool moving_active_iface = false;
1869
1870     iface->delay_expires = LLONG_MAX;
1871     if (enable == iface->enabled) {
1872         return;
1873     }
1874
1875     iface->enabled = enable;
1876     if (!iface->enabled) {
1877         VLOG_WARN("interface %s: disabled", iface->name);
1878         ofproto_revalidate(br->ofproto, iface->tag);
1879         if (iface->port_ifidx == port->active_iface) {
1880             ofproto_revalidate(br->ofproto,
1881                                port->active_iface_tag);
1882
1883             /* Disabling a slave can lead to another slave being immediately
1884              * enabled if there will be no active slaves but one is waiting
1885              * on an updelay.  In this case we do not need to run most of the
1886              * code for the newly enabled slave since there was no period
1887              * without an active slave and it is redundant with the disabling
1888              * path. */
1889             moving_active_iface = true;
1890             bond_choose_active_iface(port);
1891         }
1892         bond_send_learning_packets(port);
1893     } else {
1894         VLOG_WARN("interface %s: enabled", iface->name);
1895         if (port->active_iface < 0 && !moving_active_iface) {
1896             ofproto_revalidate(br->ofproto, port->no_ifaces_tag);
1897             bond_choose_active_iface(port);
1898             bond_send_learning_packets(port);
1899         }
1900         iface->tag = tag_create_random();
1901     }
1902
1903     moving_active_iface = false;
1904     port->bond_compat_is_stale = true;
1905 }
1906
1907 /* Attempts to make the sum of the bond slaves' statistics appear on the fake
1908  * bond interface. */
1909 static void
1910 bond_update_fake_iface_stats(struct port *port)
1911 {
1912     struct netdev_stats bond_stats;
1913     struct netdev *bond_dev;
1914     size_t i;
1915
1916     memset(&bond_stats, 0, sizeof bond_stats);
1917
1918     for (i = 0; i < port->n_ifaces; i++) {
1919         struct netdev_stats slave_stats;
1920
1921         if (!netdev_get_stats(port->ifaces[i]->netdev, &slave_stats)) {
1922             /* XXX: We swap the stats here because they are swapped back when
1923              * reported by the internal device.  The reason for this is
1924              * internal devices normally represent packets going into the system
1925              * but when used as fake bond device they represent packets leaving
1926              * the system.  We really should do this in the internal device
1927              * itself because changing it here reverses the counts from the
1928              * perspective of the switch.  However, the internal device doesn't
1929              * know what type of device it represents so we have to do it here
1930              * for now. */
1931             bond_stats.tx_packets += slave_stats.rx_packets;
1932             bond_stats.tx_bytes += slave_stats.rx_bytes;
1933             bond_stats.rx_packets += slave_stats.tx_packets;
1934             bond_stats.rx_bytes += slave_stats.tx_bytes;
1935         }
1936     }
1937
1938     if (!netdev_open_default(port->name, &bond_dev)) {
1939         netdev_set_stats(bond_dev, &bond_stats);
1940         netdev_close(bond_dev);
1941     }
1942 }
1943
1944 static void
1945 bond_run(struct bridge *br)
1946 {
1947     size_t i, j;
1948
1949     for (i = 0; i < br->n_ports; i++) {
1950         struct port *port = br->ports[i];
1951
1952         if (port->n_ifaces >= 2) {
1953             for (j = 0; j < port->n_ifaces; j++) {
1954                 struct iface *iface = port->ifaces[j];
1955                 if (time_msec() >= iface->delay_expires) {
1956                     bond_enable_slave(iface, !iface->enabled);
1957                 }
1958             }
1959
1960             if (port->bond_fake_iface
1961                 && time_msec() >= port->bond_next_fake_iface_update) {
1962                 bond_update_fake_iface_stats(port);
1963                 port->bond_next_fake_iface_update = time_msec() + 1000;
1964             }
1965         }
1966
1967         if (port->bond_compat_is_stale) {
1968             port->bond_compat_is_stale = false;
1969             port_update_bond_compat(port);
1970         }
1971     }
1972 }
1973
1974 static void
1975 bond_wait(struct bridge *br)
1976 {
1977     size_t i, j;
1978
1979     for (i = 0; i < br->n_ports; i++) {
1980         struct port *port = br->ports[i];
1981         if (port->n_ifaces < 2) {
1982             continue;
1983         }
1984         for (j = 0; j < port->n_ifaces; j++) {
1985             struct iface *iface = port->ifaces[j];
1986             if (iface->delay_expires != LLONG_MAX) {
1987                 poll_timer_wait_until(iface->delay_expires);
1988             }
1989         }
1990         if (port->bond_fake_iface) {
1991             poll_timer_wait_until(port->bond_next_fake_iface_update);
1992         }
1993     }
1994 }
1995
1996 static bool
1997 set_dst(struct dst *p, const flow_t *flow,
1998         const struct port *in_port, const struct port *out_port,
1999         tag_type *tags)
2000 {
2001     p->vlan = (out_port->vlan >= 0 ? OFP_VLAN_NONE
2002               : in_port->vlan >= 0 ? in_port->vlan
2003               : ntohs(flow->dl_vlan));
2004     return choose_output_iface(out_port, flow->dl_src, &p->xf_ifidx, tags);
2005 }
2006
2007 static void
2008 swap_dst(struct dst *p, struct dst *q)
2009 {
2010     struct dst tmp = *p;
2011     *p = *q;
2012     *q = tmp;
2013 }
2014
2015 /* Moves all the dsts with vlan == 'vlan' to the front of the 'n_dsts' in
2016  * 'dsts'.  (This may help performance by reducing the number of VLAN changes
2017  * that we push to the datapath.  We could in fact fully sort the array by
2018  * vlan, but in most cases there are at most two different vlan tags so that's
2019  * possibly overkill.) */
2020 static void
2021 partition_dsts(struct dst *dsts, size_t n_dsts, int vlan)
2022 {
2023     struct dst *first = dsts;
2024     struct dst *last = dsts + n_dsts;
2025
2026     while (first != last) {
2027         /* Invariants:
2028          *      - All dsts < first have vlan == 'vlan'.
2029          *      - All dsts >= last have vlan != 'vlan'.
2030          *      - first < last. */
2031         while (first->vlan == vlan) {
2032             if (++first == last) {
2033                 return;
2034             }
2035         }
2036
2037         /* Same invariants, plus one additional:
2038          *      - first->vlan != vlan.
2039          */
2040         while (last[-1].vlan != vlan) {
2041             if (--last == first) {
2042                 return;
2043             }
2044         }
2045
2046         /* Same invariants, plus one additional:
2047          *      - last[-1].vlan == vlan.*/
2048         swap_dst(first++, --last);
2049     }
2050 }
2051
2052 static int
2053 mirror_mask_ffs(mirror_mask_t mask)
2054 {
2055     BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
2056     return ffs(mask);
2057 }
2058
2059 static bool
2060 dst_is_duplicate(const struct dst *dsts, size_t n_dsts,
2061                  const struct dst *test)
2062 {
2063     size_t i;
2064     for (i = 0; i < n_dsts; i++) {
2065         if (dsts[i].vlan == test->vlan && dsts[i].xf_ifidx == test->xf_ifidx) {
2066             return true;
2067         }
2068     }
2069     return false;
2070 }
2071
2072 static bool
2073 port_trunks_vlan(const struct port *port, uint16_t vlan)
2074 {
2075     return (port->vlan < 0
2076             && (!port->trunks || bitmap_is_set(port->trunks, vlan)));
2077 }
2078
2079 static bool
2080 port_includes_vlan(const struct port *port, uint16_t vlan)
2081 {
2082     return vlan == port->vlan || port_trunks_vlan(port, vlan);
2083 }
2084
2085 static size_t
2086 compose_dsts(const struct bridge *br, const flow_t *flow, uint16_t vlan,
2087              const struct port *in_port, const struct port *out_port,
2088              struct dst dsts[], tag_type *tags, uint16_t *nf_output_iface)
2089 {
2090     mirror_mask_t mirrors = in_port->src_mirrors;
2091     struct dst *dst = dsts;
2092     size_t i;
2093
2094     if (out_port == FLOOD_PORT) {
2095         /* XXX use XFLOW_FLOOD if no vlans or bonding. */
2096         /* XXX even better, define each VLAN as a datapath port group */
2097         for (i = 0; i < br->n_ports; i++) {
2098             struct port *port = br->ports[i];
2099             if (port != in_port && port_includes_vlan(port, vlan)
2100                 && !port->is_mirror_output_port
2101                 && set_dst(dst, flow, in_port, port, tags)) {
2102                 mirrors |= port->dst_mirrors;
2103                 dst++;
2104             }
2105         }
2106         *nf_output_iface = NF_OUT_FLOOD;
2107     } else if (out_port && set_dst(dst, flow, in_port, out_port, tags)) {
2108         *nf_output_iface = dst->xf_ifidx;
2109         mirrors |= out_port->dst_mirrors;
2110         dst++;
2111     }
2112
2113     while (mirrors) {
2114         struct mirror *m = br->mirrors[mirror_mask_ffs(mirrors) - 1];
2115         if (!m->n_vlans || vlan_is_mirrored(m, vlan)) {
2116             if (m->out_port) {
2117                 if (set_dst(dst, flow, in_port, m->out_port, tags)
2118                     && !dst_is_duplicate(dsts, dst - dsts, dst)) {
2119                     dst++;
2120                 }
2121             } else {
2122                 for (i = 0; i < br->n_ports; i++) {
2123                     struct port *port = br->ports[i];
2124                     if (port_includes_vlan(port, m->out_vlan)
2125                         && set_dst(dst, flow, in_port, port, tags))
2126                     {
2127                         int flow_vlan;
2128
2129                         if (port->vlan < 0) {
2130                             dst->vlan = m->out_vlan;
2131                         }
2132                         if (dst_is_duplicate(dsts, dst - dsts, dst)) {
2133                             continue;
2134                         }
2135
2136                         /* Use the vlan tag on the original flow instead of
2137                          * the one passed in the vlan parameter.  This ensures
2138                          * that we compare the vlan from before any implicit
2139                          * tagging tags place. This is necessary because
2140                          * dst->vlan is the final vlan, after removing implicit
2141                          * tags. */
2142                         flow_vlan = ntohs(flow->dl_vlan);
2143                         if (flow_vlan == 0) {
2144                             flow_vlan = OFP_VLAN_NONE;
2145                         }
2146                         if (port == in_port && dst->vlan == flow_vlan) {
2147                             /* Don't send out input port on same VLAN. */
2148                             continue;
2149                         }
2150                         dst++;
2151                     }
2152                 }
2153             }
2154         }
2155         mirrors &= mirrors - 1;
2156     }
2157
2158     partition_dsts(dsts, dst - dsts, ntohs(flow->dl_vlan));
2159     return dst - dsts;
2160 }
2161
2162 static void OVS_UNUSED
2163 print_dsts(const struct dst *dsts, size_t n)
2164 {
2165     for (; n--; dsts++) {
2166         printf(">p%"PRIu16, dsts->xf_ifidx);
2167         if (dsts->vlan != OFP_VLAN_NONE) {
2168             printf("v%"PRIu16, dsts->vlan);
2169         }
2170     }
2171 }
2172
2173 static void
2174 compose_actions(struct bridge *br, const flow_t *flow, uint16_t vlan,
2175                 const struct port *in_port, const struct port *out_port,
2176                 tag_type *tags, struct xflow_actions *actions,
2177                 uint16_t *nf_output_iface)
2178 {
2179     struct dst dsts[DP_MAX_PORTS * (MAX_MIRRORS + 1)];
2180     size_t n_dsts;
2181     const struct dst *p;
2182     uint16_t cur_vlan;
2183
2184     n_dsts = compose_dsts(br, flow, vlan, in_port, out_port, dsts, tags,
2185                           nf_output_iface);
2186
2187     cur_vlan = ntohs(flow->dl_vlan);
2188     for (p = dsts; p < &dsts[n_dsts]; p++) {
2189         union xflow_action *a;
2190         if (p->vlan != cur_vlan) {
2191             if (p->vlan == OFP_VLAN_NONE) {
2192                 xflow_actions_add(actions, XFLOWAT_STRIP_VLAN);
2193             } else {
2194                 a = xflow_actions_add(actions, XFLOWAT_SET_DL_TCI);
2195                 a->dl_tci.tci = htons(p->vlan & VLAN_VID_MASK);
2196                 a->dl_tci.mask = htons(VLAN_VID_MASK);
2197             }
2198             cur_vlan = p->vlan;
2199         }
2200         a = xflow_actions_add(actions, XFLOWAT_OUTPUT);
2201         a->output.port = p->xf_ifidx;
2202     }
2203 }
2204
2205 /* Returns the effective vlan of a packet, taking into account both the
2206  * 802.1Q header and implicitly tagged ports.  A value of 0 indicates that
2207  * the packet is untagged and -1 indicates it has an invalid header and
2208  * should be dropped. */
2209 static int flow_get_vlan(struct bridge *br, const flow_t *flow,
2210                          struct port *in_port, bool have_packet)
2211 {
2212     /* Note that dl_vlan of 0 and of OFP_VLAN_NONE both mean that the packet
2213      * belongs to VLAN 0, so we should treat both cases identically.  (In the
2214      * former case, the packet has an 802.1Q header that specifies VLAN 0,
2215      * presumably to allow a priority to be specified.  In the latter case, the
2216      * packet does not have any 802.1Q header.) */
2217     int vlan = ntohs(flow->dl_vlan);
2218     if (vlan == OFP_VLAN_NONE) {
2219         vlan = 0;
2220     }
2221     if (in_port->vlan >= 0) {
2222         if (vlan) {
2223             /* XXX support double tagging? */
2224             if (have_packet) {
2225                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2226                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %"PRIu16" tagged "
2227                              "packet received on port %s configured with "
2228                              "implicit VLAN %"PRIu16,
2229                              br->name, ntohs(flow->dl_vlan),
2230                              in_port->name, in_port->vlan);
2231             }
2232             return -1;
2233         }
2234         vlan = in_port->vlan;
2235     } else {
2236         if (!port_includes_vlan(in_port, vlan)) {
2237             if (have_packet) {
2238                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2239                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
2240                              "packet received on port %s not configured for "
2241                              "trunking VLAN %d",
2242                              br->name, vlan, in_port->name, vlan);
2243             }
2244             return -1;
2245         }
2246     }
2247
2248     return vlan;
2249 }
2250
2251 /* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
2252  * migration.  Older Citrix-patched Linux DomU used gratuitous ARP replies to
2253  * indicate this; newer upstream kernels use gratuitous ARP requests. */
2254 static bool
2255 is_gratuitous_arp(const flow_t *flow)
2256 {
2257     return (flow->dl_type == htons(ETH_TYPE_ARP)
2258             && eth_addr_is_broadcast(flow->dl_dst)
2259             && (flow->nw_proto == ARP_OP_REPLY
2260                 || (flow->nw_proto == ARP_OP_REQUEST
2261                     && flow->nw_src == flow->nw_dst)));
2262 }
2263
2264 static void
2265 update_learning_table(struct bridge *br, const flow_t *flow, int vlan,
2266                       struct port *in_port)
2267 {
2268     enum grat_arp_lock_type lock_type;
2269     tag_type rev_tag;
2270
2271     /* We don't want to learn from gratuitous ARP packets that are reflected
2272      * back over bond slaves so we lock the learning table. */
2273     lock_type = !is_gratuitous_arp(flow) ? GRAT_ARP_LOCK_NONE :
2274                     (in_port->n_ifaces == 1) ? GRAT_ARP_LOCK_SET :
2275                                                GRAT_ARP_LOCK_CHECK;
2276
2277     rev_tag = mac_learning_learn(br->ml, flow->dl_src, vlan, in_port->port_idx,
2278                                  lock_type);
2279     if (rev_tag) {
2280         /* The log messages here could actually be useful in debugging,
2281          * so keep the rate limit relatively high. */
2282         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30,
2283                                                                 300);
2284         VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
2285                     "on port %s in VLAN %d",
2286                     br->name, ETH_ADDR_ARGS(flow->dl_src),
2287                     in_port->name, vlan);
2288         ofproto_revalidate(br->ofproto, rev_tag);
2289     }
2290 }
2291
2292 /* Determines whether packets in 'flow' within 'br' should be forwarded or
2293  * dropped.  Returns true if they may be forwarded, false if they should be
2294  * dropped.
2295  *
2296  * If 'have_packet' is true, it indicates that the caller is processing a
2297  * received packet.  If 'have_packet' is false, then the caller is just
2298  * revalidating an existing flow because configuration has changed.  Either
2299  * way, 'have_packet' only affects logging (there is no point in logging errors
2300  * during revalidation).
2301  *
2302  * Sets '*in_portp' to the input port.  This will be a null pointer if
2303  * flow->in_port does not designate a known input port (in which case
2304  * is_admissible() returns false).
2305  *
2306  * When returning true, sets '*vlanp' to the effective VLAN of the input
2307  * packet, as returned by flow_get_vlan().
2308  *
2309  * May also add tags to '*tags', although the current implementation only does
2310  * so in one special case.
2311  */
2312 static bool
2313 is_admissible(struct bridge *br, const flow_t *flow, bool have_packet,
2314               tag_type *tags, int *vlanp, struct port **in_portp)
2315 {
2316     struct iface *in_iface;
2317     struct port *in_port;
2318     int vlan;
2319
2320     /* Find the interface and port structure for the received packet. */
2321     in_iface = iface_from_xf_ifidx(br, ofp_port_to_xflow_port(flow->in_port));
2322     if (!in_iface) {
2323         /* No interface?  Something fishy... */
2324         if (have_packet) {
2325             /* Odd.  A few possible reasons here:
2326              *
2327              * - We deleted an interface but there are still a few packets
2328              *   queued up from it.
2329              *
2330              * - Someone externally added an interface (e.g. with "ovs-dpctl
2331              *   add-if") that we don't know about.
2332              *
2333              * - Packet arrived on the local port but the local port is not
2334              *   one of our bridge ports.
2335              */
2336             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2337
2338             VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
2339                          "interface %"PRIu16, br->name, flow->in_port); 
2340         }
2341
2342         *in_portp = NULL;
2343         return false;
2344     }
2345     *in_portp = in_port = in_iface->port;
2346     *vlanp = vlan = flow_get_vlan(br, flow, in_port, have_packet);
2347     if (vlan < 0) {
2348         return false;
2349     }
2350
2351     /* Drop frames for reserved multicast addresses. */
2352     if (eth_addr_is_reserved(flow->dl_dst)) {
2353         return false;
2354     }
2355
2356     /* Drop frames on ports reserved for mirroring. */
2357     if (in_port->is_mirror_output_port) {
2358         if (have_packet) {
2359             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2360             VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
2361                          "%s, which is reserved exclusively for mirroring",
2362                          br->name, in_port->name);
2363         }
2364         return false;
2365     }
2366
2367     /* Packets received on bonds need special attention to avoid duplicates. */
2368     if (in_port->n_ifaces > 1) {
2369         int src_idx;
2370         bool is_grat_arp_locked;
2371
2372         if (eth_addr_is_multicast(flow->dl_dst)) {
2373             *tags |= in_port->active_iface_tag;
2374             if (in_port->active_iface != in_iface->port_ifidx) {
2375                 /* Drop all multicast packets on inactive slaves. */
2376                 return false;
2377             }
2378         }
2379
2380         /* Drop all packets for which we have learned a different input
2381          * port, because we probably sent the packet on one slave and got
2382          * it back on the other.  Gratuitous ARP packets are an exception
2383          * to this rule: the host has moved to another switch.  The exception
2384          * to the exception is if we locked the learning table to avoid
2385          * reflections on bond slaves.  If this is the case, just drop the
2386          * packet now. */
2387         src_idx = mac_learning_lookup(br->ml, flow->dl_src, vlan,
2388                                       &is_grat_arp_locked);
2389         if (src_idx != -1 && src_idx != in_port->port_idx &&
2390             (!is_gratuitous_arp(flow) || is_grat_arp_locked)) {
2391                 return false;
2392         }
2393     }
2394
2395     return true;
2396 }
2397
2398 /* If the composed actions may be applied to any packet in the given 'flow',
2399  * returns true.  Otherwise, the actions should only be applied to 'packet', or
2400  * not at all, if 'packet' was NULL. */
2401 static bool
2402 process_flow(struct bridge *br, const flow_t *flow,
2403              const struct ofpbuf *packet, struct xflow_actions *actions,
2404              tag_type *tags, uint16_t *nf_output_iface)
2405 {
2406     struct port *in_port;
2407     struct port *out_port;
2408     int vlan;
2409     int out_port_idx;
2410
2411     /* Check whether we should drop packets in this flow. */
2412     if (!is_admissible(br, flow, packet != NULL, tags, &vlan, &in_port)) {
2413         out_port = NULL;
2414         goto done;
2415     }
2416
2417     /* Learn source MAC (but don't try to learn from revalidation). */
2418     if (packet) {
2419         update_learning_table(br, flow, vlan, in_port);
2420     }
2421
2422     /* Determine output port. */
2423     out_port_idx = mac_learning_lookup_tag(br->ml, flow->dl_dst, vlan, tags,
2424                                            NULL);
2425     if (out_port_idx >= 0 && out_port_idx < br->n_ports) {
2426         out_port = br->ports[out_port_idx];
2427     } else if (!packet && !eth_addr_is_multicast(flow->dl_dst)) {
2428         /* If we are revalidating but don't have a learning entry then
2429          * eject the flow.  Installing a flow that floods packets opens
2430          * up a window of time where we could learn from a packet reflected
2431          * on a bond and blackhole packets before the learning table is
2432          * updated to reflect the correct port. */
2433         return false;
2434     } else {
2435         out_port = FLOOD_PORT;
2436     }
2437
2438     /* Don't send packets out their input ports. */
2439     if (in_port == out_port) {
2440         out_port = NULL;
2441     }
2442
2443 done:
2444     if (in_port) {
2445         compose_actions(br, flow, vlan, in_port, out_port, tags, actions,
2446                         nf_output_iface);
2447     }
2448
2449     return true;
2450 }
2451
2452 /* Careful: 'opp' is in host byte order and opp->port_no is an OFP port
2453  * number. */
2454 static void
2455 bridge_port_changed_ofhook_cb(enum ofp_port_reason reason,
2456                               const struct ofp_phy_port *opp,
2457                               void *br_)
2458 {
2459     struct bridge *br = br_;
2460     struct iface *iface;
2461     struct port *port;
2462
2463     iface = iface_from_xf_ifidx(br, ofp_port_to_xflow_port(opp->port_no));
2464     if (!iface) {
2465         return;
2466     }
2467     port = iface->port;
2468
2469     if (reason == OFPPR_DELETE) {
2470         VLOG_WARN("bridge %s: interface %s deleted unexpectedly",
2471                   br->name, iface->name);
2472         iface_destroy(iface);
2473         if (!port->n_ifaces) {
2474             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
2475                       br->name, port->name);
2476             port_destroy(port);
2477         }
2478
2479         bridge_flush(br);
2480     } else {
2481         if (port->n_ifaces > 1) {
2482             bool up = !(opp->state & OFPPS_LINK_DOWN);
2483             bond_link_status_update(iface, up);
2484             port_update_bond_compat(port);
2485         }
2486     }
2487 }
2488
2489 static bool
2490 bridge_normal_ofhook_cb(const flow_t *flow, const struct ofpbuf *packet,
2491                         struct xflow_actions *actions, tag_type *tags,
2492                         uint16_t *nf_output_iface, void *br_)
2493 {
2494     struct bridge *br = br_;
2495
2496     COVERAGE_INC(bridge_process_flow);
2497
2498     return process_flow(br, flow, packet, actions, tags, nf_output_iface);
2499 }
2500
2501 static void
2502 bridge_account_flow_ofhook_cb(const flow_t *flow, tag_type tags,
2503                               const union xflow_action *actions,
2504                               size_t n_actions, unsigned long long int n_bytes,
2505                               void *br_)
2506 {
2507     struct bridge *br = br_;
2508     const union xflow_action *a;
2509     struct port *in_port;
2510     tag_type dummy = 0;
2511     int vlan;
2512
2513     /* Feed information from the active flows back into the learning table to
2514      * ensure that table is always in sync with what is actually flowing
2515      * through the datapath.
2516      *
2517      * We test that 'tags' is nonzero to ensure that only flows that include an
2518      * OFPP_NORMAL action are used for learning.  This works because
2519      * bridge_normal_ofhook_cb() always sets a nonzero tag value. */
2520     if (tags && is_admissible(br, flow, false, &dummy, &vlan, &in_port)) {
2521         update_learning_table(br, flow, vlan, in_port);
2522     }
2523
2524     /* Account for bond slave utilization. */
2525     if (!br->has_bonded_ports) {
2526         return;
2527     }
2528     for (a = actions; a < &actions[n_actions]; a++) {
2529         if (a->type == XFLOWAT_OUTPUT) {
2530             struct port *out_port = port_from_xf_ifidx(br, a->output.port);
2531             if (out_port && out_port->n_ifaces >= 2) {
2532                 struct bond_entry *e = lookup_bond_entry(out_port,
2533                                                          flow->dl_src);
2534                 e->tx_bytes += n_bytes;
2535             }
2536         }
2537     }
2538 }
2539
2540 static void
2541 bridge_account_checkpoint_ofhook_cb(void *br_)
2542 {
2543     struct bridge *br = br_;
2544     long long int now;
2545     size_t i;
2546
2547     if (!br->has_bonded_ports) {
2548         return;
2549     }
2550
2551     now = time_msec();
2552     for (i = 0; i < br->n_ports; i++) {
2553         struct port *port = br->ports[i];
2554         if (port->n_ifaces > 1 && now >= port->bond_next_rebalance) {
2555             port->bond_next_rebalance = now + port->bond_rebalance_interval;
2556             bond_rebalance_port(port);
2557         }
2558     }
2559 }
2560
2561 static struct ofhooks bridge_ofhooks = {
2562     bridge_port_changed_ofhook_cb,
2563     bridge_normal_ofhook_cb,
2564     bridge_account_flow_ofhook_cb,
2565     bridge_account_checkpoint_ofhook_cb,
2566 };
2567 \f
2568 /* Bonding functions. */
2569
2570 /* Statistics for a single interface on a bonded port, used for load-based
2571  * bond rebalancing.  */
2572 struct slave_balance {
2573     struct iface *iface;        /* The interface. */
2574     uint64_t tx_bytes;          /* Sum of hashes[*]->tx_bytes. */
2575
2576     /* All the "bond_entry"s that are assigned to this interface, in order of
2577      * increasing tx_bytes. */
2578     struct bond_entry **hashes;
2579     size_t n_hashes;
2580 };
2581
2582 /* Sorts pointers to pointers to bond_entries in ascending order by the
2583  * interface to which they are assigned, and within a single interface in
2584  * ascending order of bytes transmitted. */
2585 static int
2586 compare_bond_entries(const void *a_, const void *b_)
2587 {
2588     const struct bond_entry *const *ap = a_;
2589     const struct bond_entry *const *bp = b_;
2590     const struct bond_entry *a = *ap;
2591     const struct bond_entry *b = *bp;
2592     if (a->iface_idx != b->iface_idx) {
2593         return a->iface_idx > b->iface_idx ? 1 : -1;
2594     } else if (a->tx_bytes != b->tx_bytes) {
2595         return a->tx_bytes > b->tx_bytes ? 1 : -1;
2596     } else {
2597         return 0;
2598     }
2599 }
2600
2601 /* Sorts slave_balances so that enabled ports come first, and otherwise in
2602  * *descending* order by number of bytes transmitted. */
2603 static int
2604 compare_slave_balance(const void *a_, const void *b_)
2605 {
2606     const struct slave_balance *a = a_;
2607     const struct slave_balance *b = b_;
2608     if (a->iface->enabled != b->iface->enabled) {
2609         return a->iface->enabled ? -1 : 1;
2610     } else if (a->tx_bytes != b->tx_bytes) {
2611         return a->tx_bytes > b->tx_bytes ? -1 : 1;
2612     } else {
2613         return 0;
2614     }
2615 }
2616
2617 static void
2618 swap_bals(struct slave_balance *a, struct slave_balance *b)
2619 {
2620     struct slave_balance tmp = *a;
2621     *a = *b;
2622     *b = tmp;
2623 }
2624
2625 /* Restores the 'n_bals' slave_balance structures in 'bals' to sorted order
2626  * given that 'p' (and only 'p') might be in the wrong location.
2627  *
2628  * This function invalidates 'p', since it might now be in a different memory
2629  * location. */
2630 static void
2631 resort_bals(struct slave_balance *p,
2632             struct slave_balance bals[], size_t n_bals)
2633 {
2634     if (n_bals > 1) {
2635         for (; p > bals && p->tx_bytes > p[-1].tx_bytes; p--) {
2636             swap_bals(p, p - 1);
2637         }
2638         for (; p < &bals[n_bals - 1] && p->tx_bytes < p[1].tx_bytes; p++) {
2639             swap_bals(p, p + 1);
2640         }
2641     }
2642 }
2643
2644 static void
2645 log_bals(const struct slave_balance *bals, size_t n_bals, struct port *port)
2646 {
2647     if (VLOG_IS_DBG_ENABLED()) {
2648         struct ds ds = DS_EMPTY_INITIALIZER;
2649         const struct slave_balance *b;
2650
2651         for (b = bals; b < bals + n_bals; b++) {
2652             size_t i;
2653
2654             if (b > bals) {
2655                 ds_put_char(&ds, ',');
2656             }
2657             ds_put_format(&ds, " %s %"PRIu64"kB",
2658                           b->iface->name, b->tx_bytes / 1024);
2659
2660             if (!b->iface->enabled) {
2661                 ds_put_cstr(&ds, " (disabled)");
2662             }
2663             if (b->n_hashes > 0) {
2664                 ds_put_cstr(&ds, " (");
2665                 for (i = 0; i < b->n_hashes; i++) {
2666                     const struct bond_entry *e = b->hashes[i];
2667                     if (i > 0) {
2668                         ds_put_cstr(&ds, " + ");
2669                     }
2670                     ds_put_format(&ds, "h%td: %"PRIu64"kB",
2671                                   e - port->bond_hash, e->tx_bytes / 1024);
2672                 }
2673                 ds_put_cstr(&ds, ")");
2674             }
2675         }
2676         VLOG_DBG("bond %s:%s", port->name, ds_cstr(&ds));
2677         ds_destroy(&ds);
2678     }
2679 }
2680
2681 /* Shifts 'hash' from 'from' to 'to' within 'port'. */
2682 static void
2683 bond_shift_load(struct slave_balance *from, struct slave_balance *to,
2684                 int hash_idx)
2685 {
2686     struct bond_entry *hash = from->hashes[hash_idx];
2687     struct port *port = from->iface->port;
2688     uint64_t delta = hash->tx_bytes;
2689
2690     VLOG_INFO("bond %s: shift %"PRIu64"kB of load (with hash %td) "
2691               "from %s to %s (now carrying %"PRIu64"kB and "
2692               "%"PRIu64"kB load, respectively)",
2693               port->name, delta / 1024, hash - port->bond_hash,
2694               from->iface->name, to->iface->name,
2695               (from->tx_bytes - delta) / 1024,
2696               (to->tx_bytes + delta) / 1024);
2697
2698     /* Delete element from from->hashes.
2699      *
2700      * We don't bother to add the element to to->hashes because not only would
2701      * it require more work, the only purpose it would be to allow that hash to
2702      * be migrated to another slave in this rebalancing run, and there is no
2703      * point in doing that.  */
2704     if (hash_idx == 0) {
2705         from->hashes++;
2706     } else {
2707         memmove(from->hashes + hash_idx, from->hashes + hash_idx + 1,
2708                 (from->n_hashes - (hash_idx + 1)) * sizeof *from->hashes);
2709     }
2710     from->n_hashes--;
2711
2712     /* Shift load away from 'from' to 'to'. */
2713     from->tx_bytes -= delta;
2714     to->tx_bytes += delta;
2715
2716     /* Arrange for flows to be revalidated. */
2717     ofproto_revalidate(port->bridge->ofproto, hash->iface_tag);
2718     hash->iface_idx = to->iface->port_ifidx;
2719     hash->iface_tag = tag_create_random();
2720 }
2721
2722 static void
2723 bond_rebalance_port(struct port *port)
2724 {
2725     struct slave_balance bals[DP_MAX_PORTS];
2726     size_t n_bals;
2727     struct bond_entry *hashes[BOND_MASK + 1];
2728     struct slave_balance *b, *from, *to;
2729     struct bond_entry *e;
2730     size_t i;
2731
2732     /* Sets up 'bals' to describe each of the port's interfaces, sorted in
2733      * descending order of tx_bytes, so that bals[0] represents the most
2734      * heavily loaded slave and bals[n_bals - 1] represents the least heavily
2735      * loaded slave.
2736      *
2737      * The code is a bit tricky: to avoid dynamically allocating a 'hashes'
2738      * array for each slave_balance structure, we sort our local array of
2739      * hashes in order by slave, so that all of the hashes for a given slave
2740      * become contiguous in memory, and then we point each 'hashes' members of
2741      * a slave_balance structure to the start of a contiguous group. */
2742     n_bals = port->n_ifaces;
2743     for (b = bals; b < &bals[n_bals]; b++) {
2744         b->iface = port->ifaces[b - bals];
2745         b->tx_bytes = 0;
2746         b->hashes = NULL;
2747         b->n_hashes = 0;
2748     }
2749     for (i = 0; i <= BOND_MASK; i++) {
2750         hashes[i] = &port->bond_hash[i];
2751     }
2752     qsort(hashes, BOND_MASK + 1, sizeof *hashes, compare_bond_entries);
2753     for (i = 0; i <= BOND_MASK; i++) {
2754         e = hashes[i];
2755         if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
2756             b = &bals[e->iface_idx];
2757             b->tx_bytes += e->tx_bytes;
2758             if (!b->hashes) {
2759                 b->hashes = &hashes[i];
2760             }
2761             b->n_hashes++;
2762         }
2763     }
2764     qsort(bals, n_bals, sizeof *bals, compare_slave_balance);
2765     log_bals(bals, n_bals, port);
2766
2767     /* Discard slaves that aren't enabled (which were sorted to the back of the
2768      * array earlier). */
2769     while (!bals[n_bals - 1].iface->enabled) {
2770         n_bals--;
2771         if (!n_bals) {
2772             return;
2773         }
2774     }
2775
2776     /* Shift load from the most-loaded slaves to the least-loaded slaves. */
2777     to = &bals[n_bals - 1];
2778     for (from = bals; from < to; ) {
2779         uint64_t overload = from->tx_bytes - to->tx_bytes;
2780         if (overload < to->tx_bytes >> 5 || overload < 100000) {
2781             /* The extra load on 'from' (and all less-loaded slaves), compared
2782              * to that of 'to' (the least-loaded slave), is less than ~3%, or
2783              * it is less than ~1Mbps.  No point in rebalancing. */
2784             break;
2785         } else if (from->n_hashes == 1) {
2786             /* 'from' only carries a single MAC hash, so we can't shift any
2787              * load away from it, even though we want to. */
2788             from++;
2789         } else {
2790             /* 'from' is carrying significantly more load than 'to', and that
2791              * load is split across at least two different hashes.  Pick a hash
2792              * to migrate to 'to' (the least-loaded slave), given that doing so
2793              * must decrease the ratio of the load on the two slaves by at
2794              * least 0.1.
2795              *
2796              * The sort order we use means that we prefer to shift away the
2797              * smallest hashes instead of the biggest ones.  There is little
2798              * reason behind this decision; we could use the opposite sort
2799              * order to shift away big hashes ahead of small ones. */
2800             size_t i;
2801             bool order_swapped;
2802
2803             for (i = 0; i < from->n_hashes; i++) {
2804                 double old_ratio, new_ratio;
2805                 uint64_t delta = from->hashes[i]->tx_bytes;
2806
2807                 if (delta == 0 || from->tx_bytes - delta == 0) {
2808                     /* Pointless move. */
2809                     continue;
2810                 }
2811
2812                 order_swapped = from->tx_bytes - delta < to->tx_bytes + delta;
2813
2814                 if (to->tx_bytes == 0) {
2815                     /* Nothing on the new slave, move it. */
2816                     break;
2817                 }
2818
2819                 old_ratio = (double)from->tx_bytes / to->tx_bytes;
2820                 new_ratio = (double)(from->tx_bytes - delta) /
2821                             (to->tx_bytes + delta);
2822
2823                 if (new_ratio == 0) {
2824                     /* Should already be covered but check to prevent division
2825                      * by zero. */
2826                     continue;
2827                 }
2828
2829                 if (new_ratio < 1) {
2830                     new_ratio = 1 / new_ratio;
2831                 }
2832
2833                 if (old_ratio - new_ratio > 0.1) {
2834                     /* Would decrease the ratio, move it. */
2835                     break;
2836                 }
2837             }
2838             if (i < from->n_hashes) {
2839                 bond_shift_load(from, to, i);
2840                 port->bond_compat_is_stale = true;
2841
2842                 /* If the result of the migration changed the relative order of
2843                  * 'from' and 'to' swap them back to maintain invariants. */
2844                 if (order_swapped) {
2845                     swap_bals(from, to);
2846                 }
2847
2848                 /* Re-sort 'bals'.  Note that this may make 'from' and 'to'
2849                  * point to different slave_balance structures.  It is only
2850                  * valid to do these two operations in a row at all because we
2851                  * know that 'from' will not move past 'to' and vice versa. */
2852                 resort_bals(from, bals, n_bals);
2853                 resort_bals(to, bals, n_bals);
2854             } else {
2855                 from++;
2856             }
2857         }
2858     }
2859
2860     /* Implement exponentially weighted moving average.  A weight of 1/2 causes
2861      * historical data to decay to <1% in 7 rebalancing runs.  */
2862     for (e = &port->bond_hash[0]; e <= &port->bond_hash[BOND_MASK]; e++) {
2863         e->tx_bytes /= 2;
2864     }
2865 }
2866
2867 static void
2868 bond_send_learning_packets(struct port *port)
2869 {
2870     struct bridge *br = port->bridge;
2871     struct mac_entry *e;
2872     struct ofpbuf packet;
2873     int error, n_packets, n_errors;
2874
2875     if (!port->n_ifaces || port->active_iface < 0) {
2876         return;
2877     }
2878
2879     ofpbuf_init(&packet, 128);
2880     error = n_packets = n_errors = 0;
2881     LIST_FOR_EACH (e, struct mac_entry, lru_node, &br->ml->lrus) {
2882         union ofp_action actions[2], *a;
2883         uint16_t xf_ifidx;
2884         tag_type tags = 0;
2885         flow_t flow;
2886         int retval;
2887
2888         if (e->port == port->port_idx
2889             || !choose_output_iface(port, e->mac, &xf_ifidx, &tags)) {
2890             continue;
2891         }
2892
2893         /* Compose actions. */
2894         memset(actions, 0, sizeof actions);
2895         a = actions;
2896         if (e->vlan) {
2897             a->vlan_vid.type = htons(OFPAT_SET_VLAN_VID);
2898             a->vlan_vid.len = htons(sizeof *a);
2899             a->vlan_vid.vlan_vid = htons(e->vlan);
2900             a++;
2901         }
2902         a->output.type = htons(OFPAT_OUTPUT);
2903         a->output.len = htons(sizeof *a);
2904         a->output.port = htons(xflow_port_to_ofp_port(xf_ifidx));
2905         a++;
2906
2907         /* Send packet. */
2908         n_packets++;
2909         compose_benign_packet(&packet, "Open vSwitch Bond Failover", 0xf177,
2910                               e->mac);
2911         flow_extract(&packet, 0, OFPP_NONE, &flow);
2912         retval = ofproto_send_packet(br->ofproto, &flow, actions, a - actions,
2913                                      &packet);
2914         if (retval) {
2915             error = retval;
2916             n_errors++;
2917         }
2918     }
2919     ofpbuf_uninit(&packet);
2920
2921     if (n_errors) {
2922         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2923         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
2924                      "packets, last error was: %s",
2925                      port->name, n_errors, n_packets, strerror(error));
2926     } else {
2927         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
2928                  port->name, n_packets);
2929     }
2930 }
2931 \f
2932 /* Bonding unixctl user interface functions. */
2933
2934 static void
2935 bond_unixctl_list(struct unixctl_conn *conn,
2936                   const char *args OVS_UNUSED, void *aux OVS_UNUSED)
2937 {
2938     struct ds ds = DS_EMPTY_INITIALIZER;
2939     const struct bridge *br;
2940
2941     ds_put_cstr(&ds, "bridge\tbond\tslaves\n");
2942
2943     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2944         size_t i;
2945
2946         for (i = 0; i < br->n_ports; i++) {
2947             const struct port *port = br->ports[i];
2948             if (port->n_ifaces > 1) {
2949                 size_t j;
2950
2951                 ds_put_format(&ds, "%s\t%s\t", br->name, port->name);
2952                 for (j = 0; j < port->n_ifaces; j++) {
2953                     const struct iface *iface = port->ifaces[j];
2954                     if (j) {
2955                         ds_put_cstr(&ds, ", ");
2956                     }
2957                     ds_put_cstr(&ds, iface->name);
2958                 }
2959                 ds_put_char(&ds, '\n');
2960             }
2961         }
2962     }
2963     unixctl_command_reply(conn, 200, ds_cstr(&ds));
2964     ds_destroy(&ds);
2965 }
2966
2967 static struct port *
2968 bond_find(const char *name)
2969 {
2970     const struct bridge *br;
2971
2972     LIST_FOR_EACH (br, struct bridge, node, &all_bridges) {
2973         size_t i;
2974
2975         for (i = 0; i < br->n_ports; i++) {
2976             struct port *port = br->ports[i];
2977             if (!strcmp(port->name, name) && port->n_ifaces > 1) {
2978                 return port;
2979             }
2980         }
2981     }
2982     return NULL;
2983 }
2984
2985 static void
2986 bond_unixctl_show(struct unixctl_conn *conn,
2987                   const char *args, void *aux OVS_UNUSED)
2988 {
2989     struct ds ds = DS_EMPTY_INITIALIZER;
2990     const struct port *port;
2991     size_t j;
2992
2993     port = bond_find(args);
2994     if (!port) {
2995         unixctl_command_reply(conn, 501, "no such bond");
2996         return;
2997     }
2998
2999     ds_put_format(&ds, "updelay: %d ms\n", port->updelay);
3000     ds_put_format(&ds, "downdelay: %d ms\n", port->downdelay);
3001     ds_put_format(&ds, "next rebalance: %lld ms\n",
3002                   port->bond_next_rebalance - time_msec());
3003     for (j = 0; j < port->n_ifaces; j++) {
3004         const struct iface *iface = port->ifaces[j];
3005         struct bond_entry *be;
3006
3007         /* Basic info. */
3008         ds_put_format(&ds, "slave %s: %s\n",
3009                       iface->name, iface->enabled ? "enabled" : "disabled");
3010         if (j == port->active_iface) {
3011             ds_put_cstr(&ds, "\tactive slave\n");
3012         }
3013         if (iface->delay_expires != LLONG_MAX) {
3014             ds_put_format(&ds, "\t%s expires in %lld ms\n",
3015                           iface->enabled ? "downdelay" : "updelay",
3016                           iface->delay_expires - time_msec());
3017         }
3018
3019         /* Hashes. */
3020         for (be = port->bond_hash; be <= &port->bond_hash[BOND_MASK]; be++) {
3021             int hash = be - port->bond_hash;
3022             struct mac_entry *me;
3023
3024             if (be->iface_idx != j) {
3025                 continue;
3026             }
3027
3028             ds_put_format(&ds, "\thash %d: %"PRIu64" kB load\n",
3029                           hash, be->tx_bytes / 1024);
3030
3031             /* MACs. */
3032             LIST_FOR_EACH (me, struct mac_entry, lru_node,
3033                            &port->bridge->ml->lrus) {
3034                 uint16_t xf_ifidx;
3035                 tag_type tags = 0;
3036                 if (bond_hash(me->mac) == hash
3037                     && me->port != port->port_idx
3038                     && choose_output_iface(port, me->mac, &xf_ifidx, &tags)
3039                     && xf_ifidx == iface->xf_ifidx)
3040                 {
3041                     ds_put_format(&ds, "\t\t"ETH_ADDR_FMT"\n",
3042                                   ETH_ADDR_ARGS(me->mac));
3043                 }
3044             }
3045         }
3046     }
3047     unixctl_command_reply(conn, 200, ds_cstr(&ds));
3048     ds_destroy(&ds);
3049 }
3050
3051 static void
3052 bond_unixctl_migrate(struct unixctl_conn *conn, const char *args_,
3053                      void *aux OVS_UNUSED)
3054 {
3055     char *args = (char *) args_;
3056     char *save_ptr = NULL;
3057     char *bond_s, *hash_s, *slave_s;
3058     uint8_t mac[ETH_ADDR_LEN];
3059     struct port *port;
3060     struct iface *iface;
3061     struct bond_entry *entry;
3062     int hash;
3063
3064     bond_s = strtok_r(args, " ", &save_ptr);
3065     hash_s = strtok_r(NULL, " ", &save_ptr);
3066     slave_s = strtok_r(NULL, " ", &save_ptr);
3067     if (!slave_s) {
3068         unixctl_command_reply(conn, 501,
3069                               "usage: bond/migrate BOND HASH SLAVE");
3070         return;
3071     }
3072
3073     port = bond_find(bond_s);
3074     if (!port) {
3075         unixctl_command_reply(conn, 501, "no such bond");
3076         return;
3077     }
3078
3079     if (sscanf(hash_s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
3080         == ETH_ADDR_SCAN_COUNT) {
3081         hash = bond_hash(mac);
3082     } else if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
3083         hash = atoi(hash_s) & BOND_MASK;
3084     } else {
3085         unixctl_command_reply(conn, 501, "bad hash");
3086         return;
3087     }
3088
3089     iface = port_lookup_iface(port, slave_s);
3090     if (!iface) {
3091         unixctl_command_reply(conn, 501, "no such slave");
3092         return;
3093     }
3094
3095     if (!iface->enabled) {
3096         unixctl_command_reply(conn, 501, "cannot migrate to disabled slave");
3097         return;
3098     }
3099
3100     entry = &port->bond_hash[hash];
3101     ofproto_revalidate(port->bridge->ofproto, entry->iface_tag);
3102     entry->iface_idx = iface->port_ifidx;
3103     entry->iface_tag = tag_create_random();
3104     port->bond_compat_is_stale = true;
3105     unixctl_command_reply(conn, 200, "migrated");
3106 }
3107
3108 static void
3109 bond_unixctl_set_active_slave(struct unixctl_conn *conn, const char *args_,
3110                               void *aux OVS_UNUSED)
3111 {
3112     char *args = (char *) args_;
3113     char *save_ptr = NULL;
3114     char *bond_s, *slave_s;
3115     struct port *port;
3116     struct iface *iface;
3117
3118     bond_s = strtok_r(args, " ", &save_ptr);
3119     slave_s = strtok_r(NULL, " ", &save_ptr);
3120     if (!slave_s) {
3121         unixctl_command_reply(conn, 501,
3122                               "usage: bond/set-active-slave BOND SLAVE");
3123         return;
3124     }
3125
3126     port = bond_find(bond_s);
3127     if (!port) {
3128         unixctl_command_reply(conn, 501, "no such bond");
3129         return;
3130     }
3131
3132     iface = port_lookup_iface(port, slave_s);
3133     if (!iface) {
3134         unixctl_command_reply(conn, 501, "no such slave");
3135         return;
3136     }
3137
3138     if (!iface->enabled) {
3139         unixctl_command_reply(conn, 501, "cannot make disabled slave active");
3140         return;
3141     }
3142
3143     if (port->active_iface != iface->port_ifidx) {
3144         ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
3145         port->active_iface = iface->port_ifidx;
3146         port->active_iface_tag = tag_create_random();
3147         VLOG_INFO("port %s: active interface is now %s",
3148                   port->name, iface->name);
3149         bond_send_learning_packets(port);
3150         unixctl_command_reply(conn, 200, "done");
3151     } else {
3152         unixctl_command_reply(conn, 200, "no change");
3153     }
3154 }
3155
3156 static void
3157 enable_slave(struct unixctl_conn *conn, const char *args_, bool enable)
3158 {
3159     char *args = (char *) args_;
3160     char *save_ptr = NULL;
3161     char *bond_s, *slave_s;
3162     struct port *port;
3163     struct iface *iface;
3164
3165     bond_s = strtok_r(args, " ", &save_ptr);
3166     slave_s = strtok_r(NULL, " ", &save_ptr);
3167     if (!slave_s) {
3168         unixctl_command_reply(conn, 501,
3169                               "usage: bond/enable/disable-slave BOND SLAVE");
3170         return;
3171     }
3172
3173     port = bond_find(bond_s);
3174     if (!port) {
3175         unixctl_command_reply(conn, 501, "no such bond");
3176         return;
3177     }
3178
3179     iface = port_lookup_iface(port, slave_s);
3180     if (!iface) {
3181         unixctl_command_reply(conn, 501, "no such slave");
3182         return;
3183     }
3184
3185     bond_enable_slave(iface, enable);
3186     unixctl_command_reply(conn, 501, enable ? "enabled" : "disabled");
3187 }
3188
3189 static void
3190 bond_unixctl_enable_slave(struct unixctl_conn *conn, const char *args,
3191                           void *aux OVS_UNUSED)
3192 {
3193     enable_slave(conn, args, true);
3194 }
3195
3196 static void
3197 bond_unixctl_disable_slave(struct unixctl_conn *conn, const char *args,
3198                            void *aux OVS_UNUSED)
3199 {
3200     enable_slave(conn, args, false);
3201 }
3202
3203 static void
3204 bond_unixctl_hash(struct unixctl_conn *conn, const char *args,
3205                   void *aux OVS_UNUSED)
3206 {
3207         uint8_t mac[ETH_ADDR_LEN];
3208         uint8_t hash;
3209         char *hash_cstr;
3210
3211         if (sscanf(args, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
3212             == ETH_ADDR_SCAN_COUNT) {
3213                 hash = bond_hash(mac);
3214
3215                 hash_cstr = xasprintf("%u", hash);
3216                 unixctl_command_reply(conn, 200, hash_cstr);
3217                 free(hash_cstr);
3218         } else {
3219                 unixctl_command_reply(conn, 501, "invalid mac");
3220         }
3221 }
3222
3223 static void
3224 bond_init(void)
3225 {
3226     unixctl_command_register("bond/list", bond_unixctl_list, NULL);
3227     unixctl_command_register("bond/show", bond_unixctl_show, NULL);
3228     unixctl_command_register("bond/migrate", bond_unixctl_migrate, NULL);
3229     unixctl_command_register("bond/set-active-slave",
3230                              bond_unixctl_set_active_slave, NULL);
3231     unixctl_command_register("bond/enable-slave", bond_unixctl_enable_slave,
3232                              NULL);
3233     unixctl_command_register("bond/disable-slave", bond_unixctl_disable_slave,
3234                              NULL);
3235     unixctl_command_register("bond/hash", bond_unixctl_hash, NULL);
3236 }
3237 \f
3238 /* Port functions. */
3239
3240 static struct port *
3241 port_create(struct bridge *br, const char *name)
3242 {
3243     struct port *port;
3244
3245     port = xzalloc(sizeof *port);
3246     port->bridge = br;
3247     port->port_idx = br->n_ports;
3248     port->vlan = -1;
3249     port->trunks = NULL;
3250     port->name = xstrdup(name);
3251     port->active_iface = -1;
3252
3253     if (br->n_ports >= br->allocated_ports) {
3254         br->ports = x2nrealloc(br->ports, &br->allocated_ports,
3255                                sizeof *br->ports);
3256     }
3257     br->ports[br->n_ports++] = port;
3258     shash_add_assert(&br->port_by_name, port->name, port);
3259
3260     VLOG_INFO("created port %s on bridge %s", port->name, br->name);
3261     bridge_flush(br);
3262
3263     return port;
3264 }
3265
3266 static const char *
3267 get_port_other_config(const struct ovsrec_port *port, const char *key,
3268                       const char *default_value)
3269 {
3270     const char *value;
3271
3272     value = get_ovsrec_key_value(&port->header_, &ovsrec_port_col_other_config,
3273                                  key);
3274     return value ? value : default_value;
3275 }
3276
3277 static void
3278 port_del_ifaces(struct port *port, const struct ovsrec_port *cfg)
3279 {
3280     struct shash new_ifaces;
3281     size_t i;
3282
3283     /* Collect list of new interfaces. */
3284     shash_init(&new_ifaces);
3285     for (i = 0; i < cfg->n_interfaces; i++) {
3286         const char *name = cfg->interfaces[i]->name;
3287         shash_add_once(&new_ifaces, name, NULL);
3288     }
3289
3290     /* Get rid of deleted interfaces. */
3291     for (i = 0; i < port->n_ifaces; ) {
3292         if (!shash_find(&new_ifaces, cfg->interfaces[i]->name)) {
3293             iface_destroy(port->ifaces[i]);
3294         } else {
3295             i++;
3296         }
3297     }
3298
3299     shash_destroy(&new_ifaces);
3300 }
3301
3302 static void
3303 port_reconfigure(struct port *port, const struct ovsrec_port *cfg)
3304 {
3305     struct shash new_ifaces;
3306     long long int next_rebalance;
3307     unsigned long *trunks;
3308     int vlan;
3309     size_t i;
3310
3311     port->cfg = cfg;
3312
3313     /* Update settings. */
3314     port->updelay = cfg->bond_updelay;
3315     if (port->updelay < 0) {
3316         port->updelay = 0;
3317     }
3318     port->updelay = cfg->bond_downdelay;
3319     if (port->downdelay < 0) {
3320         port->downdelay = 0;
3321     }
3322     port->bond_rebalance_interval = atoi(
3323         get_port_other_config(cfg, "bond-rebalance-interval", "10000"));
3324     if (port->bond_rebalance_interval < 1000) {
3325         port->bond_rebalance_interval = 1000;
3326     }
3327     next_rebalance = time_msec() + port->bond_rebalance_interval;
3328     if (port->bond_next_rebalance > next_rebalance) {
3329         port->bond_next_rebalance = next_rebalance;
3330     }
3331
3332     /* Add new interfaces and update 'cfg' member of existing ones. */
3333     shash_init(&new_ifaces);
3334     for (i = 0; i < cfg->n_interfaces; i++) {
3335         const struct ovsrec_interface *if_cfg = cfg->interfaces[i];
3336         struct iface *iface;
3337
3338         if (!shash_add_once(&new_ifaces, if_cfg->name, NULL)) {
3339             VLOG_WARN("port %s: %s specified twice as port interface",
3340                       port->name, if_cfg->name);
3341             continue;
3342         }
3343
3344         iface = iface_lookup(port->bridge, if_cfg->name);
3345         if (iface) {
3346             if (iface->port != port) {
3347                 VLOG_ERR("bridge %s: %s interface is on multiple ports, "
3348                          "removing from %s",
3349                          port->bridge->name, if_cfg->name, iface->port->name);
3350                 continue;
3351             }
3352             iface->cfg = if_cfg;
3353         } else {
3354             iface_create(port, if_cfg);
3355         }
3356     }
3357     shash_destroy(&new_ifaces);
3358
3359     /* Get VLAN tag. */
3360     vlan = -1;
3361     if (cfg->tag) {
3362         if (port->n_ifaces < 2) {
3363             vlan = *cfg->tag;
3364             if (vlan >= 0 && vlan <= 4095) {
3365                 VLOG_DBG("port %s: assigning VLAN tag %d", port->name, vlan);
3366             } else {
3367                 vlan = -1;
3368             }
3369         } else {
3370             /* It's possible that bonded, VLAN-tagged ports make sense.  Maybe
3371              * they even work as-is.  But they have not been tested. */
3372             VLOG_WARN("port %s: VLAN tags not supported on bonded ports",
3373                       port->name);
3374         }
3375     }
3376     if (port->vlan != vlan) {
3377         port->vlan = vlan;
3378         bridge_flush(port->bridge);
3379     }
3380
3381     /* Get trunked VLANs. */
3382     trunks = NULL;
3383     if (vlan < 0 && cfg->n_trunks) {
3384         size_t n_errors;
3385         size_t i;
3386
3387         trunks = bitmap_allocate(4096);
3388         n_errors = 0;
3389         for (i = 0; i < cfg->n_trunks; i++) {
3390             int trunk = cfg->trunks[i];
3391             if (trunk >= 0) {
3392                 bitmap_set1(trunks, trunk);
3393             } else {
3394                 n_errors++;
3395             }
3396         }
3397         if (n_errors) {
3398             VLOG_ERR("port %s: invalid values for %zu trunk VLANs",
3399                      port->name, cfg->n_trunks);
3400         }
3401         if (n_errors == cfg->n_trunks) {
3402             VLOG_ERR("port %s: no valid trunks, trunking all VLANs",
3403                      port->name);
3404             bitmap_free(trunks);
3405             trunks = NULL;
3406         }
3407     } else if (vlan >= 0 && cfg->n_trunks) {
3408         VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan",
3409                  port->name);
3410     }
3411     if (trunks == NULL
3412         ? port->trunks != NULL
3413         : port->trunks == NULL || !bitmap_equal(trunks, port->trunks, 4096)) {
3414         bridge_flush(port->bridge);
3415     }
3416     bitmap_free(port->trunks);
3417     port->trunks = trunks;
3418 }
3419
3420 static void
3421 port_destroy(struct port *port)
3422 {
3423     if (port) {
3424         struct bridge *br = port->bridge;
3425         struct port *del;
3426         int i;
3427
3428         proc_net_compat_update_vlan(port->name, NULL, 0);
3429         proc_net_compat_update_bond(port->name, NULL);
3430
3431         for (i = 0; i < MAX_MIRRORS; i++) {
3432             struct mirror *m = br->mirrors[i];
3433             if (m && m->out_port == port) {
3434                 mirror_destroy(m);
3435             }
3436         }
3437
3438         while (port->n_ifaces > 0) {
3439             iface_destroy(port->ifaces[port->n_ifaces - 1]);
3440         }
3441
3442         shash_find_and_delete_assert(&br->port_by_name, port->name);
3443
3444         del = br->ports[port->port_idx] = br->ports[--br->n_ports];
3445         del->port_idx = port->port_idx;
3446
3447         free(port->ifaces);
3448         bitmap_free(port->trunks);
3449         free(port->name);
3450         free(port);
3451         bridge_flush(br);
3452     }
3453 }
3454
3455 static struct port *
3456 port_from_xf_ifidx(const struct bridge *br, uint16_t xf_ifidx)
3457 {
3458     struct iface *iface = iface_from_xf_ifidx(br, xf_ifidx);
3459     return iface ? iface->port : NULL;
3460 }
3461
3462 static struct port *
3463 port_lookup(const struct bridge *br, const char *name)
3464 {
3465     return shash_find_data(&br->port_by_name, name);
3466 }
3467
3468 static struct iface *
3469 port_lookup_iface(const struct port *port, const char *name)
3470 {
3471     struct iface *iface = iface_lookup(port->bridge, name);
3472     return iface && iface->port == port ? iface : NULL;
3473 }
3474
3475 static void
3476 port_update_bonding(struct port *port)
3477 {
3478     if (port->n_ifaces < 2) {
3479         /* Not a bonded port. */
3480         if (port->bond_hash) {
3481             free(port->bond_hash);
3482             port->bond_hash = NULL;
3483             port->bond_compat_is_stale = true;
3484             port->bond_fake_iface = false;
3485         }
3486     } else {
3487         if (!port->bond_hash) {
3488             size_t i;
3489
3490             port->bond_hash = xcalloc(BOND_MASK + 1, sizeof *port->bond_hash);
3491             for (i = 0; i <= BOND_MASK; i++) {
3492                 struct bond_entry *e = &port->bond_hash[i];
3493                 e->iface_idx = -1;
3494                 e->tx_bytes = 0;
3495             }
3496             port->no_ifaces_tag = tag_create_random();
3497             bond_choose_active_iface(port);
3498             port->bond_next_rebalance
3499                 = time_msec() + port->bond_rebalance_interval;
3500
3501             if (port->cfg->bond_fake_iface) {
3502                 port->bond_next_fake_iface_update = time_msec();
3503             }
3504         }
3505         port->bond_compat_is_stale = true;
3506         port->bond_fake_iface = port->cfg->bond_fake_iface;
3507     }
3508 }
3509
3510 static void
3511 port_update_bond_compat(struct port *port)
3512 {
3513     struct compat_bond_hash compat_hashes[BOND_MASK + 1];
3514     struct compat_bond bond;
3515     size_t i;
3516
3517     if (port->n_ifaces < 2) {
3518         proc_net_compat_update_bond(port->name, NULL);
3519         return;
3520     }
3521
3522     bond.up = false;
3523     bond.updelay = port->updelay;
3524     bond.downdelay = port->downdelay;
3525
3526     bond.n_hashes = 0;
3527     bond.hashes = compat_hashes;
3528     if (port->bond_hash) {
3529         const struct bond_entry *e;
3530         for (e = port->bond_hash; e <= &port->bond_hash[BOND_MASK]; e++) {
3531             if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
3532                 struct compat_bond_hash *cbh = &bond.hashes[bond.n_hashes++];
3533                 cbh->hash = e - port->bond_hash;
3534                 cbh->netdev_name = port->ifaces[e->iface_idx]->name;
3535             }
3536         }
3537     }
3538
3539     bond.n_slaves = port->n_ifaces;
3540     bond.slaves = xmalloc(port->n_ifaces * sizeof *bond.slaves);
3541     for (i = 0; i < port->n_ifaces; i++) {
3542         struct iface *iface = port->ifaces[i];
3543         struct compat_bond_slave *slave = &bond.slaves[i];
3544         slave->name = iface->name;
3545
3546         /* We need to make the same determination as the Linux bonding
3547          * code to determine whether a slave should be consider "up".
3548          * The Linux function bond_miimon_inspect() supports four 
3549          * BOND_LINK_* states:
3550          *      
3551          *    - BOND_LINK_UP: carrier detected, updelay has passed.
3552          *    - BOND_LINK_FAIL: carrier lost, downdelay in progress.
3553          *    - BOND_LINK_DOWN: carrier lost, downdelay has passed.
3554          *    - BOND_LINK_BACK: carrier detected, updelay in progress.
3555          *
3556          * The function bond_info_show_slave() only considers BOND_LINK_UP 
3557          * to be "up" and anything else to be "down".
3558          */
3559         slave->up = iface->enabled && iface->delay_expires == LLONG_MAX;
3560         if (slave->up) {
3561             bond.up = true;
3562         }
3563         netdev_get_etheraddr(iface->netdev, slave->mac);
3564     }
3565
3566     if (port->bond_fake_iface) {
3567         struct netdev *bond_netdev;
3568
3569         if (!netdev_open_default(port->name, &bond_netdev)) {
3570             if (bond.up) {
3571                 netdev_turn_flags_on(bond_netdev, NETDEV_UP, true);
3572             } else {
3573                 netdev_turn_flags_off(bond_netdev, NETDEV_UP, true);
3574             }
3575             netdev_close(bond_netdev);
3576         }
3577     }
3578
3579     proc_net_compat_update_bond(port->name, &bond);
3580     free(bond.slaves);
3581 }
3582
3583 static void
3584 port_update_vlan_compat(struct port *port)
3585 {
3586     struct bridge *br = port->bridge;
3587     char *vlandev_name = NULL;
3588
3589     if (port->vlan > 0) {
3590         /* Figure out the name that the VLAN device should actually have, if it
3591          * existed.  This takes some work because the VLAN device would not
3592          * have port->name in its name; rather, it would have the trunk port's
3593          * name, and 'port' would be attached to a bridge that also had the
3594          * VLAN device one of its ports.  So we need to find a trunk port that
3595          * includes port->vlan.
3596          *
3597          * There might be more than one candidate.  This doesn't happen on
3598          * XenServer, so if it happens we just pick the first choice in
3599          * alphabetical order instead of creating multiple VLAN devices. */
3600         size_t i;
3601         for (i = 0; i < br->n_ports; i++) {
3602             struct port *p = br->ports[i];
3603             if (port_trunks_vlan(p, port->vlan)
3604                 && p->n_ifaces
3605                 && (!vlandev_name || strcmp(p->name, vlandev_name) <= 0))
3606             {
3607                 uint8_t ea[ETH_ADDR_LEN];
3608                 netdev_get_etheraddr(p->ifaces[0]->netdev, ea);
3609                 if (!eth_addr_is_multicast(ea) &&
3610                     !eth_addr_is_reserved(ea) &&
3611                     !eth_addr_is_zero(ea)) {
3612                     vlandev_name = p->name;
3613                 }
3614             }
3615         }
3616     }
3617     proc_net_compat_update_vlan(port->name, vlandev_name, port->vlan);
3618 }
3619 \f
3620 /* Interface functions. */
3621
3622 static struct iface *
3623 iface_create(struct port *port, const struct ovsrec_interface *if_cfg)
3624 {
3625     struct bridge *br = port->bridge;
3626     struct iface *iface;
3627     char *name = if_cfg->name;
3628     int error;
3629
3630     iface = xzalloc(sizeof *iface);
3631     iface->port = port;
3632     iface->port_ifidx = port->n_ifaces;
3633     iface->name = xstrdup(name);
3634     iface->xf_ifidx = -1;
3635     iface->tag = tag_create_random();
3636     iface->delay_expires = LLONG_MAX;
3637     iface->netdev = NULL;
3638     iface->cfg = if_cfg;
3639
3640     shash_add_assert(&br->iface_by_name, iface->name, iface);
3641
3642     /* Attempt to create the network interface in case it doesn't exist yet. */
3643     if (!iface_is_internal(br, iface->name)) {
3644         error = set_up_iface(if_cfg, iface, true);
3645         if (error) {
3646             VLOG_WARN("could not create iface %s: %s", iface->name,
3647                       strerror(error));
3648
3649             shash_find_and_delete_assert(&br->iface_by_name, iface->name);
3650             free(iface->name);
3651             free(iface);
3652             return NULL;
3653         }
3654     }
3655
3656     if (port->n_ifaces >= port->allocated_ifaces) {
3657         port->ifaces = x2nrealloc(port->ifaces, &port->allocated_ifaces,
3658                                   sizeof *port->ifaces);
3659     }
3660     port->ifaces[port->n_ifaces++] = iface;
3661     if (port->n_ifaces > 1) {
3662         br->has_bonded_ports = true;
3663     }
3664
3665     VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
3666
3667     bridge_flush(br);
3668
3669     return iface;
3670 }
3671
3672 static void
3673 iface_destroy(struct iface *iface)
3674 {
3675     if (iface) {
3676         struct port *port = iface->port;
3677         struct bridge *br = port->bridge;
3678         bool del_active = port->active_iface == iface->port_ifidx;
3679         struct iface *del;
3680
3681         shash_find_and_delete_assert(&br->iface_by_name, iface->name);
3682
3683         if (iface->xf_ifidx >= 0) {
3684             port_array_set(&br->ifaces, iface->xf_ifidx, NULL);
3685         }
3686
3687         del = port->ifaces[iface->port_ifidx] = port->ifaces[--port->n_ifaces];
3688         del->port_ifidx = iface->port_ifidx;
3689
3690         netdev_close(iface->netdev);
3691
3692         if (del_active) {
3693             ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
3694             bond_choose_active_iface(port);
3695             bond_send_learning_packets(port);
3696         }
3697
3698         free(iface->name);
3699         free(iface);
3700
3701         bridge_flush(port->bridge);
3702     }
3703 }
3704
3705 static struct iface *
3706 iface_lookup(const struct bridge *br, const char *name)
3707 {
3708     return shash_find_data(&br->iface_by_name, name);
3709 }
3710
3711 static struct iface *
3712 iface_from_xf_ifidx(const struct bridge *br, uint16_t xf_ifidx)
3713 {
3714     return port_array_get(&br->ifaces, xf_ifidx);
3715 }
3716
3717 /* Returns true if 'iface' is the name of an "internal" interface on bridge
3718  * 'br', that is, an interface that is entirely simulated within the datapath.
3719  * The local port (XFLOWP_LOCAL) is always an internal interface.  Other local
3720  * interfaces are created by setting "iface.<iface>.internal = true".
3721  *
3722  * In addition, we have a kluge-y feature that creates an internal port with
3723  * the name of a bonded port if "bonding.<bondname>.fake-iface = true" is set.
3724  * This feature needs to go away in the long term.  Until then, this is one
3725  * reason why this function takes a name instead of a struct iface: the fake
3726  * interfaces created this way do not have a struct iface. */
3727 static bool
3728 iface_is_internal(const struct bridge *br, const char *if_name)
3729 {
3730     struct iface *iface;
3731     struct port *port;
3732
3733     if (!strcmp(if_name, br->name)) {
3734         return true;
3735     }
3736
3737     iface = iface_lookup(br, if_name);
3738     if (iface && !strcmp(iface->cfg->type, "internal")) {
3739         return true;
3740     }
3741
3742     port = port_lookup(br, if_name);
3743     if (port && port->n_ifaces > 1 && port->cfg->bond_fake_iface) {
3744         return true;
3745     }
3746     return false;
3747 }
3748
3749 /* Set Ethernet address of 'iface', if one is specified in the configuration
3750  * file. */
3751 static void
3752 iface_set_mac(struct iface *iface)
3753 {
3754     uint8_t ea[ETH_ADDR_LEN];
3755
3756     if (iface->cfg->mac && eth_addr_from_string(iface->cfg->mac, ea)) {
3757         if (eth_addr_is_multicast(ea)) {
3758             VLOG_ERR("interface %s: cannot set MAC to multicast address",
3759                      iface->name);
3760         } else if (iface->xf_ifidx == XFLOWP_LOCAL) {
3761             VLOG_ERR("ignoring iface.%s.mac; use bridge.%s.mac instead",
3762                      iface->name, iface->name);
3763         } else {
3764             int error = netdev_set_etheraddr(iface->netdev, ea);
3765             if (error) {
3766                 VLOG_ERR("interface %s: setting MAC failed (%s)",
3767                          iface->name, strerror(error));
3768             }
3769         }
3770     }
3771 }
3772
3773 static void
3774 shash_from_ovs_idl_map(char **keys, char **values, size_t n,
3775                        struct shash *shash)
3776 {
3777     size_t i;
3778
3779     shash_init(shash);
3780     for (i = 0; i < n; i++) {
3781         shash_add(shash, keys[i], values[i]);
3782     }
3783 }
3784
3785 struct iface_delete_queues_cbdata {
3786     struct netdev *netdev;
3787     const struct ovsdb_datum *queues;
3788 };
3789
3790 static bool
3791 queue_ids_include(const struct ovsdb_datum *queues, int64_t target)
3792 {
3793     union ovsdb_atom atom;
3794
3795     atom.integer = target;
3796     return ovsdb_datum_find_key(queues, &atom, OVSDB_TYPE_INTEGER) != UINT_MAX;
3797 }
3798
3799 static void
3800 iface_delete_queues(unsigned int queue_id,
3801                     const struct shash *details OVS_UNUSED, void *cbdata_)
3802 {
3803     struct iface_delete_queues_cbdata *cbdata = cbdata_;
3804
3805     if (!queue_ids_include(cbdata->queues, queue_id)) {
3806         netdev_delete_queue(cbdata->netdev, queue_id);
3807     }
3808 }
3809
3810 static void
3811 iface_update_qos(struct iface *iface, const struct ovsrec_qos *qos)
3812 {
3813     if (!qos || qos->type[0] == '\0') {
3814         netdev_set_qos(iface->netdev, NULL, NULL);
3815     } else {
3816         struct iface_delete_queues_cbdata cbdata;
3817         struct shash details;
3818         size_t i;
3819
3820         /* Configure top-level Qos for 'iface'. */
3821         shash_from_ovs_idl_map(qos->key_other_config, qos->value_other_config,
3822                                qos->n_other_config, &details);
3823         netdev_set_qos(iface->netdev, qos->type, &details);
3824         shash_destroy(&details);
3825
3826         /* Deconfigure queues that were deleted. */
3827         cbdata.netdev = iface->netdev;
3828         cbdata.queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER,
3829                                               OVSDB_TYPE_UUID);
3830         netdev_dump_queues(iface->netdev, iface_delete_queues, &cbdata);
3831
3832         /* Configure queues for 'iface'. */
3833         for (i = 0; i < qos->n_queues; i++) {
3834             const struct ovsrec_queue *queue = qos->value_queues[i];
3835             unsigned int queue_id = qos->key_queues[i];
3836
3837             shash_from_ovs_idl_map(queue->key_other_config,
3838                                    queue->value_other_config,
3839                                    queue->n_other_config, &details);
3840             netdev_set_queue(iface->netdev, queue_id, &details);
3841             shash_destroy(&details);
3842         }
3843     }
3844 }
3845 \f
3846 /* Port mirroring. */
3847
3848 static struct mirror *
3849 mirror_find_by_uuid(struct bridge *br, const struct uuid *uuid)
3850 {
3851     int i;
3852
3853     for (i = 0; i < MAX_MIRRORS; i++) {
3854         struct mirror *m = br->mirrors[i];
3855         if (m && uuid_equals(uuid, &m->uuid)) {
3856             return m;
3857         }
3858     }
3859     return NULL;
3860 }
3861
3862 static void
3863 mirror_reconfigure(struct bridge *br)
3864 {
3865     unsigned long *rspan_vlans;
3866     int i;
3867
3868     /* Get rid of deleted mirrors. */
3869     for (i = 0; i < MAX_MIRRORS; i++) {
3870         struct mirror *m = br->mirrors[i];
3871         if (m) {
3872             const struct ovsdb_datum *mc;
3873             union ovsdb_atom atom;
3874
3875             mc = ovsrec_bridge_get_mirrors(br->cfg, OVSDB_TYPE_UUID);
3876             atom.uuid = br->mirrors[i]->uuid;
3877             if (ovsdb_datum_find_key(mc, &atom, OVSDB_TYPE_UUID) == UINT_MAX) {
3878                 mirror_destroy(m);
3879             }
3880         }
3881     }
3882
3883     /* Add new mirrors and reconfigure existing ones. */
3884     for (i = 0; i < br->cfg->n_mirrors; i++) {
3885         struct ovsrec_mirror *cfg = br->cfg->mirrors[i];
3886         struct mirror *m = mirror_find_by_uuid(br, &cfg->header_.uuid);
3887         if (m) {
3888             mirror_reconfigure_one(m, cfg);
3889         } else {
3890             mirror_create(br, cfg);
3891         }
3892     }
3893
3894     /* Update port reserved status. */
3895     for (i = 0; i < br->n_ports; i++) {
3896         br->ports[i]->is_mirror_output_port = false;
3897     }
3898     for (i = 0; i < MAX_MIRRORS; i++) {
3899         struct mirror *m = br->mirrors[i];
3900         if (m && m->out_port) {
3901             m->out_port->is_mirror_output_port = true;
3902         }
3903     }
3904
3905     /* Update flooded vlans (for RSPAN). */
3906     rspan_vlans = NULL;
3907     if (br->cfg->n_flood_vlans) {
3908         rspan_vlans = bitmap_allocate(4096);
3909
3910         for (i = 0; i < br->cfg->n_flood_vlans; i++) {
3911             int64_t vlan = br->cfg->flood_vlans[i];
3912             if (vlan >= 0 && vlan < 4096) {
3913                 bitmap_set1(rspan_vlans, vlan);
3914                 VLOG_INFO("bridge %s: disabling learning on vlan %"PRId64,
3915                           br->name, vlan);
3916             } else {
3917                 VLOG_ERR("bridge %s: invalid value %"PRId64 "for flood VLAN",
3918                          br->name, vlan);
3919             }
3920         }
3921     }
3922     if (mac_learning_set_flood_vlans(br->ml, rspan_vlans)) {
3923         bridge_flush(br);
3924     }
3925 }
3926
3927 static void
3928 mirror_create(struct bridge *br, struct ovsrec_mirror *cfg)
3929 {
3930     struct mirror *m;
3931     size_t i;
3932
3933     for (i = 0; ; i++) {
3934         if (i >= MAX_MIRRORS) {
3935             VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
3936                       "cannot create %s", br->name, MAX_MIRRORS, cfg->name);
3937             return;
3938         }
3939         if (!br->mirrors[i]) {
3940             break;
3941         }
3942     }
3943
3944     VLOG_INFO("created port mirror %s on bridge %s", cfg->name, br->name);
3945     bridge_flush(br);
3946
3947     br->mirrors[i] = m = xzalloc(sizeof *m);
3948     m->bridge = br;
3949     m->idx = i;
3950     m->name = xstrdup(cfg->name);
3951     shash_init(&m->src_ports);
3952     shash_init(&m->dst_ports);
3953     m->vlans = NULL;
3954     m->n_vlans = 0;
3955     m->out_vlan = -1;
3956     m->out_port = NULL;
3957
3958     mirror_reconfigure_one(m, cfg);
3959 }
3960
3961 static void
3962 mirror_destroy(struct mirror *m)
3963 {
3964     if (m) {
3965         struct bridge *br = m->bridge;
3966         size_t i;
3967
3968         for (i = 0; i < br->n_ports; i++) {
3969             br->ports[i]->src_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3970             br->ports[i]->dst_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
3971         }
3972
3973         shash_destroy(&m->src_ports);
3974         shash_destroy(&m->dst_ports);
3975         free(m->vlans);
3976
3977         m->bridge->mirrors[m->idx] = NULL;
3978         free(m->name);
3979         free(m);
3980
3981         bridge_flush(br);
3982     }
3983 }
3984
3985 static void
3986 mirror_collect_ports(struct mirror *m, struct ovsrec_port **ports, int n_ports,
3987                      struct shash *names)
3988 {
3989     size_t i;
3990
3991     for (i = 0; i < n_ports; i++) {
3992         const char *name = ports[i]->name;
3993         if (port_lookup(m->bridge, name)) {
3994             shash_add_once(names, name, NULL);
3995         } else {
3996             VLOG_WARN("bridge %s: mirror %s cannot match on nonexistent "
3997                       "port %s", m->bridge->name, m->name, name);
3998         }
3999     }
4000 }
4001
4002 static size_t
4003 mirror_collect_vlans(struct mirror *m, const struct ovsrec_mirror *cfg,
4004                      int **vlans)
4005 {
4006     size_t n_vlans;
4007     size_t i;
4008
4009     *vlans = xmalloc(sizeof **vlans * cfg->n_select_vlan);
4010     n_vlans = 0;
4011     for (i = 0; i < cfg->n_select_vlan; i++) {
4012         int64_t vlan = cfg->select_vlan[i];
4013         if (vlan < 0 || vlan > 4095) {
4014             VLOG_WARN("bridge %s: mirror %s selects invalid VLAN %"PRId64,
4015                       m->bridge->name, m->name, vlan);
4016         } else {
4017             (*vlans)[n_vlans++] = vlan;
4018         }
4019     }
4020     return n_vlans;
4021 }
4022
4023 static bool
4024 vlan_is_mirrored(const struct mirror *m, int vlan)
4025 {
4026     size_t i;
4027
4028     for (i = 0; i < m->n_vlans; i++) {
4029         if (m->vlans[i] == vlan) {
4030             return true;
4031         }
4032     }
4033     return false;
4034 }
4035
4036 static bool
4037 port_trunks_any_mirrored_vlan(const struct mirror *m, const struct port *p)
4038 {
4039     size_t i;
4040
4041     for (i = 0; i < m->n_vlans; i++) {
4042         if (port_trunks_vlan(p, m->vlans[i])) {
4043             return true;
4044         }
4045     }
4046     return false;
4047 }
4048
4049 static void
4050 mirror_reconfigure_one(struct mirror *m, struct ovsrec_mirror *cfg)
4051 {
4052     struct shash src_ports, dst_ports;
4053     mirror_mask_t mirror_bit;
4054     struct port *out_port;
4055     int out_vlan;
4056     size_t n_vlans;
4057     int *vlans;
4058     size_t i;
4059
4060     /* Set name. */
4061     if (strcmp(cfg->name, m->name)) {
4062         free(m->name);
4063         m->name = xstrdup(cfg->name);
4064     }
4065
4066     /* Get output port. */
4067     if (cfg->output_port) {
4068         out_port = port_lookup(m->bridge, cfg->output_port->name);
4069         if (!out_port) {
4070             VLOG_ERR("bridge %s: mirror %s outputs to port not on bridge",
4071                      m->bridge->name, m->name);
4072             mirror_destroy(m);
4073             return;
4074         }
4075         out_vlan = -1;
4076
4077         if (cfg->output_vlan) {
4078             VLOG_ERR("bridge %s: mirror %s specifies both output port and "
4079                      "output vlan; ignoring output vlan",
4080                      m->bridge->name, m->name);
4081         }
4082     } else if (cfg->output_vlan) {
4083         out_port = NULL;
4084         out_vlan = *cfg->output_vlan;
4085     } else {
4086         VLOG_ERR("bridge %s: mirror %s does not specify output; ignoring",
4087                  m->bridge->name, m->name);
4088         mirror_destroy(m);
4089         return;
4090     }
4091
4092     shash_init(&src_ports);
4093     shash_init(&dst_ports);
4094     if (cfg->select_all) {
4095         for (i = 0; i < m->bridge->n_ports; i++) {
4096             const char *name = m->bridge->ports[i]->name;
4097             shash_add_once(&src_ports, name, NULL);
4098             shash_add_once(&dst_ports, name, NULL);
4099         }
4100         vlans = NULL;
4101         n_vlans = 0;
4102     } else {
4103         /* Get ports, and drop duplicates and ports that don't exist. */
4104         mirror_collect_ports(m, cfg->select_src_port, cfg->n_select_src_port,
4105                              &src_ports);
4106         mirror_collect_ports(m, cfg->select_dst_port, cfg->n_select_dst_port,
4107                              &dst_ports);
4108
4109         /* Get all the vlans, and drop duplicate and invalid vlans. */
4110         n_vlans = mirror_collect_vlans(m, cfg, &vlans);
4111     }
4112
4113     /* Update mirror data. */
4114     if (!shash_equal_keys(&m->src_ports, &src_ports)
4115         || !shash_equal_keys(&m->dst_ports, &dst_ports)
4116         || m->n_vlans != n_vlans
4117         || memcmp(m->vlans, vlans, sizeof *vlans * n_vlans)
4118         || m->out_port != out_port
4119         || m->out_vlan != out_vlan) {
4120         bridge_flush(m->bridge);
4121     }
4122     shash_swap(&m->src_ports, &src_ports);
4123     shash_swap(&m->dst_ports, &dst_ports);
4124     free(m->vlans);
4125     m->vlans = vlans;
4126     m->n_vlans = n_vlans;
4127     m->out_port = out_port;
4128     m->out_vlan = out_vlan;
4129
4130     /* Update ports. */
4131     mirror_bit = MIRROR_MASK_C(1) << m->idx;
4132     for (i = 0; i < m->bridge->n_ports; i++) {
4133         struct port *port = m->bridge->ports[i];
4134
4135         if (shash_find(&m->src_ports, port->name)
4136             || (m->n_vlans
4137                 && (!port->vlan
4138                     ? port_trunks_any_mirrored_vlan(m, port)
4139                     : vlan_is_mirrored(m, port->vlan)))) {
4140             port->src_mirrors |= mirror_bit;
4141         } else {
4142             port->src_mirrors &= ~mirror_bit;
4143         }
4144
4145         if (shash_find(&m->dst_ports, port->name)) {
4146             port->dst_mirrors |= mirror_bit;
4147         } else {
4148             port->dst_mirrors &= ~mirror_bit;
4149         }
4150     }
4151
4152     /* Clean up. */
4153     shash_destroy(&src_ports);
4154     shash_destroy(&dst_ports);
4155 }