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