ovsdb-tool: Add commands for printing the database checksum.
[openvswitch] / vswitchd / bridge.c
1 /* Copyright (c) 2008, 2009, 2010, 2011 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 "byte-order.h"
19 #include <assert.h>
20 #include <errno.h>
21 #include <arpa/inet.h>
22 #include <ctype.h>
23 #include <inttypes.h>
24 #include <sys/socket.h>
25 #include <net/if.h>
26 #include <openflow/openflow.h>
27 #include <signal.h>
28 #include <stdlib.h>
29 #include <strings.h>
30 #include <sys/stat.h>
31 #include <sys/socket.h>
32 #include <sys/types.h>
33 #include <unistd.h>
34 #include "bitmap.h"
35 #include "cfm.h"
36 #include "classifier.h"
37 #include "coverage.h"
38 #include "daemon.h"
39 #include "dirs.h"
40 #include "dpif.h"
41 #include "dynamic-string.h"
42 #include "flow.h"
43 #include "hash.h"
44 #include "hmap.h"
45 #include "jsonrpc.h"
46 #include "list.h"
47 #include "mac-learning.h"
48 #include "netdev.h"
49 #include "netlink.h"
50 #include "odp-util.h"
51 #include "ofp-print.h"
52 #include "ofpbuf.h"
53 #include "ofproto/netflow.h"
54 #include "ofproto/ofproto.h"
55 #include "ovsdb-data.h"
56 #include "packets.h"
57 #include "poll-loop.h"
58 #include "process.h"
59 #include "sha1.h"
60 #include "shash.h"
61 #include "socket-util.h"
62 #include "stream-ssl.h"
63 #include "svec.h"
64 #include "system-stats.h"
65 #include "timeval.h"
66 #include "util.h"
67 #include "unixctl.h"
68 #include "vconn.h"
69 #include "vswitchd/vswitch-idl.h"
70 #include "xenserver.h"
71 #include "vlog.h"
72 #include "sflow_api.h"
73
74 VLOG_DEFINE_THIS_MODULE(bridge);
75
76 COVERAGE_DEFINE(bridge_flush);
77 COVERAGE_DEFINE(bridge_process_flow);
78 COVERAGE_DEFINE(bridge_process_cfm);
79 COVERAGE_DEFINE(bridge_process_lacp);
80 COVERAGE_DEFINE(bridge_reconfigure);
81 COVERAGE_DEFINE(bridge_lacp_update);
82
83 struct dst {
84     uint16_t vlan;
85     uint16_t dp_ifidx;
86 };
87
88 struct dst_set {
89     struct dst builtin[32];
90     struct dst *dsts;
91     size_t n, allocated;
92 };
93
94 static void dst_set_init(struct dst_set *);
95 static void dst_set_add(struct dst_set *, const struct dst *);
96 static void dst_set_free(struct dst_set *);
97
98 enum lacp_status {
99     LACP_CURRENT   = 0x01, /* Current State. */
100     LACP_EXPIRED   = 0x02, /* Expired State. */
101     LACP_DEFAULTED = 0x04, /* Partner is defaulted. */
102     LACP_ATTACHED  = 0x08, /* Attached. Interface may be choosen for flows. */
103 };
104
105 struct iface {
106     /* These members are always valid. */
107     struct port *port;          /* Containing port. */
108     size_t port_ifidx;          /* Index within containing port. */
109     char *name;                 /* Host network device name. */
110     tag_type tag;               /* Tag associated with this interface. */
111     long long delay_expires;    /* Time after which 'enabled' may change. */
112
113     /* These members are valid only after bridge_reconfigure() causes them to
114      * be initialized. */
115     struct hmap_node dp_ifidx_node; /* In struct bridge's "ifaces" hmap. */
116     int dp_ifidx;               /* Index within kernel datapath. */
117     struct netdev *netdev;      /* Network device. */
118     bool enabled;               /* May be chosen for flows? */
119     bool up;                    /* Is the interface up? */
120     const char *type;           /* Usually same as cfg->type. */
121     struct cfm *cfm;            /* Connectivity Fault Management */
122     const struct ovsrec_interface *cfg;
123
124     /* LACP information. */
125     enum lacp_status lacp_status;  /* LACP status. */
126     uint16_t lacp_priority;        /* LACP port priority. */
127     struct lacp_info lacp_actor;   /* LACP actor information. */
128     struct lacp_info lacp_partner; /* LACP partner information. */
129     long long int lacp_tx;         /* Next LACP message transmission time. */
130     long long int lacp_rx;         /* Next LACP message receive time. */
131 };
132
133 #define BOND_MASK 0xff
134 struct bond_entry {
135     int iface_idx;              /* Index of assigned iface, or -1 if none. */
136     uint64_t tx_bytes;          /* Count of bytes recently transmitted. */
137     tag_type iface_tag;         /* Tag associated with iface_idx. */
138 };
139
140 enum bond_mode {
141     BM_TCP, /* Transport Layer Load Balance. */
142     BM_SLB, /* Source Load Balance. */
143     BM_AB   /* Active Backup. */
144 };
145
146 #define MAX_MIRRORS 32
147 typedef uint32_t mirror_mask_t;
148 #define MIRROR_MASK_C(X) UINT32_C(X)
149 BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
150 struct mirror {
151     struct bridge *bridge;
152     size_t idx;
153     char *name;
154     struct uuid uuid;           /* UUID of this "mirror" record in database. */
155
156     /* Selection criteria. */
157     struct shash src_ports;     /* Name is port name; data is always NULL. */
158     struct shash dst_ports;     /* Name is port name; data is always NULL. */
159     int *vlans;
160     size_t n_vlans;
161
162     /* Output. */
163     struct port *out_port;
164     int out_vlan;
165 };
166
167 /* Flags for a port's lacp member. */
168 #define LACP_ACTIVE     0x01 /* LACP is in active mode. */
169 #define LACP_PASSIVE    0x02 /* LACP is in passive mode. */
170 #define LACP_NEGOTIATED 0x04 /* LACP has successfully negotiated. */
171
172 #define FLOOD_PORT ((struct port *) 1) /* The 'flood' output port. */
173 struct port {
174     struct bridge *bridge;
175     size_t port_idx;
176     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
177     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
178                                  * NULL if all VLANs are trunked. */
179     const struct ovsrec_port *cfg;
180     char *name;
181
182     /* An ordinary bridge port has 1 interface.
183      * A bridge port for bonding has at least 2 interfaces. */
184     struct iface **ifaces;
185     size_t n_ifaces, allocated_ifaces;
186
187     /* Bonding info. */
188     enum bond_mode bond_mode;   /* Type of the bond. BM_SLB is the default. */
189     int active_iface;           /* Ifidx on which bcasts accepted, or -1. */
190     tag_type active_iface_tag;  /* Tag for bcast flows. */
191     tag_type no_ifaces_tag;     /* Tag for flows when all ifaces disabled. */
192     int updelay, downdelay;     /* Delay before iface goes up/down, in ms. */
193     bool bond_fake_iface;       /* Fake a bond interface for legacy compat? */
194     bool miimon;                /* Use miimon instead of carrier? */
195     long long int bond_miimon_interval; /* Miimon status refresh interval. */
196     long long int bond_miimon_next_update; /* Time of next miimon update. */
197     long long int bond_next_fake_iface_update; /* Time of next update. */
198     struct netdev_monitor *monitor; /* Tracks carrier up/down status. */
199
200     /* LACP information. */
201     int lacp;                   /* LACP status flags. 0 if LACP is off. */
202     uint16_t lacp_key;          /* LACP aggregation key. */
203     uint16_t lacp_priority;     /* LACP system priority. */
204     bool lacp_need_update;      /* Need to update attached interfaces? */
205
206     /* SLB specific bonding info. */
207     struct bond_entry *bond_hash; /* An array of (BOND_MASK + 1) elements. */
208     int bond_rebalance_interval; /* Interval between rebalances, in ms. */
209     long long int bond_next_rebalance; /* Next rebalancing time. */
210
211     /* Port mirroring info. */
212     mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
213     mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
214     bool is_mirror_output_port; /* Does port mirroring send frames here? */
215 };
216
217 struct bridge {
218     struct list node;           /* Node in global list of bridges. */
219     char *name;                 /* User-specified arbitrary name. */
220     struct mac_learning *ml;    /* MAC learning table. */
221     uint8_t ea[ETH_ADDR_LEN];   /* Bridge Ethernet Address. */
222     uint8_t default_ea[ETH_ADDR_LEN]; /* Default MAC. */
223     const struct ovsrec_bridge *cfg;
224
225     /* OpenFlow switch processing. */
226     struct ofproto *ofproto;    /* OpenFlow switch. */
227
228     /* Kernel datapath information. */
229     struct dpif *dpif;          /* Datapath. */
230     struct hmap ifaces;         /* Contains "struct iface"s. */
231
232     /* Bridge ports. */
233     struct port **ports;
234     size_t n_ports, allocated_ports;
235     struct shash iface_by_name; /* "struct iface"s indexed by name. */
236     struct shash port_by_name;  /* "struct port"s indexed by name. */
237
238     /* Bonding. */
239     bool has_bonded_ports;
240
241     /* Flow tracking. */
242     bool flush;
243
244     /* Port mirroring. */
245     struct mirror *mirrors[MAX_MIRRORS];
246 };
247
248 /* List of all bridges. */
249 static struct list all_bridges = LIST_INITIALIZER(&all_bridges);
250
251 /* OVSDB IDL used to obtain configuration. */
252 static struct ovsdb_idl *idl;
253
254 /* Each time this timer expires, the bridge fetches systems and interface
255  * statistics and pushes them into the database. */
256 #define STATS_INTERVAL (5 * 1000) /* In milliseconds. */
257 static long long int stats_timer = LLONG_MIN;
258
259 static struct bridge *bridge_create(const struct ovsrec_bridge *br_cfg);
260 static void bridge_destroy(struct bridge *);
261 static struct bridge *bridge_lookup(const char *name);
262 static unixctl_cb_func bridge_unixctl_dump_flows;
263 static unixctl_cb_func bridge_unixctl_reconnect;
264 static int bridge_run_one(struct bridge *);
265 static size_t bridge_get_controllers(const struct bridge *br,
266                                      struct ovsrec_controller ***controllersp);
267 static void bridge_reconfigure_one(struct bridge *);
268 static void bridge_reconfigure_remotes(struct bridge *,
269                                        const struct sockaddr_in *managers,
270                                        size_t n_managers);
271 static void bridge_get_all_ifaces(const struct bridge *, struct shash *ifaces);
272 static void bridge_fetch_dp_ifaces(struct bridge *);
273 static void bridge_flush(struct bridge *);
274 static void bridge_pick_local_hw_addr(struct bridge *,
275                                       uint8_t ea[ETH_ADDR_LEN],
276                                       struct iface **hw_addr_iface);
277 static uint64_t bridge_pick_datapath_id(struct bridge *,
278                                         const uint8_t bridge_ea[ETH_ADDR_LEN],
279                                         struct iface *hw_addr_iface);
280 static struct iface *bridge_get_local_iface(struct bridge *);
281 static uint64_t dpid_from_hash(const void *, size_t nbytes);
282
283 static unixctl_cb_func bridge_unixctl_fdb_show;
284
285 static void lacp_run(struct bridge *);
286 static void lacp_wait(struct bridge *);
287 static void lacp_process_packet(const struct ofpbuf *, struct iface *);
288
289 static void bond_init(void);
290 static void bond_run(struct bridge *);
291 static void bond_wait(struct bridge *);
292 static void bond_rebalance_port(struct port *);
293 static void bond_send_learning_packets(struct port *);
294 static void bond_enable_slave(struct iface *iface, bool enable);
295
296 static struct port *port_create(struct bridge *, const char *name);
297 static void port_reconfigure(struct port *, const struct ovsrec_port *);
298 static void port_del_ifaces(struct port *, const struct ovsrec_port *);
299 static void port_destroy(struct port *);
300 static struct port *port_lookup(const struct bridge *, const char *name);
301 static struct iface *port_lookup_iface(const struct port *, const char *name);
302 static struct port *port_from_dp_ifidx(const struct bridge *,
303                                        uint16_t dp_ifidx);
304 static void port_update_bonding(struct port *);
305 static void port_update_lacp(struct port *);
306
307 static void mirror_create(struct bridge *, struct ovsrec_mirror *);
308 static void mirror_destroy(struct mirror *);
309 static void mirror_reconfigure(struct bridge *);
310 static void mirror_reconfigure_one(struct mirror *, struct ovsrec_mirror *);
311 static bool vlan_is_mirrored(const struct mirror *, int vlan);
312
313 static struct iface *iface_create(struct port *port,
314                                   const struct ovsrec_interface *if_cfg);
315 static void iface_destroy(struct iface *);
316 static struct iface *iface_lookup(const struct bridge *, const char *name);
317 static struct iface *iface_from_dp_ifidx(const struct bridge *,
318                                          uint16_t dp_ifidx);
319 static void iface_set_mac(struct iface *);
320 static void iface_set_ofport(const struct ovsrec_interface *, int64_t ofport);
321 static void iface_update_qos(struct iface *, const struct ovsrec_qos *);
322 static void iface_update_cfm(struct iface *);
323 static void iface_refresh_cfm_stats(struct iface *iface);
324 static void iface_send_packet(struct iface *, struct ofpbuf *packet);
325 static uint8_t iface_get_lacp_state(const struct iface *);
326 static void iface_get_lacp_priority(struct iface *, struct lacp_info *);
327 static void iface_set_lacp_defaulted(struct iface *);
328 static void iface_set_lacp_expired(struct iface *);
329
330 static void shash_from_ovs_idl_map(char **keys, char **values, size_t n,
331                                    struct shash *);
332 static void shash_to_ovs_idl_map(struct shash *,
333                                  char ***keys, char ***values, size_t *n);
334
335
336 /* Hooks into ofproto processing. */
337 static struct ofhooks bridge_ofhooks;
338 \f
339 /* Public functions. */
340
341 /* Initializes the bridge module, configuring it to obtain its configuration
342  * from an OVSDB server accessed over 'remote', which should be a string in a
343  * form acceptable to ovsdb_idl_create(). */
344 void
345 bridge_init(const char *remote)
346 {
347     /* Create connection to database. */
348     idl = ovsdb_idl_create(remote, &ovsrec_idl_class, true);
349
350     ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_cur_cfg);
351     ovsdb_idl_omit_alert(idl, &ovsrec_open_vswitch_col_statistics);
352     ovsdb_idl_omit(idl, &ovsrec_open_vswitch_col_external_ids);
353
354     ovsdb_idl_omit(idl, &ovsrec_bridge_col_external_ids);
355
356     ovsdb_idl_omit(idl, &ovsrec_port_col_external_ids);
357     ovsdb_idl_omit(idl, &ovsrec_port_col_fake_bridge);
358
359     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_ofport);
360     ovsdb_idl_omit_alert(idl, &ovsrec_interface_col_statistics);
361     ovsdb_idl_omit(idl, &ovsrec_interface_col_external_ids);
362
363     /* Register unixctl commands. */
364     unixctl_command_register("fdb/show", bridge_unixctl_fdb_show, NULL);
365     unixctl_command_register("bridge/dump-flows", bridge_unixctl_dump_flows,
366                              NULL);
367     unixctl_command_register("bridge/reconnect", bridge_unixctl_reconnect,
368                              NULL);
369     bond_init();
370 }
371
372 void
373 bridge_exit(void)
374 {
375     struct bridge *br, *next_br;
376
377     LIST_FOR_EACH_SAFE (br, next_br, node, &all_bridges) {
378         bridge_destroy(br);
379     }
380     ovsdb_idl_destroy(idl);
381 }
382
383 /* Performs configuration that is only necessary once at ovs-vswitchd startup,
384  * but for which the ovs-vswitchd configuration 'cfg' is required. */
385 static void
386 bridge_configure_once(const struct ovsrec_open_vswitch *cfg)
387 {
388     static bool already_configured_once;
389     struct svec bridge_names;
390     struct svec dpif_names, dpif_types;
391     size_t i;
392
393     /* Only do this once per ovs-vswitchd run. */
394     if (already_configured_once) {
395         return;
396     }
397     already_configured_once = true;
398
399     stats_timer = time_msec() + STATS_INTERVAL;
400
401     /* Get all the configured bridges' names from 'cfg' into 'bridge_names'. */
402     svec_init(&bridge_names);
403     for (i = 0; i < cfg->n_bridges; i++) {
404         svec_add(&bridge_names, cfg->bridges[i]->name);
405     }
406     svec_sort(&bridge_names);
407
408     /* Iterate over all system dpifs and delete any of them that do not appear
409      * in 'cfg'. */
410     svec_init(&dpif_names);
411     svec_init(&dpif_types);
412     dp_enumerate_types(&dpif_types);
413     for (i = 0; i < dpif_types.n; i++) {
414         size_t j;
415
416         dp_enumerate_names(dpif_types.names[i], &dpif_names);
417
418         /* Delete each dpif whose name is not in 'bridge_names'. */
419         for (j = 0; j < dpif_names.n; j++) {
420             if (!svec_contains(&bridge_names, dpif_names.names[j])) {
421                 struct dpif *dpif;
422                 int retval;
423
424                 retval = dpif_open(dpif_names.names[j], dpif_types.names[i],
425                                    &dpif);
426                 if (!retval) {
427                     dpif_delete(dpif);
428                     dpif_close(dpif);
429                 }
430             }
431         }
432     }
433     svec_destroy(&bridge_names);
434     svec_destroy(&dpif_names);
435     svec_destroy(&dpif_types);
436 }
437
438 /* Callback for iterate_and_prune_ifaces(). */
439 static bool
440 check_iface(struct bridge *br, struct iface *iface, void *aux OVS_UNUSED)
441 {
442     if (!iface->netdev) {
443         /* We already reported a related error, don't bother duplicating it. */
444         return false;
445     }
446
447     if (iface->dp_ifidx < 0) {
448         VLOG_ERR("%s interface not in %s, dropping",
449                  iface->name, dpif_name(br->dpif));
450         return false;
451     }
452
453     VLOG_DBG("%s has interface %s on port %d", dpif_name(br->dpif),
454              iface->name, iface->dp_ifidx);
455     return true;
456 }
457
458 /* Callback for iterate_and_prune_ifaces(). */
459 static bool
460 set_iface_properties(struct bridge *br OVS_UNUSED, struct iface *iface,
461                      void *aux OVS_UNUSED)
462 {
463     /* Set policing attributes. */
464     netdev_set_policing(iface->netdev,
465                         iface->cfg->ingress_policing_rate,
466                         iface->cfg->ingress_policing_burst);
467
468     /* Set MAC address of internal interfaces other than the local
469      * interface. */
470     if (iface->dp_ifidx != ODPP_LOCAL && !strcmp(iface->type, "internal")) {
471         iface_set_mac(iface);
472     }
473
474     return true;
475 }
476
477 /* Calls 'cb' for each interfaces in 'br', passing along the 'aux' argument.
478  * Deletes from 'br' all the interfaces for which 'cb' returns false, and then
479  * deletes from 'br' any ports that no longer have any interfaces. */
480 static void
481 iterate_and_prune_ifaces(struct bridge *br,
482                          bool (*cb)(struct bridge *, struct iface *,
483                                     void *aux),
484                          void *aux)
485 {
486     size_t i, j;
487
488     for (i = 0; i < br->n_ports; ) {
489         struct port *port = br->ports[i];
490         for (j = 0; j < port->n_ifaces; ) {
491             struct iface *iface = port->ifaces[j];
492             if (cb(br, iface, aux)) {
493                 j++;
494             } else {
495                 iface_set_ofport(iface->cfg, -1);
496                 iface_destroy(iface);
497             }
498         }
499
500         if (port->n_ifaces) {
501             i++;
502         } else  {
503             VLOG_ERR("%s port has no interfaces, dropping", port->name);
504             port_destroy(port);
505         }
506     }
507 }
508
509 /* Looks at the list of managers in 'ovs_cfg' and extracts their remote IP
510  * addresses and ports into '*managersp' and '*n_managersp'.  The caller is
511  * responsible for freeing '*managersp' (with free()).
512  *
513  * You may be asking yourself "why does ovs-vswitchd care?", because
514  * ovsdb-server is responsible for connecting to the managers, and ovs-vswitchd
515  * should not be and in fact is not directly involved in that.  But
516  * ovs-vswitchd needs to make sure that ovsdb-server can reach the managers, so
517  * it has to tell in-band control where the managers are to enable that.
518  * (Thus, only managers connected in-band are collected.)
519  */
520 static void
521 collect_in_band_managers(const struct ovsrec_open_vswitch *ovs_cfg,
522                          struct sockaddr_in **managersp, size_t *n_managersp)
523 {
524     struct sockaddr_in *managers = NULL;
525     size_t n_managers = 0;
526     struct shash targets;
527     size_t i;
528
529     /* Collect all of the potential targets, as the union of the "managers"
530      * column and the "targets" columns of the rows pointed to by
531      * "manager_options", excluding any that are out-of-band. */
532     shash_init(&targets);
533     for (i = 0; i < ovs_cfg->n_managers; i++) {
534         shash_add_once(&targets, ovs_cfg->managers[i], NULL);
535     }
536     for (i = 0; i < ovs_cfg->n_manager_options; i++) {
537         struct ovsrec_manager *m = ovs_cfg->manager_options[i];
538
539         if (m->connection_mode && !strcmp(m->connection_mode, "out-of-band")) {
540             shash_find_and_delete(&targets, m->target);
541         } else {
542             shash_add_once(&targets, m->target, NULL);
543         }
544     }
545
546     /* Now extract the targets' IP addresses. */
547     if (!shash_is_empty(&targets)) {
548         struct shash_node *node;
549
550         managers = xmalloc(shash_count(&targets) * sizeof *managers);
551         SHASH_FOR_EACH (node, &targets) {
552             const char *target = node->name;
553             struct sockaddr_in *sin = &managers[n_managers];
554
555             if ((!strncmp(target, "tcp:", 4)
556                  && inet_parse_active(target + 4, JSONRPC_TCP_PORT, sin)) ||
557                 (!strncmp(target, "ssl:", 4)
558                  && inet_parse_active(target + 4, JSONRPC_SSL_PORT, sin))) {
559                 n_managers++;
560             }
561         }
562     }
563     shash_destroy(&targets);
564
565     *managersp = managers;
566     *n_managersp = n_managers;
567 }
568
569 static void
570 bridge_reconfigure(const struct ovsrec_open_vswitch *ovs_cfg)
571 {
572     struct shash old_br, new_br;
573     struct shash_node *node;
574     struct bridge *br, *next;
575     struct sockaddr_in *managers;
576     size_t n_managers;
577     size_t i;
578     int sflow_bridge_number;
579
580     COVERAGE_INC(bridge_reconfigure);
581
582     collect_in_band_managers(ovs_cfg, &managers, &n_managers);
583
584     /* Collect old and new bridges. */
585     shash_init(&old_br);
586     shash_init(&new_br);
587     LIST_FOR_EACH (br, node, &all_bridges) {
588         shash_add(&old_br, br->name, br);
589     }
590     for (i = 0; i < ovs_cfg->n_bridges; i++) {
591         const struct ovsrec_bridge *br_cfg = ovs_cfg->bridges[i];
592         if (!shash_add_once(&new_br, br_cfg->name, br_cfg)) {
593             VLOG_WARN("more than one bridge named %s", br_cfg->name);
594         }
595     }
596
597     /* Get rid of deleted bridges and add new bridges. */
598     LIST_FOR_EACH_SAFE (br, next, node, &all_bridges) {
599         struct ovsrec_bridge *br_cfg = shash_find_data(&new_br, br->name);
600         if (br_cfg) {
601             br->cfg = br_cfg;
602         } else {
603             bridge_destroy(br);
604         }
605     }
606     SHASH_FOR_EACH (node, &new_br) {
607         const char *br_name = node->name;
608         const struct ovsrec_bridge *br_cfg = node->data;
609         br = shash_find_data(&old_br, br_name);
610         if (br) {
611             /* If the bridge datapath type has changed, we need to tear it
612              * down and recreate. */
613             if (strcmp(br->cfg->datapath_type, br_cfg->datapath_type)) {
614                 bridge_destroy(br);
615                 bridge_create(br_cfg);
616             }
617         } else {
618             bridge_create(br_cfg);
619         }
620     }
621     shash_destroy(&old_br);
622     shash_destroy(&new_br);
623
624     /* Reconfigure all bridges. */
625     LIST_FOR_EACH (br, node, &all_bridges) {
626         bridge_reconfigure_one(br);
627     }
628
629     /* Add and delete ports on all datapaths.
630      *
631      * The kernel will reject any attempt to add a given port to a datapath if
632      * that port already belongs to a different datapath, so we must do all
633      * port deletions before any port additions. */
634     LIST_FOR_EACH (br, node, &all_bridges) {
635         struct dpif_port_dump dump;
636         struct shash want_ifaces;
637         struct dpif_port dpif_port;
638
639         bridge_get_all_ifaces(br, &want_ifaces);
640         DPIF_PORT_FOR_EACH (&dpif_port, &dump, br->dpif) {
641             if (!shash_find(&want_ifaces, dpif_port.name)
642                 && strcmp(dpif_port.name, br->name)) {
643                 int retval = dpif_port_del(br->dpif, dpif_port.port_no);
644                 if (retval) {
645                     VLOG_ERR("failed to remove %s interface from %s: %s",
646                              dpif_port.name, dpif_name(br->dpif),
647                              strerror(retval));
648                 }
649             }
650         }
651         shash_destroy(&want_ifaces);
652     }
653     LIST_FOR_EACH (br, node, &all_bridges) {
654         struct shash cur_ifaces, want_ifaces;
655         struct dpif_port_dump dump;
656         struct dpif_port dpif_port;
657
658         /* Get the set of interfaces currently in this datapath. */
659         shash_init(&cur_ifaces);
660         DPIF_PORT_FOR_EACH (&dpif_port, &dump, br->dpif) {
661             struct dpif_port *port_info = xmalloc(sizeof *port_info);
662             dpif_port_clone(port_info, &dpif_port);
663             shash_add(&cur_ifaces, dpif_port.name, port_info);
664         }
665
666         /* Get the set of interfaces we want on this datapath. */
667         bridge_get_all_ifaces(br, &want_ifaces);
668
669         hmap_clear(&br->ifaces);
670         SHASH_FOR_EACH (node, &want_ifaces) {
671             const char *if_name = node->name;
672             struct iface *iface = node->data;
673             struct dpif_port *dpif_port;
674             const char *type;
675             int error;
676
677             type = iface ? iface->type : "internal";
678             dpif_port = shash_find_data(&cur_ifaces, if_name);
679
680             /* If we have a port or a netdev already, and it's not the type we
681              * want, then delete the port (if any) and close the netdev (if
682              * any). */
683             if ((dpif_port && strcmp(dpif_port->type, type))
684                 || (iface && iface->netdev
685                     && strcmp(type, netdev_get_type(iface->netdev)))) {
686                 if (dpif_port) {
687                     error = ofproto_port_del(br->ofproto, dpif_port->port_no);
688                     if (error) {
689                         continue;
690                     }
691                     dpif_port = NULL;
692                 }
693                 if (iface) {
694                     netdev_close(iface->netdev);
695                     iface->netdev = NULL;
696                 }
697             }
698
699             /* If the port doesn't exist or we don't have the netdev open,
700              * we need to do more work. */
701             if (!dpif_port || (iface && !iface->netdev)) {
702                 struct netdev_options options;
703                 struct netdev *netdev;
704                 struct shash args;
705
706                 /* First open the network device. */
707                 options.name = if_name;
708                 options.type = type;
709                 options.args = &args;
710                 options.ethertype = NETDEV_ETH_TYPE_NONE;
711
712                 shash_init(&args);
713                 if (iface) {
714                     shash_from_ovs_idl_map(iface->cfg->key_options,
715                                            iface->cfg->value_options,
716                                            iface->cfg->n_options, &args);
717                 }
718                 error = netdev_open(&options, &netdev);
719                 shash_destroy(&args);
720
721                 if (error) {
722                     VLOG_WARN("could not open network device %s (%s)",
723                               if_name, strerror(error));
724                     continue;
725                 }
726
727                 /* Then add the port if we haven't already. */
728                 if (!dpif_port) {
729                     error = dpif_port_add(br->dpif, netdev, NULL);
730                     if (error) {
731                         netdev_close(netdev);
732                         if (error == EFBIG) {
733                             VLOG_ERR("ran out of valid port numbers on %s",
734                                      dpif_name(br->dpif));
735                             break;
736                         } else {
737                             VLOG_ERR("failed to add %s interface to %s: %s",
738                                      if_name, dpif_name(br->dpif),
739                                      strerror(error));
740                             continue;
741                         }
742                     }
743                 }
744
745                 /* Update 'iface'. */
746                 if (iface) {
747                     iface->netdev = netdev;
748                     iface->enabled = netdev_get_carrier(iface->netdev);
749                     iface->up = iface->enabled;
750                 }
751             } else if (iface && iface->netdev) {
752                 struct shash args;
753
754                 shash_init(&args);
755                 shash_from_ovs_idl_map(iface->cfg->key_options,
756                                        iface->cfg->value_options,
757                                        iface->cfg->n_options, &args);
758                 netdev_set_config(iface->netdev, &args);
759                 shash_destroy(&args);
760             }
761         }
762         shash_destroy(&want_ifaces);
763
764         SHASH_FOR_EACH (node, &cur_ifaces) {
765             struct dpif_port *port_info = node->data;
766             dpif_port_destroy(port_info);
767             free(port_info);
768         }
769         shash_destroy(&cur_ifaces);
770     }
771     sflow_bridge_number = 0;
772     LIST_FOR_EACH (br, node, &all_bridges) {
773         uint8_t ea[8];
774         uint64_t dpid;
775         struct iface *local_iface;
776         struct iface *hw_addr_iface;
777         char *dpid_string;
778
779         bridge_fetch_dp_ifaces(br);
780
781         iterate_and_prune_ifaces(br, check_iface, NULL);
782
783         /* Pick local port hardware address, datapath ID. */
784         bridge_pick_local_hw_addr(br, ea, &hw_addr_iface);
785         local_iface = bridge_get_local_iface(br);
786         if (local_iface) {
787             int error = netdev_set_etheraddr(local_iface->netdev, ea);
788             if (error) {
789                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
790                 VLOG_ERR_RL(&rl, "bridge %s: failed to set bridge "
791                             "Ethernet address: %s",
792                             br->name, strerror(error));
793             }
794         }
795         memcpy(br->ea, ea, ETH_ADDR_LEN);
796
797         dpid = bridge_pick_datapath_id(br, ea, hw_addr_iface);
798         ofproto_set_datapath_id(br->ofproto, dpid);
799
800         dpid_string = xasprintf("%016"PRIx64, dpid);
801         ovsrec_bridge_set_datapath_id(br->cfg, dpid_string);
802         free(dpid_string);
803
804         /* Set NetFlow configuration on this bridge. */
805         if (br->cfg->netflow) {
806             struct ovsrec_netflow *nf_cfg = br->cfg->netflow;
807             struct netflow_options opts;
808
809             memset(&opts, 0, sizeof opts);
810
811             dpif_get_netflow_ids(br->dpif, &opts.engine_type, &opts.engine_id);
812             if (nf_cfg->engine_type) {
813                 opts.engine_type = *nf_cfg->engine_type;
814             }
815             if (nf_cfg->engine_id) {
816                 opts.engine_id = *nf_cfg->engine_id;
817             }
818
819             opts.active_timeout = nf_cfg->active_timeout;
820             if (!opts.active_timeout) {
821                 opts.active_timeout = -1;
822             } else if (opts.active_timeout < 0) {
823                 VLOG_WARN("bridge %s: active timeout interval set to negative "
824                           "value, using default instead (%d seconds)", br->name,
825                           NF_ACTIVE_TIMEOUT_DEFAULT);
826                 opts.active_timeout = -1;
827             }
828
829             opts.add_id_to_iface = nf_cfg->add_id_to_interface;
830             if (opts.add_id_to_iface) {
831                 if (opts.engine_id > 0x7f) {
832                     VLOG_WARN("bridge %s: netflow port mangling may conflict "
833                               "with another vswitch, choose an engine id less "
834                               "than 128", br->name);
835                 }
836                 if (br->n_ports > 508) {
837                     VLOG_WARN("bridge %s: netflow port mangling will conflict "
838                               "with another port when more than 508 ports are "
839                               "used", br->name);
840                 }
841             }
842
843             opts.collectors.n = nf_cfg->n_targets;
844             opts.collectors.names = nf_cfg->targets;
845             if (ofproto_set_netflow(br->ofproto, &opts)) {
846                 VLOG_ERR("bridge %s: problem setting netflow collectors",
847                          br->name);
848             }
849         } else {
850             ofproto_set_netflow(br->ofproto, NULL);
851         }
852
853         /* Set sFlow configuration on this bridge. */
854         if (br->cfg->sflow) {
855             const struct ovsrec_sflow *sflow_cfg = br->cfg->sflow;
856             struct ovsrec_controller **controllers;
857             struct ofproto_sflow_options oso;
858             size_t n_controllers;
859
860             memset(&oso, 0, sizeof oso);
861
862             oso.targets.n = sflow_cfg->n_targets;
863             oso.targets.names = sflow_cfg->targets;
864
865             oso.sampling_rate = SFL_DEFAULT_SAMPLING_RATE;
866             if (sflow_cfg->sampling) {
867                 oso.sampling_rate = *sflow_cfg->sampling;
868             }
869
870             oso.polling_interval = SFL_DEFAULT_POLLING_INTERVAL;
871             if (sflow_cfg->polling) {
872                 oso.polling_interval = *sflow_cfg->polling;
873             }
874
875             oso.header_len = SFL_DEFAULT_HEADER_SIZE;
876             if (sflow_cfg->header) {
877                 oso.header_len = *sflow_cfg->header;
878             }
879
880             oso.sub_id = sflow_bridge_number++;
881             oso.agent_device = sflow_cfg->agent;
882
883             oso.control_ip = NULL;
884             n_controllers = bridge_get_controllers(br, &controllers);
885             for (i = 0; i < n_controllers; i++) {
886                 if (controllers[i]->local_ip) {
887                     oso.control_ip = controllers[i]->local_ip;
888                     break;
889                 }
890             }
891             ofproto_set_sflow(br->ofproto, &oso);
892
893             /* Do not destroy oso.targets because it is owned by sflow_cfg. */
894         } else {
895             ofproto_set_sflow(br->ofproto, NULL);
896         }
897
898         /* Update the controller and related settings.  It would be more
899          * straightforward to call this from bridge_reconfigure_one(), but we
900          * can't do it there for two reasons.  First, and most importantly, at
901          * that point we don't know the dp_ifidx of any interfaces that have
902          * been added to the bridge (because we haven't actually added them to
903          * the datapath).  Second, at that point we haven't set the datapath ID
904          * yet; when a controller is configured, resetting the datapath ID will
905          * immediately disconnect from the controller, so it's better to set
906          * the datapath ID before the controller. */
907         bridge_reconfigure_remotes(br, managers, n_managers);
908     }
909     LIST_FOR_EACH (br, node, &all_bridges) {
910         for (i = 0; i < br->n_ports; i++) {
911             struct port *port = br->ports[i];
912             int j;
913
914             port_update_bonding(port);
915             port_update_lacp(port);
916
917             for (j = 0; j < port->n_ifaces; j++) {
918                 iface_update_qos(port->ifaces[j], port->cfg->qos);
919             }
920         }
921     }
922     LIST_FOR_EACH (br, node, &all_bridges) {
923         iterate_and_prune_ifaces(br, set_iface_properties, NULL);
924     }
925
926     LIST_FOR_EACH (br, node, &all_bridges) {
927         struct iface *iface;
928         HMAP_FOR_EACH (iface, dp_ifidx_node, &br->ifaces) {
929             iface_update_cfm(iface);
930         }
931     }
932
933     free(managers);
934
935     /* ovs-vswitchd has completed initialization, so allow the process that
936      * forked us to exit successfully. */
937     daemonize_complete();
938 }
939
940 static const char *
941 get_ovsrec_key_value(const struct ovsdb_idl_row *row,
942                      const struct ovsdb_idl_column *column,
943                      const char *key)
944 {
945     const struct ovsdb_datum *datum;
946     union ovsdb_atom atom;
947     unsigned int idx;
948
949     datum = ovsdb_idl_get(row, column, OVSDB_TYPE_STRING, OVSDB_TYPE_STRING);
950     atom.string = (char *) key;
951     idx = ovsdb_datum_find_key(datum, &atom, OVSDB_TYPE_STRING);
952     return idx == UINT_MAX ? NULL : datum->values[idx].string;
953 }
954
955 static const char *
956 bridge_get_other_config(const struct ovsrec_bridge *br_cfg, const char *key)
957 {
958     return get_ovsrec_key_value(&br_cfg->header_,
959                                 &ovsrec_bridge_col_other_config, key);
960 }
961
962 static void
963 bridge_pick_local_hw_addr(struct bridge *br, uint8_t ea[ETH_ADDR_LEN],
964                           struct iface **hw_addr_iface)
965 {
966     const char *hwaddr;
967     size_t i, j;
968     int error;
969
970     *hw_addr_iface = NULL;
971
972     /* Did the user request a particular MAC? */
973     hwaddr = bridge_get_other_config(br->cfg, "hwaddr");
974     if (hwaddr && eth_addr_from_string(hwaddr, ea)) {
975         if (eth_addr_is_multicast(ea)) {
976             VLOG_ERR("bridge %s: cannot set MAC address to multicast "
977                      "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
978         } else if (eth_addr_is_zero(ea)) {
979             VLOG_ERR("bridge %s: cannot set MAC address to zero", br->name);
980         } else {
981             return;
982         }
983     }
984
985     /* Otherwise choose the minimum non-local MAC address among all of the
986      * interfaces. */
987     memset(ea, 0xff, sizeof ea);
988     for (i = 0; i < br->n_ports; i++) {
989         struct port *port = br->ports[i];
990         uint8_t iface_ea[ETH_ADDR_LEN];
991         struct iface *iface;
992
993         /* Mirror output ports don't participate. */
994         if (port->is_mirror_output_port) {
995             continue;
996         }
997
998         /* Choose the MAC address to represent the port. */
999         if (port->cfg->mac && eth_addr_from_string(port->cfg->mac, iface_ea)) {
1000             /* Find the interface with this Ethernet address (if any) so that
1001              * we can provide the correct devname to the caller. */
1002             iface = NULL;
1003             for (j = 0; j < port->n_ifaces; j++) {
1004                 struct iface *candidate = port->ifaces[j];
1005                 uint8_t candidate_ea[ETH_ADDR_LEN];
1006                 if (!netdev_get_etheraddr(candidate->netdev, candidate_ea)
1007                     && eth_addr_equals(iface_ea, candidate_ea)) {
1008                     iface = candidate;
1009                 }
1010             }
1011         } else {
1012             /* Choose the interface whose MAC address will represent the port.
1013              * The Linux kernel bonding code always chooses the MAC address of
1014              * the first slave added to a bond, and the Fedora networking
1015              * scripts always add slaves to a bond in alphabetical order, so
1016              * for compatibility we choose the interface with the name that is
1017              * first in alphabetical order. */
1018             iface = port->ifaces[0];
1019             for (j = 1; j < port->n_ifaces; j++) {
1020                 struct iface *candidate = port->ifaces[j];
1021                 if (strcmp(candidate->name, iface->name) < 0) {
1022                     iface = candidate;
1023                 }
1024             }
1025
1026             /* The local port doesn't count (since we're trying to choose its
1027              * MAC address anyway). */
1028             if (iface->dp_ifidx == ODPP_LOCAL) {
1029                 continue;
1030             }
1031
1032             /* Grab MAC. */
1033             error = netdev_get_etheraddr(iface->netdev, iface_ea);
1034             if (error) {
1035                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1036                 VLOG_ERR_RL(&rl, "failed to obtain Ethernet address of %s: %s",
1037                             iface->name, strerror(error));
1038                 continue;
1039             }
1040         }
1041
1042         /* Compare against our current choice. */
1043         if (!eth_addr_is_multicast(iface_ea) &&
1044             !eth_addr_is_local(iface_ea) &&
1045             !eth_addr_is_reserved(iface_ea) &&
1046             !eth_addr_is_zero(iface_ea) &&
1047             eth_addr_compare_3way(iface_ea, ea) < 0)
1048         {
1049             memcpy(ea, iface_ea, ETH_ADDR_LEN);
1050             *hw_addr_iface = iface;
1051         }
1052     }
1053     if (eth_addr_is_multicast(ea)) {
1054         memcpy(ea, br->default_ea, ETH_ADDR_LEN);
1055         *hw_addr_iface = NULL;
1056         VLOG_WARN("bridge %s: using default bridge Ethernet "
1057                   "address "ETH_ADDR_FMT, br->name, ETH_ADDR_ARGS(ea));
1058     } else {
1059         VLOG_DBG("bridge %s: using bridge Ethernet address "ETH_ADDR_FMT,
1060                  br->name, ETH_ADDR_ARGS(ea));
1061     }
1062 }
1063
1064 /* Choose and returns the datapath ID for bridge 'br' given that the bridge
1065  * Ethernet address is 'bridge_ea'.  If 'bridge_ea' is the Ethernet address of
1066  * an interface on 'br', then that interface must be passed in as
1067  * 'hw_addr_iface'; if 'bridge_ea' was derived some other way, then
1068  * 'hw_addr_iface' must be passed in as a null pointer. */
1069 static uint64_t
1070 bridge_pick_datapath_id(struct bridge *br,
1071                         const uint8_t bridge_ea[ETH_ADDR_LEN],
1072                         struct iface *hw_addr_iface)
1073 {
1074     /*
1075      * The procedure for choosing a bridge MAC address will, in the most
1076      * ordinary case, also choose a unique MAC that we can use as a datapath
1077      * ID.  In some special cases, though, multiple bridges will end up with
1078      * the same MAC address.  This is OK for the bridges, but it will confuse
1079      * the OpenFlow controller, because each datapath needs a unique datapath
1080      * ID.
1081      *
1082      * Datapath IDs must be unique.  It is also very desirable that they be
1083      * stable from one run to the next, so that policy set on a datapath
1084      * "sticks".
1085      */
1086     const char *datapath_id;
1087     uint64_t dpid;
1088
1089     datapath_id = bridge_get_other_config(br->cfg, "datapath-id");
1090     if (datapath_id && dpid_from_string(datapath_id, &dpid)) {
1091         return dpid;
1092     }
1093
1094     if (hw_addr_iface) {
1095         int vlan;
1096         if (!netdev_get_vlan_vid(hw_addr_iface->netdev, &vlan)) {
1097             /*
1098              * A bridge whose MAC address is taken from a VLAN network device
1099              * (that is, a network device created with vconfig(8) or similar
1100              * tool) will have the same MAC address as a bridge on the VLAN
1101              * device's physical network device.
1102              *
1103              * Handle this case by hashing the physical network device MAC
1104              * along with the VLAN identifier.
1105              */
1106             uint8_t buf[ETH_ADDR_LEN + 2];
1107             memcpy(buf, bridge_ea, ETH_ADDR_LEN);
1108             buf[ETH_ADDR_LEN] = vlan >> 8;
1109             buf[ETH_ADDR_LEN + 1] = vlan;
1110             return dpid_from_hash(buf, sizeof buf);
1111         } else {
1112             /*
1113              * Assume that this bridge's MAC address is unique, since it
1114              * doesn't fit any of the cases we handle specially.
1115              */
1116         }
1117     } else {
1118         /*
1119          * A purely internal bridge, that is, one that has no non-virtual
1120          * network devices on it at all, is more difficult because it has no
1121          * natural unique identifier at all.
1122          *
1123          * When the host is a XenServer, we handle this case by hashing the
1124          * host's UUID with the name of the bridge.  Names of bridges are
1125          * persistent across XenServer reboots, although they can be reused if
1126          * an internal network is destroyed and then a new one is later
1127          * created, so this is fairly effective.
1128          *
1129          * When the host is not a XenServer, we punt by using a random MAC
1130          * address on each run.
1131          */
1132         const char *host_uuid = xenserver_get_host_uuid();
1133         if (host_uuid) {
1134             char *combined = xasprintf("%s,%s", host_uuid, br->name);
1135             dpid = dpid_from_hash(combined, strlen(combined));
1136             free(combined);
1137             return dpid;
1138         }
1139     }
1140
1141     return eth_addr_to_uint64(bridge_ea);
1142 }
1143
1144 static uint64_t
1145 dpid_from_hash(const void *data, size_t n)
1146 {
1147     uint8_t hash[SHA1_DIGEST_SIZE];
1148
1149     BUILD_ASSERT_DECL(sizeof hash >= ETH_ADDR_LEN);
1150     sha1_bytes(data, n, hash);
1151     eth_addr_mark_random(hash);
1152     return eth_addr_to_uint64(hash);
1153 }
1154
1155 static void
1156 iface_refresh_status(struct iface *iface)
1157 {
1158     struct shash sh;
1159
1160     enum netdev_flags flags;
1161     uint32_t current;
1162     int64_t bps;
1163     int mtu;
1164     int64_t mtu_64;
1165     int error;
1166
1167     shash_init(&sh);
1168
1169     if (!netdev_get_status(iface->netdev, &sh)) {
1170         size_t n;
1171         char **keys, **values;
1172
1173         shash_to_ovs_idl_map(&sh, &keys, &values, &n);
1174         ovsrec_interface_set_status(iface->cfg, keys, values, n);
1175
1176         free(keys);
1177         free(values);
1178     } else {
1179         ovsrec_interface_set_status(iface->cfg, NULL, NULL, 0);
1180     }
1181
1182     shash_destroy_free_data(&sh);
1183
1184     error = netdev_get_flags(iface->netdev, &flags);
1185     if (!error) {
1186         ovsrec_interface_set_admin_state(iface->cfg, flags & NETDEV_UP ? "up" : "down");
1187     }
1188     else {
1189         ovsrec_interface_set_admin_state(iface->cfg, NULL);
1190     }
1191
1192     error = netdev_get_features(iface->netdev, &current, NULL, NULL, NULL);
1193     if (!error) {
1194         ovsrec_interface_set_duplex(iface->cfg,
1195                                     netdev_features_is_full_duplex(current)
1196                                     ? "full" : "half");
1197         /* warning: uint64_t -> int64_t conversion */
1198         bps = netdev_features_to_bps(current);
1199         ovsrec_interface_set_link_speed(iface->cfg, &bps, 1);
1200     }
1201     else {
1202         ovsrec_interface_set_duplex(iface->cfg, NULL);
1203         ovsrec_interface_set_link_speed(iface->cfg, NULL, 0);
1204     }
1205
1206
1207     ovsrec_interface_set_link_state(iface->cfg,
1208                                     netdev_get_carrier(iface->netdev)
1209                                     ? "up" : "down");
1210
1211     error = netdev_get_mtu(iface->netdev, &mtu);
1212     if (!error && mtu != INT_MAX) {
1213         mtu_64 = mtu;
1214         ovsrec_interface_set_mtu(iface->cfg, &mtu_64, 1);
1215     }
1216     else {
1217         ovsrec_interface_set_mtu(iface->cfg, NULL, 0);
1218     }
1219 }
1220
1221 static void
1222 iface_refresh_cfm_stats(struct iface *iface)
1223 {
1224     size_t i;
1225     struct cfm *cfm;
1226     const struct ovsrec_monitor *mon;
1227
1228     mon = iface->cfg->monitor;
1229     cfm = iface->cfm;
1230
1231     if (!cfm || !mon) {
1232         return;
1233     }
1234
1235     for (i = 0; i < mon->n_remote_mps; i++) {
1236         const struct ovsrec_maintenance_point *mp;
1237         const struct remote_mp *rmp;
1238
1239         mp = mon->remote_mps[i];
1240         rmp = cfm_get_remote_mp(cfm, mp->mpid);
1241
1242         ovsrec_maintenance_point_set_fault(mp, &rmp->fault, 1);
1243     }
1244
1245     if (hmap_is_empty(&cfm->x_remote_mps)) {
1246         ovsrec_monitor_set_unexpected_remote_mpids(mon, NULL, 0);
1247     } else {
1248         size_t length;
1249         struct remote_mp *rmp;
1250         int64_t *x_remote_mps;
1251
1252         length = hmap_count(&cfm->x_remote_mps);
1253         x_remote_mps = xzalloc(length * sizeof *x_remote_mps);
1254
1255         i = 0;
1256         HMAP_FOR_EACH (rmp, node, &cfm->x_remote_mps) {
1257             x_remote_mps[i++] = rmp->mpid;
1258         }
1259
1260         ovsrec_monitor_set_unexpected_remote_mpids(mon, x_remote_mps, length);
1261         free(x_remote_mps);
1262     }
1263
1264     if (hmap_is_empty(&cfm->x_remote_maids)) {
1265         ovsrec_monitor_set_unexpected_remote_maids(mon, NULL, 0);
1266     } else {
1267         size_t length;
1268         char **x_remote_maids;
1269         struct remote_maid *rmaid;
1270
1271         length = hmap_count(&cfm->x_remote_maids);
1272         x_remote_maids = xzalloc(length * sizeof *x_remote_maids);
1273
1274         i = 0;
1275         HMAP_FOR_EACH (rmaid, node, &cfm->x_remote_maids) {
1276             size_t j;
1277
1278             x_remote_maids[i] = xzalloc(CCM_MAID_LEN * 2 + 1);
1279
1280             for (j = 0; j < CCM_MAID_LEN; j++) {
1281                  snprintf(&x_remote_maids[i][j * 2], 3, "%02hhx",
1282                           rmaid->maid[j]);
1283             }
1284             i++;
1285         }
1286         ovsrec_monitor_set_unexpected_remote_maids(mon, x_remote_maids, length);
1287
1288         for (i = 0; i < length; i++) {
1289             free(x_remote_maids[i]);
1290         }
1291         free(x_remote_maids);
1292     }
1293
1294     ovsrec_monitor_set_fault(mon, &cfm->fault, 1);
1295 }
1296
1297 static void
1298 iface_refresh_stats(struct iface *iface)
1299 {
1300     struct iface_stat {
1301         char *name;
1302         int offset;
1303     };
1304     static const struct iface_stat iface_stats[] = {
1305         { "rx_packets", offsetof(struct netdev_stats, rx_packets) },
1306         { "tx_packets", offsetof(struct netdev_stats, tx_packets) },
1307         { "rx_bytes", offsetof(struct netdev_stats, rx_bytes) },
1308         { "tx_bytes", offsetof(struct netdev_stats, tx_bytes) },
1309         { "rx_dropped", offsetof(struct netdev_stats, rx_dropped) },
1310         { "tx_dropped", offsetof(struct netdev_stats, tx_dropped) },
1311         { "rx_errors", offsetof(struct netdev_stats, rx_errors) },
1312         { "tx_errors", offsetof(struct netdev_stats, tx_errors) },
1313         { "rx_frame_err", offsetof(struct netdev_stats, rx_frame_errors) },
1314         { "rx_over_err", offsetof(struct netdev_stats, rx_over_errors) },
1315         { "rx_crc_err", offsetof(struct netdev_stats, rx_crc_errors) },
1316         { "collisions", offsetof(struct netdev_stats, collisions) },
1317     };
1318     enum { N_STATS = ARRAY_SIZE(iface_stats) };
1319     const struct iface_stat *s;
1320
1321     char *keys[N_STATS];
1322     int64_t values[N_STATS];
1323     int n;
1324
1325     struct netdev_stats stats;
1326
1327     /* Intentionally ignore return value, since errors will set 'stats' to
1328      * all-1s, and we will deal with that correctly below. */
1329     netdev_get_stats(iface->netdev, &stats);
1330
1331     n = 0;
1332     for (s = iface_stats; s < &iface_stats[N_STATS]; s++) {
1333         uint64_t value = *(uint64_t *) (((char *) &stats) + s->offset);
1334         if (value != UINT64_MAX) {
1335             keys[n] = s->name;
1336             values[n] = value;
1337             n++;
1338         }
1339     }
1340
1341     ovsrec_interface_set_statistics(iface->cfg, keys, values, n);
1342 }
1343
1344 static void
1345 refresh_system_stats(const struct ovsrec_open_vswitch *cfg)
1346 {
1347     struct ovsdb_datum datum;
1348     struct shash stats;
1349
1350     shash_init(&stats);
1351     get_system_stats(&stats);
1352
1353     ovsdb_datum_from_shash(&datum, &stats);
1354     ovsdb_idl_txn_write(&cfg->header_, &ovsrec_open_vswitch_col_statistics,
1355                         &datum);
1356 }
1357
1358 static inline const char *
1359 nx_role_to_str(enum nx_role role)
1360 {
1361     switch (role) {
1362     case NX_ROLE_OTHER:
1363         return "other";
1364     case NX_ROLE_MASTER:
1365         return "master";
1366     case NX_ROLE_SLAVE:
1367         return "slave";
1368     default:
1369         return "*** INVALID ROLE ***";
1370     }
1371 }
1372
1373 static void
1374 bridge_refresh_controller_status(const struct bridge *br)
1375 {
1376     struct shash info;
1377     const struct ovsrec_controller *cfg;
1378
1379     ofproto_get_ofproto_controller_info(br->ofproto, &info);
1380
1381     OVSREC_CONTROLLER_FOR_EACH(cfg, idl) {
1382         struct ofproto_controller_info *cinfo =
1383             shash_find_data(&info, cfg->target);
1384
1385         if (cinfo) {
1386             ovsrec_controller_set_is_connected(cfg, cinfo->is_connected);
1387             ovsrec_controller_set_role(cfg, nx_role_to_str(cinfo->role));
1388             ovsrec_controller_set_status(cfg, (char **) cinfo->pairs.keys,
1389                                          (char **) cinfo->pairs.values,
1390                                          cinfo->pairs.n);
1391         } else {
1392             ovsrec_controller_set_is_connected(cfg, false);
1393             ovsrec_controller_set_role(cfg, NULL);
1394             ovsrec_controller_set_status(cfg, NULL, NULL, 0);
1395         }
1396     }
1397
1398     ofproto_free_ofproto_controller_info(&info);
1399 }
1400
1401 void
1402 bridge_run(void)
1403 {
1404     const struct ovsrec_open_vswitch *cfg;
1405
1406     bool datapath_destroyed;
1407     bool database_changed;
1408     struct bridge *br;
1409
1410     /* Let each bridge do the work that it needs to do. */
1411     datapath_destroyed = false;
1412     LIST_FOR_EACH (br, node, &all_bridges) {
1413         int error = bridge_run_one(br);
1414         if (error) {
1415             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1416             VLOG_ERR_RL(&rl, "bridge %s: datapath was destroyed externally, "
1417                         "forcing reconfiguration", br->name);
1418             datapath_destroyed = true;
1419         }
1420     }
1421
1422     /* (Re)configure if necessary. */
1423     database_changed = ovsdb_idl_run(idl);
1424     cfg = ovsrec_open_vswitch_first(idl);
1425 #ifdef HAVE_OPENSSL
1426     /* Re-configure SSL.  We do this on every trip through the main loop,
1427      * instead of just when the database changes, because the contents of the
1428      * key and certificate files can change without the database changing.
1429      *
1430      * We do this before bridge_reconfigure() because that function might
1431      * initiate SSL connections and thus requires SSL to be configured. */
1432     if (cfg && cfg->ssl) {
1433         const struct ovsrec_ssl *ssl = cfg->ssl;
1434
1435         stream_ssl_set_key_and_cert(ssl->private_key, ssl->certificate);
1436         stream_ssl_set_ca_cert_file(ssl->ca_cert, ssl->bootstrap_ca_cert);
1437     }
1438 #endif
1439     if (database_changed || datapath_destroyed) {
1440         if (cfg) {
1441             struct ovsdb_idl_txn *txn = ovsdb_idl_txn_create(idl);
1442
1443             bridge_configure_once(cfg);
1444             bridge_reconfigure(cfg);
1445
1446             ovsrec_open_vswitch_set_cur_cfg(cfg, cfg->next_cfg);
1447             ovsdb_idl_txn_commit(txn);
1448             ovsdb_idl_txn_destroy(txn); /* XXX */
1449         } else {
1450             /* We still need to reconfigure to avoid dangling pointers to
1451              * now-destroyed ovsrec structures inside bridge data. */
1452             static const struct ovsrec_open_vswitch null_cfg;
1453
1454             bridge_reconfigure(&null_cfg);
1455         }
1456     }
1457
1458     /* Refresh system and interface stats if necessary. */
1459     if (time_msec() >= stats_timer) {
1460         if (cfg) {
1461             struct ovsdb_idl_txn *txn;
1462
1463             txn = ovsdb_idl_txn_create(idl);
1464             LIST_FOR_EACH (br, node, &all_bridges) {
1465                 size_t i;
1466
1467                 for (i = 0; i < br->n_ports; i++) {
1468                     struct port *port = br->ports[i];
1469                     size_t j;
1470
1471                     for (j = 0; j < port->n_ifaces; j++) {
1472                         struct iface *iface = port->ifaces[j];
1473                         iface_refresh_stats(iface);
1474                         iface_refresh_cfm_stats(iface);
1475                         iface_refresh_status(iface);
1476                     }
1477                 }
1478                 bridge_refresh_controller_status(br);
1479             }
1480             refresh_system_stats(cfg);
1481             ovsdb_idl_txn_commit(txn);
1482             ovsdb_idl_txn_destroy(txn); /* XXX */
1483         }
1484
1485         stats_timer = time_msec() + STATS_INTERVAL;
1486     }
1487 }
1488
1489 void
1490 bridge_wait(void)
1491 {
1492     struct bridge *br;
1493     struct iface *iface;
1494
1495     LIST_FOR_EACH (br, node, &all_bridges) {
1496         ofproto_wait(br->ofproto);
1497         if (ofproto_has_primary_controller(br->ofproto)) {
1498             continue;
1499         }
1500
1501         mac_learning_wait(br->ml);
1502         lacp_wait(br);
1503         bond_wait(br);
1504
1505         HMAP_FOR_EACH (iface, dp_ifidx_node, &br->ifaces) {
1506             if (iface->cfm) {
1507                 cfm_wait(iface->cfm);
1508             }
1509         }
1510     }
1511     ovsdb_idl_wait(idl);
1512     poll_timer_wait_until(stats_timer);
1513 }
1514
1515 /* Forces 'br' to revalidate all of its flows.  This is appropriate when 'br''s
1516  * configuration changes.  */
1517 static void
1518 bridge_flush(struct bridge *br)
1519 {
1520     COVERAGE_INC(bridge_flush);
1521     br->flush = true;
1522     mac_learning_flush(br->ml);
1523 }
1524
1525 /* Returns the 'br' interface for the ODPP_LOCAL port, or null if 'br' has no
1526  * such interface. */
1527 static struct iface *
1528 bridge_get_local_iface(struct bridge *br)
1529 {
1530     size_t i, j;
1531
1532     for (i = 0; i < br->n_ports; i++) {
1533         struct port *port = br->ports[i];
1534         for (j = 0; j < port->n_ifaces; j++) {
1535             struct iface *iface = port->ifaces[j];
1536             if (iface->dp_ifidx == ODPP_LOCAL) {
1537                 return iface;
1538             }
1539         }
1540     }
1541
1542     return NULL;
1543 }
1544 \f
1545 /* Bridge unixctl user interface functions. */
1546 static void
1547 bridge_unixctl_fdb_show(struct unixctl_conn *conn,
1548                         const char *args, void *aux OVS_UNUSED)
1549 {
1550     struct ds ds = DS_EMPTY_INITIALIZER;
1551     const struct bridge *br;
1552     const struct mac_entry *e;
1553
1554     br = bridge_lookup(args);
1555     if (!br) {
1556         unixctl_command_reply(conn, 501, "no such bridge");
1557         return;
1558     }
1559
1560     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
1561     LIST_FOR_EACH (e, lru_node, &br->ml->lrus) {
1562         if (e->port < 0 || e->port >= br->n_ports) {
1563             continue;
1564         }
1565         ds_put_format(&ds, "%5d  %4d  "ETH_ADDR_FMT"  %3d\n",
1566                       br->ports[e->port]->ifaces[0]->dp_ifidx,
1567                       e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
1568     }
1569     unixctl_command_reply(conn, 200, ds_cstr(&ds));
1570     ds_destroy(&ds);
1571 }
1572 \f
1573 /* Bridge reconfiguration functions. */
1574 static struct bridge *
1575 bridge_create(const struct ovsrec_bridge *br_cfg)
1576 {
1577     struct bridge *br;
1578     int error;
1579
1580     assert(!bridge_lookup(br_cfg->name));
1581     br = xzalloc(sizeof *br);
1582
1583     error = dpif_create_and_open(br_cfg->name, br_cfg->datapath_type,
1584                                  &br->dpif);
1585     if (error) {
1586         free(br);
1587         return NULL;
1588     }
1589     dpif_flow_flush(br->dpif);
1590
1591     error = ofproto_create(br_cfg->name, br_cfg->datapath_type, &bridge_ofhooks,
1592                            br, &br->ofproto);
1593     if (error) {
1594         VLOG_ERR("failed to create switch %s: %s", br_cfg->name,
1595                  strerror(error));
1596         dpif_delete(br->dpif);
1597         dpif_close(br->dpif);
1598         free(br);
1599         return NULL;
1600     }
1601
1602     br->name = xstrdup(br_cfg->name);
1603     br->cfg = br_cfg;
1604     br->ml = mac_learning_create();
1605     eth_addr_nicira_random(br->default_ea);
1606
1607     hmap_init(&br->ifaces);
1608
1609     shash_init(&br->port_by_name);
1610     shash_init(&br->iface_by_name);
1611
1612     br->flush = false;
1613
1614     list_push_back(&all_bridges, &br->node);
1615
1616     VLOG_INFO("created bridge %s on %s", br->name, dpif_name(br->dpif));
1617
1618     return br;
1619 }
1620
1621 static void
1622 bridge_destroy(struct bridge *br)
1623 {
1624     if (br) {
1625         int error;
1626
1627         while (br->n_ports > 0) {
1628             port_destroy(br->ports[br->n_ports - 1]);
1629         }
1630         list_remove(&br->node);
1631         error = dpif_delete(br->dpif);
1632         if (error && error != ENOENT) {
1633             VLOG_ERR("failed to delete %s: %s",
1634                      dpif_name(br->dpif), strerror(error));
1635         }
1636         dpif_close(br->dpif);
1637         ofproto_destroy(br->ofproto);
1638         mac_learning_destroy(br->ml);
1639         hmap_destroy(&br->ifaces);
1640         shash_destroy(&br->port_by_name);
1641         shash_destroy(&br->iface_by_name);
1642         free(br->ports);
1643         free(br->name);
1644         free(br);
1645     }
1646 }
1647
1648 static struct bridge *
1649 bridge_lookup(const char *name)
1650 {
1651     struct bridge *br;
1652
1653     LIST_FOR_EACH (br, node, &all_bridges) {
1654         if (!strcmp(br->name, name)) {
1655             return br;
1656         }
1657     }
1658     return NULL;
1659 }
1660
1661 /* Handle requests for a listing of all flows known by the OpenFlow
1662  * stack, including those normally hidden. */
1663 static void
1664 bridge_unixctl_dump_flows(struct unixctl_conn *conn,
1665                           const char *args, void *aux OVS_UNUSED)
1666 {
1667     struct bridge *br;
1668     struct ds results;
1669
1670     br = bridge_lookup(args);
1671     if (!br) {
1672         unixctl_command_reply(conn, 501, "Unknown bridge");
1673         return;
1674     }
1675
1676     ds_init(&results);
1677     ofproto_get_all_flows(br->ofproto, &results);
1678
1679     unixctl_command_reply(conn, 200, ds_cstr(&results));
1680     ds_destroy(&results);
1681 }
1682
1683 /* "bridge/reconnect [BRIDGE]": makes BRIDGE drop all of its controller
1684  * connections and reconnect.  If BRIDGE is not specified, then all bridges
1685  * drop their controller connections and reconnect. */
1686 static void
1687 bridge_unixctl_reconnect(struct unixctl_conn *conn,
1688                          const char *args, void *aux OVS_UNUSED)
1689 {
1690     struct bridge *br;
1691     if (args[0] != '\0') {
1692         br = bridge_lookup(args);
1693         if (!br) {
1694             unixctl_command_reply(conn, 501, "Unknown bridge");
1695             return;
1696         }
1697         ofproto_reconnect_controllers(br->ofproto);
1698     } else {
1699         LIST_FOR_EACH (br, node, &all_bridges) {
1700             ofproto_reconnect_controllers(br->ofproto);
1701         }
1702     }
1703     unixctl_command_reply(conn, 200, NULL);
1704 }
1705
1706 static int
1707 bridge_run_one(struct bridge *br)
1708 {
1709     int error;
1710     struct iface *iface;
1711
1712     error = ofproto_run1(br->ofproto);
1713     if (error) {
1714         return error;
1715     }
1716
1717     mac_learning_run(br->ml, ofproto_get_revalidate_set(br->ofproto));
1718     lacp_run(br);
1719     bond_run(br);
1720
1721     error = ofproto_run2(br->ofproto, br->flush);
1722     br->flush = false;
1723
1724     HMAP_FOR_EACH (iface, dp_ifidx_node, &br->ifaces) {
1725         struct ofpbuf *packet;
1726
1727         if (!iface->cfm) {
1728             continue;
1729         }
1730
1731         packet = cfm_run(iface->cfm);
1732         if (packet) {
1733             iface_send_packet(iface, packet);
1734             ofpbuf_uninit(packet);
1735             free(packet);
1736         }
1737     }
1738
1739     return error;
1740 }
1741
1742 static size_t
1743 bridge_get_controllers(const struct bridge *br,
1744                        struct ovsrec_controller ***controllersp)
1745 {
1746     struct ovsrec_controller **controllers;
1747     size_t n_controllers;
1748
1749     controllers = br->cfg->controller;
1750     n_controllers = br->cfg->n_controller;
1751
1752     if (n_controllers == 1 && !strcmp(controllers[0]->target, "none")) {
1753         controllers = NULL;
1754         n_controllers = 0;
1755     }
1756
1757     if (controllersp) {
1758         *controllersp = controllers;
1759     }
1760     return n_controllers;
1761 }
1762
1763 static void
1764 bridge_reconfigure_one(struct bridge *br)
1765 {
1766     struct shash old_ports, new_ports;
1767     struct svec snoops, old_snoops;
1768     struct shash_node *node;
1769     enum ofproto_fail_mode fail_mode;
1770     size_t i;
1771
1772     /* Collect old ports. */
1773     shash_init(&old_ports);
1774     for (i = 0; i < br->n_ports; i++) {
1775         shash_add(&old_ports, br->ports[i]->name, br->ports[i]);
1776     }
1777
1778     /* Collect new ports. */
1779     shash_init(&new_ports);
1780     for (i = 0; i < br->cfg->n_ports; i++) {
1781         const char *name = br->cfg->ports[i]->name;
1782         if (!shash_add_once(&new_ports, name, br->cfg->ports[i])) {
1783             VLOG_WARN("bridge %s: %s specified twice as bridge port",
1784                       br->name, name);
1785         }
1786     }
1787
1788     /* If we have a controller, then we need a local port.  Complain if the
1789      * user didn't specify one.
1790      *
1791      * XXX perhaps we should synthesize a port ourselves in this case. */
1792     if (bridge_get_controllers(br, NULL)) {
1793         char local_name[IF_NAMESIZE];
1794         int error;
1795
1796         error = dpif_port_get_name(br->dpif, ODPP_LOCAL,
1797                                    local_name, sizeof local_name);
1798         if (!error && !shash_find(&new_ports, local_name)) {
1799             VLOG_WARN("bridge %s: controller specified but no local port "
1800                       "(port named %s) defined",
1801                       br->name, local_name);
1802         }
1803     }
1804
1805     /* Get rid of deleted ports.
1806      * Get rid of deleted interfaces on ports that still exist. */
1807     SHASH_FOR_EACH (node, &old_ports) {
1808         struct port *port = node->data;
1809         const struct ovsrec_port *port_cfg;
1810
1811         port_cfg = shash_find_data(&new_ports, node->name);
1812         if (!port_cfg) {
1813             port_destroy(port);
1814         } else {
1815             port_del_ifaces(port, port_cfg);
1816         }
1817     }
1818
1819     /* Create new ports.
1820      * Add new interfaces to existing ports.
1821      * Reconfigure existing ports. */
1822     SHASH_FOR_EACH (node, &new_ports) {
1823         struct port *port = shash_find_data(&old_ports, node->name);
1824         if (!port) {
1825             port = port_create(br, node->name);
1826         }
1827
1828         port_reconfigure(port, node->data);
1829         if (!port->n_ifaces) {
1830             VLOG_WARN("bridge %s: port %s has no interfaces, dropping",
1831                       br->name, port->name);
1832             port_destroy(port);
1833         }
1834     }
1835     shash_destroy(&old_ports);
1836     shash_destroy(&new_ports);
1837
1838     /* Set the fail-mode */
1839     fail_mode = !br->cfg->fail_mode
1840                 || !strcmp(br->cfg->fail_mode, "standalone")
1841                     ? OFPROTO_FAIL_STANDALONE
1842                     : OFPROTO_FAIL_SECURE;
1843     if (ofproto_get_fail_mode(br->ofproto) != fail_mode
1844         && !ofproto_has_primary_controller(br->ofproto)) {
1845         ofproto_flush_flows(br->ofproto);
1846     }
1847     ofproto_set_fail_mode(br->ofproto, fail_mode);
1848
1849     /* Delete all flows if we're switching from connected to standalone or vice
1850      * versa.  (XXX Should we delete all flows if we are switching from one
1851      * controller to another?) */
1852
1853     /* Configure OpenFlow controller connection snooping. */
1854     svec_init(&snoops);
1855     svec_add_nocopy(&snoops, xasprintf("punix:%s/%s.snoop",
1856                                        ovs_rundir(), br->name));
1857     svec_init(&old_snoops);
1858     ofproto_get_snoops(br->ofproto, &old_snoops);
1859     if (!svec_equal(&snoops, &old_snoops)) {
1860         ofproto_set_snoops(br->ofproto, &snoops);
1861     }
1862     svec_destroy(&snoops);
1863     svec_destroy(&old_snoops);
1864
1865     mirror_reconfigure(br);
1866 }
1867
1868 /* Initializes 'oc' appropriately as a management service controller for
1869  * 'br'.
1870  *
1871  * The caller must free oc->target when it is no longer needed. */
1872 static void
1873 bridge_ofproto_controller_for_mgmt(const struct bridge *br,
1874                                    struct ofproto_controller *oc)
1875 {
1876     oc->target = xasprintf("punix:%s/%s.mgmt", ovs_rundir(), br->name);
1877     oc->max_backoff = 0;
1878     oc->probe_interval = 60;
1879     oc->band = OFPROTO_OUT_OF_BAND;
1880     oc->accept_re = NULL;
1881     oc->update_resolv_conf = false;
1882     oc->rate_limit = 0;
1883     oc->burst_limit = 0;
1884 }
1885
1886 /* Converts ovsrec_controller 'c' into an ofproto_controller in 'oc'.  */
1887 static void
1888 bridge_ofproto_controller_from_ovsrec(const struct ovsrec_controller *c,
1889                                       struct ofproto_controller *oc)
1890 {
1891     oc->target = c->target;
1892     oc->max_backoff = c->max_backoff ? *c->max_backoff / 1000 : 8;
1893     oc->probe_interval = c->inactivity_probe ? *c->inactivity_probe / 1000 : 5;
1894     oc->band = (!c->connection_mode || !strcmp(c->connection_mode, "in-band")
1895                 ? OFPROTO_IN_BAND : OFPROTO_OUT_OF_BAND);
1896     oc->accept_re = c->discover_accept_regex;
1897     oc->update_resolv_conf = c->discover_update_resolv_conf;
1898     oc->rate_limit = c->controller_rate_limit ? *c->controller_rate_limit : 0;
1899     oc->burst_limit = (c->controller_burst_limit
1900                        ? *c->controller_burst_limit : 0);
1901 }
1902
1903 /* Configures the IP stack for 'br''s local interface properly according to the
1904  * configuration in 'c'.  */
1905 static void
1906 bridge_configure_local_iface_netdev(struct bridge *br,
1907                                     struct ovsrec_controller *c)
1908 {
1909     struct netdev *netdev;
1910     struct in_addr mask, gateway;
1911
1912     struct iface *local_iface;
1913     struct in_addr ip;
1914
1915     /* Controller discovery does its own TCP/IP configuration later. */
1916     if (strcmp(c->target, "discover")) {
1917         return;
1918     }
1919
1920     /* If there's no local interface or no IP address, give up. */
1921     local_iface = bridge_get_local_iface(br);
1922     if (!local_iface || !c->local_ip || !inet_aton(c->local_ip, &ip)) {
1923         return;
1924     }
1925
1926     /* Bring up the local interface. */
1927     netdev = local_iface->netdev;
1928     netdev_turn_flags_on(netdev, NETDEV_UP, true);
1929
1930     /* Configure the IP address and netmask. */
1931     if (!c->local_netmask
1932         || !inet_aton(c->local_netmask, &mask)
1933         || !mask.s_addr) {
1934         mask.s_addr = guess_netmask(ip.s_addr);
1935     }
1936     if (!netdev_set_in4(netdev, ip, mask)) {
1937         VLOG_INFO("bridge %s: configured IP address "IP_FMT", netmask "IP_FMT,
1938                   br->name, IP_ARGS(&ip.s_addr), IP_ARGS(&mask.s_addr));
1939     }
1940
1941     /* Configure the default gateway. */
1942     if (c->local_gateway
1943         && inet_aton(c->local_gateway, &gateway)
1944         && gateway.s_addr) {
1945         if (!netdev_add_router(netdev, gateway)) {
1946             VLOG_INFO("bridge %s: configured gateway "IP_FMT,
1947                       br->name, IP_ARGS(&gateway.s_addr));
1948         }
1949     }
1950 }
1951
1952 static void
1953 bridge_reconfigure_remotes(struct bridge *br,
1954                            const struct sockaddr_in *managers,
1955                            size_t n_managers)
1956 {
1957     const char *disable_ib_str, *queue_id_str;
1958     bool disable_in_band = false;
1959     int queue_id;
1960
1961     struct ovsrec_controller **controllers;
1962     size_t n_controllers;
1963     bool had_primary;
1964
1965     struct ofproto_controller *ocs;
1966     size_t n_ocs;
1967     size_t i;
1968
1969     /* Check if we should disable in-band control on this bridge. */
1970     disable_ib_str = bridge_get_other_config(br->cfg, "disable-in-band");
1971     if (disable_ib_str && !strcmp(disable_ib_str, "true")) {
1972         disable_in_band = true;
1973     }
1974
1975     /* Set OpenFlow queue ID for in-band control. */
1976     queue_id_str = bridge_get_other_config(br->cfg, "in-band-queue");
1977     queue_id = queue_id_str ? strtol(queue_id_str, NULL, 10) : -1;
1978     ofproto_set_in_band_queue(br->ofproto, queue_id);
1979
1980     if (disable_in_band) {
1981         ofproto_set_extra_in_band_remotes(br->ofproto, NULL, 0);
1982     } else {
1983         ofproto_set_extra_in_band_remotes(br->ofproto, managers, n_managers);
1984     }
1985     had_primary = ofproto_has_primary_controller(br->ofproto);
1986
1987     n_controllers = bridge_get_controllers(br, &controllers);
1988
1989     ocs = xmalloc((n_controllers + 1) * sizeof *ocs);
1990     n_ocs = 0;
1991
1992     bridge_ofproto_controller_for_mgmt(br, &ocs[n_ocs++]);
1993     for (i = 0; i < n_controllers; i++) {
1994         struct ovsrec_controller *c = controllers[i];
1995
1996         if (!strncmp(c->target, "punix:", 6)
1997             || !strncmp(c->target, "unix:", 5)) {
1998             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1999
2000             /* Prevent remote ovsdb-server users from accessing arbitrary Unix
2001              * domain sockets and overwriting arbitrary local files. */
2002             VLOG_ERR_RL(&rl, "%s: not adding Unix domain socket controller "
2003                         "\"%s\" due to possibility for remote exploit",
2004                         dpif_name(br->dpif), c->target);
2005             continue;
2006         }
2007
2008         bridge_configure_local_iface_netdev(br, c);
2009         bridge_ofproto_controller_from_ovsrec(c, &ocs[n_ocs]);
2010         if (disable_in_band) {
2011             ocs[n_ocs].band = OFPROTO_OUT_OF_BAND;
2012         }
2013         n_ocs++;
2014     }
2015
2016     ofproto_set_controllers(br->ofproto, ocs, n_ocs);
2017     free(ocs[0].target); /* From bridge_ofproto_controller_for_mgmt(). */
2018     free(ocs);
2019
2020     if (had_primary != ofproto_has_primary_controller(br->ofproto)) {
2021         ofproto_flush_flows(br->ofproto);
2022     }
2023
2024     /* If there are no controllers and the bridge is in standalone
2025      * mode, set up a flow that matches every packet and directs
2026      * them to OFPP_NORMAL (which goes to us).  Otherwise, the
2027      * switch is in secure mode and we won't pass any traffic until
2028      * a controller has been defined and it tells us to do so. */
2029     if (!n_controllers
2030         && ofproto_get_fail_mode(br->ofproto) == OFPROTO_FAIL_STANDALONE) {
2031         union ofp_action action;
2032         struct cls_rule rule;
2033
2034         memset(&action, 0, sizeof action);
2035         action.type = htons(OFPAT_OUTPUT);
2036         action.output.len = htons(sizeof action);
2037         action.output.port = htons(OFPP_NORMAL);
2038         cls_rule_init_catchall(&rule, 0);
2039         ofproto_add_flow(br->ofproto, &rule, &action, 1);
2040     }
2041 }
2042
2043 static void
2044 bridge_get_all_ifaces(const struct bridge *br, struct shash *ifaces)
2045 {
2046     size_t i, j;
2047
2048     shash_init(ifaces);
2049     for (i = 0; i < br->n_ports; i++) {
2050         struct port *port = br->ports[i];
2051         for (j = 0; j < port->n_ifaces; j++) {
2052             struct iface *iface = port->ifaces[j];
2053             shash_add_once(ifaces, iface->name, iface);
2054         }
2055         if (port->n_ifaces > 1 && port->cfg->bond_fake_iface) {
2056             shash_add_once(ifaces, port->name, NULL);
2057         }
2058     }
2059 }
2060
2061 /* For robustness, in case the administrator moves around datapath ports behind
2062  * our back, we re-check all the datapath port numbers here.
2063  *
2064  * This function will set the 'dp_ifidx' members of interfaces that have
2065  * disappeared to -1, so only call this function from a context where those
2066  * 'struct iface's will be removed from the bridge.  Otherwise, the -1
2067  * 'dp_ifidx'es will cause trouble later when we try to send them to the
2068  * datapath, which doesn't support UINT16_MAX+1 ports. */
2069 static void
2070 bridge_fetch_dp_ifaces(struct bridge *br)
2071 {
2072     struct dpif_port_dump dump;
2073     struct dpif_port dpif_port;
2074     size_t i, j;
2075
2076     /* Reset all interface numbers. */
2077     for (i = 0; i < br->n_ports; i++) {
2078         struct port *port = br->ports[i];
2079         for (j = 0; j < port->n_ifaces; j++) {
2080             struct iface *iface = port->ifaces[j];
2081             iface->dp_ifidx = -1;
2082         }
2083     }
2084     hmap_clear(&br->ifaces);
2085
2086     DPIF_PORT_FOR_EACH (&dpif_port, &dump, br->dpif) {
2087         struct iface *iface = iface_lookup(br, dpif_port.name);
2088         if (iface) {
2089             if (iface->dp_ifidx >= 0) {
2090                 VLOG_WARN("%s reported interface %s twice",
2091                           dpif_name(br->dpif), dpif_port.name);
2092             } else if (iface_from_dp_ifidx(br, dpif_port.port_no)) {
2093                 VLOG_WARN("%s reported interface %"PRIu16" twice",
2094                           dpif_name(br->dpif), dpif_port.port_no);
2095             } else {
2096                 iface->dp_ifidx = dpif_port.port_no;
2097                 hmap_insert(&br->ifaces, &iface->dp_ifidx_node,
2098                             hash_int(iface->dp_ifidx, 0));
2099             }
2100
2101             iface_set_ofport(iface->cfg,
2102                              (iface->dp_ifidx >= 0
2103                               ? odp_port_to_ofp_port(iface->dp_ifidx)
2104                               : -1));
2105         }
2106     }
2107 }
2108 \f
2109 /* Bridge packet processing functions. */
2110
2111 static bool
2112 bond_is_tcp_hash(const struct port *port)
2113 {
2114     return port->bond_mode == BM_TCP && port->lacp & LACP_NEGOTIATED;
2115 }
2116
2117 static int
2118 bond_hash_src(const uint8_t mac[ETH_ADDR_LEN], uint16_t vlan)
2119 {
2120     return hash_bytes(mac, ETH_ADDR_LEN, vlan) & BOND_MASK;
2121 }
2122
2123 static int bond_hash_tcp(const struct flow *flow, uint16_t vlan)
2124 {
2125     struct flow hash_flow;
2126
2127     memcpy(&hash_flow, flow, sizeof hash_flow);
2128     hash_flow.vlan_tci = 0;
2129
2130     /* The symmetric quality of this hash function is not required, but
2131      * flow_hash_symmetric_l4 already exists, and is sufficient for our
2132      * purposes, so we use it out of convenience. */
2133     return flow_hash_symmetric_l4(&hash_flow, vlan) & BOND_MASK;
2134 }
2135
2136 static struct bond_entry *
2137 lookup_bond_entry(const struct port *port, const struct flow *flow,
2138                   uint16_t vlan)
2139 {
2140     assert(port->bond_mode != BM_AB);
2141
2142     if (bond_is_tcp_hash(port)) {
2143         return &port->bond_hash[bond_hash_tcp(flow, vlan)];
2144     } else {
2145         return &port->bond_hash[bond_hash_src(flow->dl_src, vlan)];
2146     }
2147 }
2148
2149 static int
2150 bond_choose_iface(const struct port *port)
2151 {
2152     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
2153     size_t i, best_down_slave = -1;
2154     long long next_delay_expiration = LLONG_MAX;
2155
2156     for (i = 0; i < port->n_ifaces; i++) {
2157         struct iface *iface = port->ifaces[i];
2158
2159         if (iface->enabled) {
2160             return i;
2161         } else if (iface->delay_expires < next_delay_expiration
2162                    && (iface->lacp_status & LACP_ATTACHED
2163                        || !(port->lacp & LACP_NEGOTIATED))) {
2164             best_down_slave = i;
2165             next_delay_expiration = iface->delay_expires;
2166         }
2167     }
2168
2169     if (best_down_slave != -1) {
2170         struct iface *iface = port->ifaces[best_down_slave];
2171
2172         VLOG_INFO_RL(&rl, "interface %s: skipping remaining %lli ms updelay "
2173                      "since no other interface is up", iface->name,
2174                      iface->delay_expires - time_msec());
2175         bond_enable_slave(iface, true);
2176     }
2177
2178     return best_down_slave;
2179 }
2180
2181 static bool
2182 choose_output_iface(const struct port *port, const struct flow *flow,
2183                     uint16_t vlan, uint16_t *dp_ifidx, tag_type *tags)
2184 {
2185     struct iface *iface;
2186
2187     assert(port->n_ifaces);
2188     if (port->n_ifaces == 1) {
2189         iface = port->ifaces[0];
2190     } else if (port->bond_mode == BM_AB) {
2191         if (port->active_iface < 0) {
2192             *tags |= port->no_ifaces_tag;
2193             return false;
2194         }
2195         iface = port->ifaces[port->active_iface];
2196     } else {
2197         struct bond_entry *e = lookup_bond_entry(port, flow, vlan);
2198         if (e->iface_idx < 0 || e->iface_idx >= port->n_ifaces
2199             || !port->ifaces[e->iface_idx]->enabled) {
2200             /* XXX select interface properly.  The current interface selection
2201              * is only good for testing the rebalancing code. */
2202             e->iface_idx = bond_choose_iface(port);
2203             if (e->iface_idx < 0) {
2204                 *tags |= port->no_ifaces_tag;
2205                 return false;
2206             }
2207             e->iface_tag = tag_create_random();
2208         }
2209         *tags |= e->iface_tag;
2210         iface = port->ifaces[e->iface_idx];
2211     }
2212     *dp_ifidx = iface->dp_ifidx;
2213     *tags |= iface->tag;        /* Currently only used for bonding. */
2214     return true;
2215 }
2216
2217 static void
2218 bond_link_status_update(struct iface *iface)
2219 {
2220     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
2221     struct port *port = iface->port;
2222     bool up = iface->up;
2223     int updelay, downdelay;
2224
2225     updelay = port->updelay;
2226     downdelay = port->downdelay;
2227
2228     if (iface->port->lacp & LACP_NEGOTIATED) {
2229         downdelay = 0;
2230         updelay = 0;
2231     }
2232
2233     if (iface->port->lacp && up) {
2234         /* The interface is up if it's attached to an aggregator and its
2235          * partner is synchronized.  The only exception is defaulted links.
2236          * They are not required to have synchronized partners because they
2237          * have no partners at all.  However, they will only be attached if
2238          * negotiations failed on all interfaces in the bond. */
2239         up = iface->lacp_status & LACP_ATTACHED
2240             && (iface->lacp_partner.state & LACP_STATE_SYNC
2241                  || iface->lacp_status & LACP_DEFAULTED);
2242     }
2243
2244
2245     if ((up == iface->enabled) == (iface->delay_expires == LLONG_MAX)) {
2246         /* Nothing to do. */
2247         return;
2248     }
2249     VLOG_INFO_RL(&rl, "interface %s: link state %s",
2250                  iface->name, up ? "up" : "down");
2251     if (up == iface->enabled) {
2252         iface->delay_expires = LLONG_MAX;
2253         VLOG_INFO_RL(&rl, "interface %s: will not be %s",
2254                      iface->name, up ? "disabled" : "enabled");
2255     } else if (up && port->active_iface < 0) {
2256         bond_enable_slave(iface, true);
2257         if (updelay) {
2258             VLOG_INFO_RL(&rl, "interface %s: skipping %d ms updelay since no "
2259                          "other interface is up", iface->name, updelay);
2260         }
2261     } else {
2262         int delay = up ? updelay : downdelay;
2263         iface->delay_expires = time_msec() + delay;
2264         if (delay) {
2265             VLOG_INFO_RL(&rl,
2266                          "interface %s: will be %s if it stays %s for %d ms",
2267                          iface->name,
2268                          up ? "enabled" : "disabled",
2269                          up ? "up" : "down",
2270                          delay);
2271         }
2272     }
2273 }
2274
2275 static void
2276 bond_choose_active_iface(struct port *port)
2277 {
2278     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
2279
2280     port->active_iface = bond_choose_iface(port);
2281     port->active_iface_tag = tag_create_random();
2282     if (port->active_iface >= 0) {
2283         VLOG_INFO_RL(&rl, "port %s: active interface is now %s",
2284                      port->name, port->ifaces[port->active_iface]->name);
2285     } else {
2286         VLOG_WARN_RL(&rl, "port %s: all ports disabled, no active interface",
2287                      port->name);
2288     }
2289 }
2290
2291 static void
2292 bond_enable_slave(struct iface *iface, bool enable)
2293 {
2294     struct port *port = iface->port;
2295     struct bridge *br = port->bridge;
2296
2297     /* This acts as a recursion check.  If the act of disabling a slave
2298      * causes a different slave to be enabled, the flag will allow us to
2299      * skip redundant work when we reenter this function.  It must be
2300      * cleared on exit to keep things safe with multiple bonds. */
2301     static bool moving_active_iface = false;
2302
2303     iface->delay_expires = LLONG_MAX;
2304     if (enable == iface->enabled) {
2305         return;
2306     }
2307
2308     iface->enabled = enable;
2309     if (!iface->enabled) {
2310         VLOG_WARN("interface %s: disabled", iface->name);
2311         ofproto_revalidate(br->ofproto, iface->tag);
2312         if (iface->port_ifidx == port->active_iface) {
2313             ofproto_revalidate(br->ofproto,
2314                                port->active_iface_tag);
2315
2316             /* Disabling a slave can lead to another slave being immediately
2317              * enabled if there will be no active slaves but one is waiting
2318              * on an updelay.  In this case we do not need to run most of the
2319              * code for the newly enabled slave since there was no period
2320              * without an active slave and it is redundant with the disabling
2321              * path. */
2322             moving_active_iface = true;
2323             bond_choose_active_iface(port);
2324         }
2325         bond_send_learning_packets(port);
2326     } else {
2327         VLOG_WARN("interface %s: enabled", iface->name);
2328         if (port->active_iface < 0 && !moving_active_iface) {
2329             ofproto_revalidate(br->ofproto, port->no_ifaces_tag);
2330             bond_choose_active_iface(port);
2331             bond_send_learning_packets(port);
2332         }
2333         iface->tag = tag_create_random();
2334     }
2335
2336     moving_active_iface = false;
2337 }
2338
2339 /* Attempts to make the sum of the bond slaves' statistics appear on the fake
2340  * bond interface. */
2341 static void
2342 bond_update_fake_iface_stats(struct port *port)
2343 {
2344     struct netdev_stats bond_stats;
2345     struct netdev *bond_dev;
2346     size_t i;
2347
2348     memset(&bond_stats, 0, sizeof bond_stats);
2349
2350     for (i = 0; i < port->n_ifaces; i++) {
2351         struct netdev_stats slave_stats;
2352
2353         if (!netdev_get_stats(port->ifaces[i]->netdev, &slave_stats)) {
2354             /* XXX: We swap the stats here because they are swapped back when
2355              * reported by the internal device.  The reason for this is
2356              * internal devices normally represent packets going into the system
2357              * but when used as fake bond device they represent packets leaving
2358              * the system.  We really should do this in the internal device
2359              * itself because changing it here reverses the counts from the
2360              * perspective of the switch.  However, the internal device doesn't
2361              * know what type of device it represents so we have to do it here
2362              * for now. */
2363             bond_stats.tx_packets += slave_stats.rx_packets;
2364             bond_stats.tx_bytes += slave_stats.rx_bytes;
2365             bond_stats.rx_packets += slave_stats.tx_packets;
2366             bond_stats.rx_bytes += slave_stats.tx_bytes;
2367         }
2368     }
2369
2370     if (!netdev_open_default(port->name, &bond_dev)) {
2371         netdev_set_stats(bond_dev, &bond_stats);
2372         netdev_close(bond_dev);
2373     }
2374 }
2375
2376 static void
2377 bond_link_carrier_update(struct iface *iface, bool carrier)
2378 {
2379     if (carrier == iface->up) {
2380         return;
2381     }
2382
2383     if (iface->lacp_status & LACP_CURRENT) {
2384         iface_set_lacp_expired(iface);
2385     }
2386
2387     iface->up = carrier;
2388     iface->lacp_tx = 0;
2389 }
2390
2391 static void
2392 bond_run(struct bridge *br)
2393 {
2394     size_t i, j;
2395
2396     for (i = 0; i < br->n_ports; i++) {
2397         struct port *port = br->ports[i];
2398
2399         if (port->n_ifaces >= 2) {
2400             char *devname;
2401
2402             if (port->monitor) {
2403                 assert(!port->miimon);
2404
2405                 /* Track carrier going up and down on interfaces. */
2406                 while (!netdev_monitor_poll(port->monitor, &devname)) {
2407                     struct iface *iface;
2408
2409                     iface = port_lookup_iface(port, devname);
2410                     if (iface) {
2411                         bool up = netdev_get_carrier(iface->netdev);
2412                         bond_link_carrier_update(iface, up);
2413                     }
2414                     free(devname);
2415                 }
2416             } else {
2417                 assert(port->miimon);
2418
2419                 if (time_msec() >= port->bond_miimon_next_update) {
2420                     for (j = 0; j < port->n_ifaces; j++) {
2421                         struct iface *iface = port->ifaces[j];
2422                         bool up = netdev_get_miimon(iface->netdev);
2423                         bond_link_carrier_update(iface, up);
2424                     }
2425                     port->bond_miimon_next_update = time_msec() +
2426                         port->bond_miimon_interval;
2427                 }
2428             }
2429
2430             for (j = 0; j < port->n_ifaces; j++) {
2431                 bond_link_status_update(port->ifaces[j]);
2432             }
2433
2434             for (j = 0; j < port->n_ifaces; j++) {
2435                 struct iface *iface = port->ifaces[j];
2436                 if (time_msec() >= iface->delay_expires) {
2437                     bond_enable_slave(iface, !iface->enabled);
2438                 }
2439             }
2440
2441             if (port->bond_fake_iface
2442                 && time_msec() >= port->bond_next_fake_iface_update) {
2443                 bond_update_fake_iface_stats(port);
2444                 port->bond_next_fake_iface_update = time_msec() + 1000;
2445             }
2446         }
2447     }
2448 }
2449
2450 static void
2451 bond_wait(struct bridge *br)
2452 {
2453     size_t i, j;
2454
2455     for (i = 0; i < br->n_ports; i++) {
2456         struct port *port = br->ports[i];
2457         if (port->n_ifaces < 2) {
2458             continue;
2459         }
2460
2461         if (port->monitor) {
2462             netdev_monitor_poll_wait(port->monitor);
2463         }
2464
2465         if (port->miimon) {
2466             poll_timer_wait_until(port->bond_miimon_next_update);
2467         }
2468
2469         for (j = 0; j < port->n_ifaces; j++) {
2470             struct iface *iface = port->ifaces[j];
2471             if (iface->delay_expires != LLONG_MAX) {
2472                 poll_timer_wait_until(iface->delay_expires);
2473             }
2474         }
2475         if (port->bond_fake_iface) {
2476             poll_timer_wait_until(port->bond_next_fake_iface_update);
2477         }
2478     }
2479 }
2480
2481 static bool
2482 set_dst(struct dst *dst, const struct flow *flow,
2483         const struct port *in_port, const struct port *out_port,
2484         tag_type *tags)
2485 {
2486     dst->vlan = (out_port->vlan >= 0 ? OFP_VLAN_NONE
2487               : in_port->vlan >= 0 ? in_port->vlan
2488               : flow->vlan_tci == 0 ? OFP_VLAN_NONE
2489               : vlan_tci_to_vid(flow->vlan_tci));
2490     return choose_output_iface(out_port, flow, dst->vlan,
2491                                &dst->dp_ifidx, tags);
2492 }
2493
2494 static void
2495 swap_dst(struct dst *p, struct dst *q)
2496 {
2497     struct dst tmp = *p;
2498     *p = *q;
2499     *q = tmp;
2500 }
2501
2502 /* Moves all the dsts with vlan == 'vlan' to the front of the 'n_dsts' in
2503  * 'dsts'.  (This may help performance by reducing the number of VLAN changes
2504  * that we push to the datapath.  We could in fact fully sort the array by
2505  * vlan, but in most cases there are at most two different vlan tags so that's
2506  * possibly overkill.) */
2507 static void
2508 partition_dsts(struct dst_set *set, int vlan)
2509 {
2510     struct dst *first = set->dsts;
2511     struct dst *last = set->dsts + set->n;
2512
2513     while (first != last) {
2514         /* Invariants:
2515          *      - All dsts < first have vlan == 'vlan'.
2516          *      - All dsts >= last have vlan != 'vlan'.
2517          *      - first < last. */
2518         while (first->vlan == vlan) {
2519             if (++first == last) {
2520                 return;
2521             }
2522         }
2523
2524         /* Same invariants, plus one additional:
2525          *      - first->vlan != vlan.
2526          */
2527         while (last[-1].vlan != vlan) {
2528             if (--last == first) {
2529                 return;
2530             }
2531         }
2532
2533         /* Same invariants, plus one additional:
2534          *      - last[-1].vlan == vlan.*/
2535         swap_dst(first++, --last);
2536     }
2537 }
2538
2539 static int
2540 mirror_mask_ffs(mirror_mask_t mask)
2541 {
2542     BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
2543     return ffs(mask);
2544 }
2545
2546 static void
2547 dst_set_init(struct dst_set *set)
2548 {
2549     set->dsts = set->builtin;
2550     set->n = 0;
2551     set->allocated = ARRAY_SIZE(set->builtin);
2552 }
2553
2554 static void
2555 dst_set_add(struct dst_set *set, const struct dst *dst)
2556 {
2557     if (set->n >= set->allocated) {
2558         size_t new_allocated;
2559         struct dst *new_dsts;
2560
2561         new_allocated = set->allocated * 2;
2562         new_dsts = xmalloc(new_allocated * sizeof *new_dsts);
2563         memcpy(new_dsts, set->dsts, set->n * sizeof *new_dsts);
2564
2565         dst_set_free(set);
2566
2567         set->dsts = new_dsts;
2568         set->allocated = new_allocated;
2569     }
2570     set->dsts[set->n++] = *dst;
2571 }
2572
2573 static void
2574 dst_set_free(struct dst_set *set)
2575 {
2576     if (set->dsts != set->builtin) {
2577         free(set->dsts);
2578     }
2579 }
2580
2581 static bool
2582 dst_is_duplicate(const struct dst_set *set, const struct dst *test)
2583 {
2584     size_t i;
2585     for (i = 0; i < set->n; i++) {
2586         if (set->dsts[i].vlan == test->vlan
2587             && set->dsts[i].dp_ifidx == test->dp_ifidx) {
2588             return true;
2589         }
2590     }
2591     return false;
2592 }
2593
2594 static bool
2595 port_trunks_vlan(const struct port *port, uint16_t vlan)
2596 {
2597     return (port->vlan < 0
2598             && (!port->trunks || bitmap_is_set(port->trunks, vlan)));
2599 }
2600
2601 static bool
2602 port_includes_vlan(const struct port *port, uint16_t vlan)
2603 {
2604     return vlan == port->vlan || port_trunks_vlan(port, vlan);
2605 }
2606
2607 static bool
2608 port_is_floodable(const struct port *port)
2609 {
2610     int i;
2611
2612     for (i = 0; i < port->n_ifaces; i++) {
2613         if (!ofproto_port_is_floodable(port->bridge->ofproto,
2614                                        port->ifaces[i]->dp_ifidx)) {
2615             return false;
2616         }
2617     }
2618     return true;
2619 }
2620
2621 static void
2622 compose_dsts(const struct bridge *br, const struct flow *flow, uint16_t vlan,
2623              const struct port *in_port, const struct port *out_port,
2624              struct dst_set *set, tag_type *tags, uint16_t *nf_output_iface)
2625 {
2626     mirror_mask_t mirrors = in_port->src_mirrors;
2627     struct dst dst;
2628     int flow_vlan;
2629     size_t i;
2630
2631     flow_vlan = vlan_tci_to_vid(flow->vlan_tci);
2632     if (flow_vlan == 0) {
2633         flow_vlan = OFP_VLAN_NONE;
2634     }
2635
2636     if (out_port == FLOOD_PORT) {
2637         for (i = 0; i < br->n_ports; i++) {
2638             struct port *port = br->ports[i];
2639             if (port != in_port
2640                 && port_is_floodable(port)
2641                 && port_includes_vlan(port, vlan)
2642                 && !port->is_mirror_output_port
2643                 && set_dst(&dst, flow, in_port, port, tags)) {
2644                 mirrors |= port->dst_mirrors;
2645                 dst_set_add(set, &dst);
2646             }
2647         }
2648         *nf_output_iface = NF_OUT_FLOOD;
2649     } else if (out_port && set_dst(&dst, flow, in_port, out_port, tags)) {
2650         dst_set_add(set, &dst);
2651         *nf_output_iface = dst.dp_ifidx;
2652         mirrors |= out_port->dst_mirrors;
2653     }
2654
2655     while (mirrors) {
2656         struct mirror *m = br->mirrors[mirror_mask_ffs(mirrors) - 1];
2657         if (!m->n_vlans || vlan_is_mirrored(m, vlan)) {
2658             if (m->out_port) {
2659                 if (set_dst(&dst, flow, in_port, m->out_port, tags)
2660                     && !dst_is_duplicate(set, &dst)) {
2661                     dst_set_add(set, &dst);
2662                 }
2663             } else {
2664                 for (i = 0; i < br->n_ports; i++) {
2665                     struct port *port = br->ports[i];
2666                     if (port_includes_vlan(port, m->out_vlan)
2667                         && set_dst(&dst, flow, in_port, port, tags))
2668                     {
2669                         if (port->vlan < 0) {
2670                             dst.vlan = m->out_vlan;
2671                         }
2672                         if (dst_is_duplicate(set, &dst)) {
2673                             continue;
2674                         }
2675
2676                         /* Use the vlan tag on the original flow instead of
2677                          * the one passed in the vlan parameter.  This ensures
2678                          * that we compare the vlan from before any implicit
2679                          * tagging tags place. This is necessary because
2680                          * dst->vlan is the final vlan, after removing implicit
2681                          * tags. */
2682                         if (port == in_port && dst.vlan == flow_vlan) {
2683                             /* Don't send out input port on same VLAN. */
2684                             continue;
2685                         }
2686                         dst_set_add(set, &dst);
2687                     }
2688                 }
2689             }
2690         }
2691         mirrors &= mirrors - 1;
2692     }
2693
2694     partition_dsts(set, flow_vlan);
2695 }
2696
2697 static void OVS_UNUSED
2698 print_dsts(const struct dst_set *set)
2699 {
2700     size_t i;
2701
2702     for (i = 0; i < set->n; i++) {
2703         const struct dst *dst = &set->dsts[i];
2704
2705         printf(">p%"PRIu16, dst->dp_ifidx);
2706         if (dst->vlan != OFP_VLAN_NONE) {
2707             printf("v%"PRIu16, dst->vlan);
2708         }
2709     }
2710 }
2711
2712 static void
2713 compose_actions(struct bridge *br, const struct flow *flow, uint16_t vlan,
2714                 const struct port *in_port, const struct port *out_port,
2715                 tag_type *tags, struct ofpbuf *actions,
2716                 uint16_t *nf_output_iface)
2717 {
2718     struct dst_set set;
2719     uint16_t cur_vlan;
2720     size_t i;
2721
2722     dst_set_init(&set);
2723     compose_dsts(br, flow, vlan, in_port, out_port, &set, tags,
2724                  nf_output_iface);
2725
2726     cur_vlan = vlan_tci_to_vid(flow->vlan_tci);
2727     if (cur_vlan == 0) {
2728         cur_vlan = OFP_VLAN_NONE;
2729     }
2730     for (i = 0; i < set.n; i++) {
2731         const struct dst *dst = &set.dsts[i];
2732         if (dst->vlan != cur_vlan) {
2733             if (dst->vlan == OFP_VLAN_NONE) {
2734                 nl_msg_put_flag(actions, ODP_ACTION_ATTR_STRIP_VLAN);
2735             } else {
2736                 ovs_be16 tci;
2737                 tci = htons(dst->vlan & VLAN_VID_MASK);
2738                 tci |= flow->vlan_tci & htons(VLAN_PCP_MASK);
2739                 nl_msg_put_be16(actions, ODP_ACTION_ATTR_SET_DL_TCI, tci);
2740             }
2741             cur_vlan = dst->vlan;
2742         }
2743         nl_msg_put_u32(actions, ODP_ACTION_ATTR_OUTPUT, dst->dp_ifidx);
2744     }
2745     dst_set_free(&set);
2746 }
2747
2748 /* Returns the effective vlan of a packet, taking into account both the
2749  * 802.1Q header and implicitly tagged ports.  A value of 0 indicates that
2750  * the packet is untagged and -1 indicates it has an invalid header and
2751  * should be dropped. */
2752 static int flow_get_vlan(struct bridge *br, const struct flow *flow,
2753                          struct port *in_port, bool have_packet)
2754 {
2755     int vlan = vlan_tci_to_vid(flow->vlan_tci);
2756     if (in_port->vlan >= 0) {
2757         if (vlan) {
2758             /* XXX support double tagging? */
2759             if (have_packet) {
2760                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2761                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
2762                              "packet received on port %s configured with "
2763                              "implicit VLAN %"PRIu16,
2764                              br->name, vlan, in_port->name, in_port->vlan);
2765             }
2766             return -1;
2767         }
2768         vlan = in_port->vlan;
2769     } else {
2770         if (!port_includes_vlan(in_port, vlan)) {
2771             if (have_packet) {
2772                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2773                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
2774                              "packet received on port %s not configured for "
2775                              "trunking VLAN %d",
2776                              br->name, vlan, in_port->name, vlan);
2777             }
2778             return -1;
2779         }
2780     }
2781
2782     return vlan;
2783 }
2784
2785 /* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
2786  * migration.  Older Citrix-patched Linux DomU used gratuitous ARP replies to
2787  * indicate this; newer upstream kernels use gratuitous ARP requests. */
2788 static bool
2789 is_gratuitous_arp(const struct flow *flow)
2790 {
2791     return (flow->dl_type == htons(ETH_TYPE_ARP)
2792             && eth_addr_is_broadcast(flow->dl_dst)
2793             && (flow->nw_proto == ARP_OP_REPLY
2794                 || (flow->nw_proto == ARP_OP_REQUEST
2795                     && flow->nw_src == flow->nw_dst)));
2796 }
2797
2798 static void
2799 update_learning_table(struct bridge *br, const struct flow *flow, int vlan,
2800                       struct port *in_port)
2801 {
2802     enum grat_arp_lock_type lock_type;
2803     tag_type rev_tag;
2804
2805     /* We don't want to learn from gratuitous ARP packets that are reflected
2806      * back over bond slaves so we lock the learning table. */
2807     lock_type = !is_gratuitous_arp(flow) ? GRAT_ARP_LOCK_NONE :
2808                     (in_port->n_ifaces == 1) ? GRAT_ARP_LOCK_SET :
2809                                                GRAT_ARP_LOCK_CHECK;
2810
2811     rev_tag = mac_learning_learn(br->ml, flow->dl_src, vlan, in_port->port_idx,
2812                                  lock_type);
2813     if (rev_tag) {
2814         /* The log messages here could actually be useful in debugging,
2815          * so keep the rate limit relatively high. */
2816         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30,
2817                                                                 300);
2818         VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
2819                     "on port %s in VLAN %d",
2820                     br->name, ETH_ADDR_ARGS(flow->dl_src),
2821                     in_port->name, vlan);
2822         ofproto_revalidate(br->ofproto, rev_tag);
2823     }
2824 }
2825
2826 /* Determines whether packets in 'flow' within 'br' should be forwarded or
2827  * dropped.  Returns true if they may be forwarded, false if they should be
2828  * dropped.
2829  *
2830  * If 'have_packet' is true, it indicates that the caller is processing a
2831  * received packet.  If 'have_packet' is false, then the caller is just
2832  * revalidating an existing flow because configuration has changed.  Either
2833  * way, 'have_packet' only affects logging (there is no point in logging errors
2834  * during revalidation).
2835  *
2836  * Sets '*in_portp' to the input port.  This will be a null pointer if
2837  * flow->in_port does not designate a known input port (in which case
2838  * is_admissible() returns false).
2839  *
2840  * When returning true, sets '*vlanp' to the effective VLAN of the input
2841  * packet, as returned by flow_get_vlan().
2842  *
2843  * May also add tags to '*tags', although the current implementation only does
2844  * so in one special case.
2845  */
2846 static bool
2847 is_admissible(struct bridge *br, const struct flow *flow, bool have_packet,
2848               tag_type *tags, int *vlanp, struct port **in_portp)
2849 {
2850     struct iface *in_iface;
2851     struct port *in_port;
2852     int vlan;
2853
2854     /* Find the interface and port structure for the received packet. */
2855     in_iface = iface_from_dp_ifidx(br, flow->in_port);
2856     if (!in_iface) {
2857         /* No interface?  Something fishy... */
2858         if (have_packet) {
2859             /* Odd.  A few possible reasons here:
2860              *
2861              * - We deleted an interface but there are still a few packets
2862              *   queued up from it.
2863              *
2864              * - Someone externally added an interface (e.g. with "ovs-dpctl
2865              *   add-if") that we don't know about.
2866              *
2867              * - Packet arrived on the local port but the local port is not
2868              *   one of our bridge ports.
2869              */
2870             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2871
2872             VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
2873                          "interface %"PRIu16, br->name, flow->in_port);
2874         }
2875
2876         *in_portp = NULL;
2877         return false;
2878     }
2879     *in_portp = in_port = in_iface->port;
2880     *vlanp = vlan = flow_get_vlan(br, flow, in_port, have_packet);
2881     if (vlan < 0) {
2882         return false;
2883     }
2884
2885     /* Drop frames for reserved multicast addresses. */
2886     if (eth_addr_is_reserved(flow->dl_dst)) {
2887         return false;
2888     }
2889
2890     /* Drop frames on ports reserved for mirroring. */
2891     if (in_port->is_mirror_output_port) {
2892         if (have_packet) {
2893             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2894             VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
2895                          "%s, which is reserved exclusively for mirroring",
2896                          br->name, in_port->name);
2897         }
2898         return false;
2899     }
2900
2901     /* When using LACP, do not accept packets from disabled interfaces. */
2902     if (in_port->lacp & LACP_NEGOTIATED && !in_iface->enabled) {
2903         return false;
2904     }
2905
2906     /* Packets received on non-LACP bonds need special attention to avoid
2907      * duplicates. */
2908     if (in_port->n_ifaces > 1 && !(in_port->lacp & LACP_NEGOTIATED)) {
2909         int src_idx;
2910         bool is_grat_arp_locked;
2911
2912         if (eth_addr_is_multicast(flow->dl_dst)) {
2913             *tags |= in_port->active_iface_tag;
2914             if (in_port->active_iface != in_iface->port_ifidx) {
2915                 /* Drop all multicast packets on inactive slaves. */
2916                 return false;
2917             }
2918         }
2919
2920         /* Drop all packets for which we have learned a different input
2921          * port, because we probably sent the packet on one slave and got
2922          * it back on the other.  Gratuitous ARP packets are an exception
2923          * to this rule: the host has moved to another switch.  The exception
2924          * to the exception is if we locked the learning table to avoid
2925          * reflections on bond slaves.  If this is the case, just drop the
2926          * packet now. */
2927         src_idx = mac_learning_lookup(br->ml, flow->dl_src, vlan,
2928                                       &is_grat_arp_locked);
2929         if (src_idx != -1 && src_idx != in_port->port_idx &&
2930             (!is_gratuitous_arp(flow) || is_grat_arp_locked)) {
2931                 return false;
2932         }
2933     }
2934
2935     return true;
2936 }
2937
2938 /* If the composed actions may be applied to any packet in the given 'flow',
2939  * returns true.  Otherwise, the actions should only be applied to 'packet', or
2940  * not at all, if 'packet' was NULL. */
2941 static bool
2942 process_flow(struct bridge *br, const struct flow *flow,
2943              const struct ofpbuf *packet, struct ofpbuf *actions,
2944              tag_type *tags, uint16_t *nf_output_iface)
2945 {
2946     struct port *in_port;
2947     struct port *out_port;
2948     int vlan;
2949     int out_port_idx;
2950
2951     /* Check whether we should drop packets in this flow. */
2952     if (!is_admissible(br, flow, packet != NULL, tags, &vlan, &in_port)) {
2953         out_port = NULL;
2954         goto done;
2955     }
2956
2957     /* Learn source MAC (but don't try to learn from revalidation). */
2958     if (packet) {
2959         update_learning_table(br, flow, vlan, in_port);
2960     }
2961
2962     /* Determine output port. */
2963     out_port_idx = mac_learning_lookup_tag(br->ml, flow->dl_dst, vlan, tags,
2964                                            NULL);
2965     if (out_port_idx >= 0 && out_port_idx < br->n_ports) {
2966         out_port = br->ports[out_port_idx];
2967     } else if (!packet && !eth_addr_is_multicast(flow->dl_dst)) {
2968         /* If we are revalidating but don't have a learning entry then
2969          * eject the flow.  Installing a flow that floods packets opens
2970          * up a window of time where we could learn from a packet reflected
2971          * on a bond and blackhole packets before the learning table is
2972          * updated to reflect the correct port. */
2973         return false;
2974     } else {
2975         out_port = FLOOD_PORT;
2976     }
2977
2978     /* Don't send packets out their input ports. */
2979     if (in_port == out_port) {
2980         out_port = NULL;
2981     }
2982
2983 done:
2984     if (in_port) {
2985         compose_actions(br, flow, vlan, in_port, out_port, tags, actions,
2986                         nf_output_iface);
2987     }
2988
2989     return true;
2990 }
2991
2992 static bool
2993 bridge_normal_ofhook_cb(const struct flow *flow, const struct ofpbuf *packet,
2994                         struct ofpbuf *actions, tag_type *tags,
2995                         uint16_t *nf_output_iface, void *br_)
2996 {
2997     struct bridge *br = br_;
2998
2999     COVERAGE_INC(bridge_process_flow);
3000     return process_flow(br, flow, packet, actions, tags, nf_output_iface);
3001 }
3002
3003 static bool
3004 bridge_special_ofhook_cb(const struct flow *flow,
3005                          const struct ofpbuf *packet, void *br_)
3006 {
3007     struct iface *iface;
3008     struct bridge *br = br_;
3009
3010     iface = iface_from_dp_ifidx(br, flow->in_port);
3011
3012     if (cfm_should_process_flow(flow)) {
3013
3014         if (iface && packet && iface->cfm) {
3015             COVERAGE_INC(bridge_process_cfm);
3016             cfm_process_heartbeat(iface->cfm, packet);
3017         }
3018         return false;
3019     } else if (flow->dl_type == htons(ETH_TYPE_LACP)) {
3020
3021         if (iface && packet) {
3022             COVERAGE_INC(bridge_process_lacp);
3023             lacp_process_packet(packet, iface);
3024         }
3025         return false;
3026     }
3027
3028     return true;
3029 }
3030
3031 static void
3032 bridge_account_flow_ofhook_cb(const struct flow *flow, tag_type tags,
3033                               const struct nlattr *actions,
3034                               size_t actions_len,
3035                               unsigned long long int n_bytes, void *br_)
3036 {
3037     struct bridge *br = br_;
3038     const struct nlattr *a;
3039     struct port *in_port;
3040     tag_type dummy = 0;
3041     unsigned int left;
3042     int vlan;
3043
3044     /* Feed information from the active flows back into the learning table to
3045      * ensure that table is always in sync with what is actually flowing
3046      * through the datapath.
3047      *
3048      * We test that 'tags' is nonzero to ensure that only flows that include an
3049      * OFPP_NORMAL action are used for learning.  This works because
3050      * bridge_normal_ofhook_cb() always sets a nonzero tag value. */
3051     if (tags && is_admissible(br, flow, false, &dummy, &vlan, &in_port)) {
3052         update_learning_table(br, flow, vlan, in_port);
3053     }
3054
3055     /* Account for bond slave utilization. */
3056     if (!br->has_bonded_ports) {
3057         return;
3058     }
3059     NL_ATTR_FOR_EACH_UNSAFE (a, left, actions, actions_len) {
3060         if (nl_attr_type(a) == ODP_ACTION_ATTR_OUTPUT) {
3061             struct port *out_port = port_from_dp_ifidx(br, nl_attr_get_u32(a));
3062             if (out_port && out_port->n_ifaces >= 2 &&
3063                 out_port->bond_mode != BM_AB) {
3064                 uint16_t vlan = (flow->vlan_tci
3065                                  ? vlan_tci_to_vid(flow->vlan_tci)
3066                                  : OFP_VLAN_NONE);
3067                 struct bond_entry *e = lookup_bond_entry(out_port, flow, vlan);
3068                 e->tx_bytes += n_bytes;
3069             }
3070         }
3071     }
3072 }
3073
3074 static void
3075 bridge_account_checkpoint_ofhook_cb(void *br_)
3076 {
3077     struct bridge *br = br_;
3078     long long int now;
3079     size_t i;
3080
3081     if (!br->has_bonded_ports) {
3082         return;
3083     }
3084
3085     now = time_msec();
3086     for (i = 0; i < br->n_ports; i++) {
3087         struct port *port = br->ports[i];
3088         if (port->n_ifaces > 1 && port->bond_mode != BM_AB
3089             && now >= port->bond_next_rebalance) {
3090             port->bond_next_rebalance = now + port->bond_rebalance_interval;
3091             bond_rebalance_port(port);
3092         }
3093     }
3094 }
3095
3096 static struct ofhooks bridge_ofhooks = {
3097     bridge_normal_ofhook_cb,
3098     bridge_special_ofhook_cb,
3099     bridge_account_flow_ofhook_cb,
3100     bridge_account_checkpoint_ofhook_cb,
3101 };
3102 \f
3103 /* LACP functions. */
3104
3105 static void
3106 lacp_process_packet(const struct ofpbuf *packet, struct iface *iface)
3107 {
3108     const struct lacp_pdu *pdu;
3109
3110     if (!iface->port->lacp) {
3111         return;
3112     }
3113
3114     pdu = parse_lacp_packet(packet);
3115     if (!pdu) {
3116         return;
3117     }
3118
3119     iface->lacp_status |= LACP_CURRENT;
3120     iface->lacp_status &= ~(LACP_EXPIRED | LACP_DEFAULTED);
3121     iface->lacp_rx = time_msec() + LACP_SLOW_TIME_RX;
3122
3123     iface->lacp_actor.state = iface_get_lacp_state(iface);
3124     if (memcmp(&iface->lacp_actor, &pdu->partner, sizeof pdu->partner)) {
3125         iface->lacp_tx = 0;
3126     }
3127
3128     if (memcmp(&iface->lacp_partner, &pdu->actor, sizeof pdu->actor)) {
3129         iface->port->lacp_need_update = true;
3130         iface->lacp_partner = pdu->actor;
3131     }
3132 }
3133
3134 static void
3135 lacp_update_ifaces(struct port *port)
3136 {
3137     size_t i;
3138     struct iface *lead;
3139     struct lacp_info lead_pri;
3140     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
3141
3142     port->lacp_need_update = false;
3143     COVERAGE_INC(bridge_lacp_update);
3144
3145     if (!port->lacp) {
3146         return;
3147     }
3148
3149     VLOG_DBG_RL(&rl, "port %s: re-evaluating LACP link status", port->name);
3150
3151     lead = NULL;
3152     for (i = 0; i < port->n_ifaces; i++) {
3153         struct iface *iface = port->ifaces[i];
3154         struct lacp_info pri;
3155
3156         iface->lacp_status |= LACP_ATTACHED;
3157         ofproto_revalidate(port->bridge->ofproto, iface->tag);
3158
3159         /* Don't allow loopback interfaces to send traffic or lead. */
3160         if (eth_addr_equals(iface->lacp_partner.sysid,
3161                             iface->lacp_actor.sysid)) {
3162             VLOG_WARN_RL(&rl, "iface %s: Loopback detected. Interface is "
3163                          "connected to its own bridge", iface->name);
3164             iface->lacp_status &= ~LACP_ATTACHED;
3165             continue;
3166         }
3167
3168         if (iface->lacp_status & LACP_DEFAULTED) {
3169             continue;
3170         }
3171
3172         iface_get_lacp_priority(iface, &pri);
3173
3174         if (!lead || memcmp(&pri, &lead_pri, sizeof pri) < 0) {
3175             lead = iface;
3176             lead_pri = pri;
3177         }
3178     }
3179
3180     if (!lead) {
3181         port->lacp &= ~LACP_NEGOTIATED;
3182         return;
3183     }
3184
3185     port->lacp |= LACP_NEGOTIATED;
3186
3187     for (i = 0; i < port->n_ifaces; i++) {
3188         struct iface *iface = port->ifaces[i];
3189
3190         if (iface->lacp_status & LACP_DEFAULTED
3191             || lead->lacp_partner.key != iface->lacp_partner.key
3192             || !eth_addr_equals(lead->lacp_partner.sysid,
3193                                 iface->lacp_partner.sysid)) {
3194             iface->lacp_status &= ~LACP_ATTACHED;
3195         }
3196     }
3197 }
3198
3199 static bool
3200 lacp_iface_may_tx(const struct iface *iface)
3201 {
3202     return iface->port->lacp & LACP_ACTIVE
3203         || iface->lacp_status & (LACP_CURRENT | LACP_EXPIRED);
3204 }
3205
3206 static void
3207 lacp_run(struct bridge *br)
3208 {
3209     size_t i, j;
3210     struct ofpbuf packet;
3211
3212     ofpbuf_init(&packet, ETH_HEADER_LEN + LACP_PDU_LEN);
3213
3214     for (i = 0; i < br->n_ports; i++) {
3215         struct port *port = br->ports[i];
3216
3217         if (!port->lacp) {
3218             continue;
3219         }
3220
3221         for (j = 0; j < port->n_ifaces; j++) {
3222             struct iface *iface = port->ifaces[j];
3223
3224             if (time_msec() > iface->lacp_rx) {
3225                 if (iface->lacp_status & LACP_CURRENT) {
3226                     iface_set_lacp_expired(iface);
3227                 } else if (iface->lacp_status & LACP_EXPIRED) {
3228                     iface_set_lacp_defaulted(iface);
3229                 }
3230             }
3231         }
3232
3233         if (port->lacp_need_update) {
3234             lacp_update_ifaces(port);
3235         }
3236
3237         for (j = 0; j < port->n_ifaces; j++) {
3238             struct iface *iface = port->ifaces[j];
3239             uint8_t ea[ETH_ADDR_LEN];
3240             int error;
3241
3242             if (time_msec() < iface->lacp_tx || !lacp_iface_may_tx(iface)) {
3243                 continue;
3244             }
3245
3246             error = netdev_get_etheraddr(iface->netdev, ea);
3247             if (!error) {
3248                 iface->lacp_actor.state = iface_get_lacp_state(iface);
3249                 compose_lacp_packet(&packet, &iface->lacp_actor,
3250                                     &iface->lacp_partner, ea);
3251                 iface_send_packet(iface, &packet);
3252             } else {
3253                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
3254                 VLOG_ERR_RL(&rl, "iface %s: failed to obtain Ethernet address "
3255                             "(%s)", iface->name, strerror(error));
3256             }
3257
3258             iface->lacp_tx = time_msec() +
3259                 (iface->lacp_partner.state & LACP_STATE_TIME
3260                  ? LACP_FAST_TIME_TX
3261                  : LACP_SLOW_TIME_TX);
3262         }
3263     }
3264     ofpbuf_uninit(&packet);
3265 }
3266
3267 static void
3268 lacp_wait(struct bridge *br)
3269 {
3270     size_t i, j;
3271
3272     for (i = 0; i < br->n_ports; i++) {
3273         struct port *port = br->ports[i];
3274
3275         if (!port->lacp) {
3276             continue;
3277         }
3278
3279         for (j = 0; j < port->n_ifaces; j++) {
3280             struct iface *iface = port->ifaces[j];
3281
3282             if (lacp_iface_may_tx(iface)) {
3283                 poll_timer_wait_until(iface->lacp_tx);
3284             }
3285
3286             if (iface->lacp_status & (LACP_CURRENT | LACP_EXPIRED)) {
3287                 poll_timer_wait_until(iface->lacp_rx);
3288             }
3289         }
3290     }
3291 }
3292 \f
3293 /* Bonding functions. */
3294
3295 /* Statistics for a single interface on a bonded port, used for load-based
3296  * bond rebalancing.  */
3297 struct slave_balance {
3298     struct iface *iface;        /* The interface. */
3299     uint64_t tx_bytes;          /* Sum of hashes[*]->tx_bytes. */
3300
3301     /* All the "bond_entry"s that are assigned to this interface, in order of
3302      * increasing tx_bytes. */
3303     struct bond_entry **hashes;
3304     size_t n_hashes;
3305 };
3306
3307 static const char *
3308 bond_mode_to_string(enum bond_mode bm) {
3309     static char *bm_slb = "balance-slb";
3310     static char *bm_ab  = "active-backup";
3311     static char *bm_tcp = "balance-tcp";
3312
3313     switch (bm) {
3314     case BM_SLB: return bm_slb;
3315     case BM_AB:  return bm_ab;
3316     case BM_TCP: return bm_tcp;
3317     }
3318
3319     NOT_REACHED();
3320     return NULL;
3321 }
3322
3323 /* Sorts pointers to pointers to bond_entries in ascending order by the
3324  * interface to which they are assigned, and within a single interface in
3325  * ascending order of bytes transmitted. */
3326 static int
3327 compare_bond_entries(const void *a_, const void *b_)
3328 {
3329     const struct bond_entry *const *ap = a_;
3330     const struct bond_entry *const *bp = b_;
3331     const struct bond_entry *a = *ap;
3332     const struct bond_entry *b = *bp;
3333     if (a->iface_idx != b->iface_idx) {
3334         return a->iface_idx > b->iface_idx ? 1 : -1;
3335     } else if (a->tx_bytes != b->tx_bytes) {
3336         return a->tx_bytes > b->tx_bytes ? 1 : -1;
3337     } else {
3338         return 0;
3339     }
3340 }
3341
3342 /* Sorts slave_balances so that enabled ports come first, and otherwise in
3343  * *descending* order by number of bytes transmitted. */
3344 static int
3345 compare_slave_balance(const void *a_, const void *b_)
3346 {
3347     const struct slave_balance *a = a_;
3348     const struct slave_balance *b = b_;
3349     if (a->iface->enabled != b->iface->enabled) {
3350         return a->iface->enabled ? -1 : 1;
3351     } else if (a->tx_bytes != b->tx_bytes) {
3352         return a->tx_bytes > b->tx_bytes ? -1 : 1;
3353     } else {
3354         return 0;
3355     }
3356 }
3357
3358 static void
3359 swap_bals(struct slave_balance *a, struct slave_balance *b)
3360 {
3361     struct slave_balance tmp = *a;
3362     *a = *b;
3363     *b = tmp;
3364 }
3365
3366 /* Restores the 'n_bals' slave_balance structures in 'bals' to sorted order
3367  * given that 'p' (and only 'p') might be in the wrong location.
3368  *
3369  * This function invalidates 'p', since it might now be in a different memory
3370  * location. */
3371 static void
3372 resort_bals(struct slave_balance *p,
3373             struct slave_balance bals[], size_t n_bals)
3374 {
3375     if (n_bals > 1) {
3376         for (; p > bals && p->tx_bytes > p[-1].tx_bytes; p--) {
3377             swap_bals(p, p - 1);
3378         }
3379         for (; p < &bals[n_bals - 1] && p->tx_bytes < p[1].tx_bytes; p++) {
3380             swap_bals(p, p + 1);
3381         }
3382     }
3383 }
3384
3385 static void
3386 log_bals(const struct slave_balance *bals, size_t n_bals, struct port *port)
3387 {
3388     if (VLOG_IS_DBG_ENABLED()) {
3389         struct ds ds = DS_EMPTY_INITIALIZER;
3390         const struct slave_balance *b;
3391
3392         for (b = bals; b < bals + n_bals; b++) {
3393             size_t i;
3394
3395             if (b > bals) {
3396                 ds_put_char(&ds, ',');
3397             }
3398             ds_put_format(&ds, " %s %"PRIu64"kB",
3399                           b->iface->name, b->tx_bytes / 1024);
3400
3401             if (!b->iface->enabled) {
3402                 ds_put_cstr(&ds, " (disabled)");
3403             }
3404             if (b->n_hashes > 0) {
3405                 ds_put_cstr(&ds, " (");
3406                 for (i = 0; i < b->n_hashes; i++) {
3407                     const struct bond_entry *e = b->hashes[i];
3408                     if (i > 0) {
3409                         ds_put_cstr(&ds, " + ");
3410                     }
3411                     ds_put_format(&ds, "h%td: %"PRIu64"kB",
3412                                   e - port->bond_hash, e->tx_bytes / 1024);
3413                 }
3414                 ds_put_cstr(&ds, ")");
3415             }
3416         }
3417         VLOG_DBG("bond %s:%s", port->name, ds_cstr(&ds));
3418         ds_destroy(&ds);
3419     }
3420 }
3421
3422 /* Shifts 'hash' from 'from' to 'to' within 'port'. */
3423 static void
3424 bond_shift_load(struct slave_balance *from, struct slave_balance *to,
3425                 int hash_idx)
3426 {
3427     struct bond_entry *hash = from->hashes[hash_idx];
3428     struct port *port = from->iface->port;
3429     uint64_t delta = hash->tx_bytes;
3430
3431     assert(port->bond_mode != BM_AB);
3432
3433     VLOG_INFO("bond %s: shift %"PRIu64"kB of load (with hash %td) "
3434               "from %s to %s (now carrying %"PRIu64"kB and "
3435               "%"PRIu64"kB load, respectively)",
3436               port->name, delta / 1024, hash - port->bond_hash,
3437               from->iface->name, to->iface->name,
3438               (from->tx_bytes - delta) / 1024,
3439               (to->tx_bytes + delta) / 1024);
3440
3441     /* Delete element from from->hashes.
3442      *
3443      * We don't bother to add the element to to->hashes because not only would
3444      * it require more work, the only purpose it would be to allow that hash to
3445      * be migrated to another slave in this rebalancing run, and there is no
3446      * point in doing that.  */
3447     if (hash_idx == 0) {
3448         from->hashes++;
3449     } else {
3450         memmove(from->hashes + hash_idx, from->hashes + hash_idx + 1,
3451                 (from->n_hashes - (hash_idx + 1)) * sizeof *from->hashes);
3452     }
3453     from->n_hashes--;
3454
3455     /* Shift load away from 'from' to 'to'. */
3456     from->tx_bytes -= delta;
3457     to->tx_bytes += delta;
3458
3459     /* Arrange for flows to be revalidated. */
3460     ofproto_revalidate(port->bridge->ofproto, hash->iface_tag);
3461     hash->iface_idx = to->iface->port_ifidx;
3462     hash->iface_tag = tag_create_random();
3463 }
3464
3465 static void
3466 bond_rebalance_port(struct port *port)
3467 {
3468     struct slave_balance *bals;
3469     size_t n_bals;
3470     struct bond_entry *hashes[BOND_MASK + 1];
3471     struct slave_balance *b, *from, *to;
3472     struct bond_entry *e;
3473     size_t i;
3474
3475     assert(port->bond_mode != BM_AB);
3476
3477     /* Sets up 'bals' to describe each of the port's interfaces, sorted in
3478      * descending order of tx_bytes, so that bals[0] represents the most
3479      * heavily loaded slave and bals[n_bals - 1] represents the least heavily
3480      * loaded slave.
3481      *
3482      * The code is a bit tricky: to avoid dynamically allocating a 'hashes'
3483      * array for each slave_balance structure, we sort our local array of
3484      * hashes in order by slave, so that all of the hashes for a given slave
3485      * become contiguous in memory, and then we point each 'hashes' members of
3486      * a slave_balance structure to the start of a contiguous group. */
3487     n_bals = port->n_ifaces;
3488     bals = xmalloc(n_bals * sizeof *bals);
3489     for (b = bals; b < &bals[n_bals]; b++) {
3490         b->iface = port->ifaces[b - bals];
3491         b->tx_bytes = 0;
3492         b->hashes = NULL;
3493         b->n_hashes = 0;
3494     }
3495     for (i = 0; i <= BOND_MASK; i++) {
3496         hashes[i] = &port->bond_hash[i];
3497     }
3498     qsort(hashes, BOND_MASK + 1, sizeof *hashes, compare_bond_entries);
3499     for (i = 0; i <= BOND_MASK; i++) {
3500         e = hashes[i];
3501         if (e->iface_idx >= 0 && e->iface_idx < port->n_ifaces) {
3502             b = &bals[e->iface_idx];
3503             b->tx_bytes += e->tx_bytes;
3504             if (!b->hashes) {
3505                 b->hashes = &hashes[i];
3506             }
3507             b->n_hashes++;
3508         }
3509     }
3510     qsort(bals, n_bals, sizeof *bals, compare_slave_balance);
3511     log_bals(bals, n_bals, port);
3512
3513     /* Discard slaves that aren't enabled (which were sorted to the back of the
3514      * array earlier). */
3515     while (!bals[n_bals - 1].iface->enabled) {
3516         n_bals--;
3517         if (!n_bals) {
3518             goto exit;
3519         }
3520     }
3521
3522     /* Shift load from the most-loaded slaves to the least-loaded slaves. */
3523     to = &bals[n_bals - 1];
3524     for (from = bals; from < to; ) {
3525         uint64_t overload = from->tx_bytes - to->tx_bytes;
3526         if (overload < to->tx_bytes >> 5 || overload < 100000) {
3527             /* The extra load on 'from' (and all less-loaded slaves), compared
3528              * to that of 'to' (the least-loaded slave), is less than ~3%, or
3529              * it is less than ~1Mbps.  No point in rebalancing. */
3530             break;
3531         } else if (from->n_hashes == 1) {
3532             /* 'from' only carries a single MAC hash, so we can't shift any
3533              * load away from it, even though we want to. */
3534             from++;
3535         } else {
3536             /* 'from' is carrying significantly more load than 'to', and that
3537              * load is split across at least two different hashes.  Pick a hash
3538              * to migrate to 'to' (the least-loaded slave), given that doing so
3539              * must decrease the ratio of the load on the two slaves by at
3540              * least 0.1.
3541              *
3542              * The sort order we use means that we prefer to shift away the
3543              * smallest hashes instead of the biggest ones.  There is little
3544              * reason behind this decision; we could use the opposite sort
3545              * order to shift away big hashes ahead of small ones. */
3546             bool order_swapped;
3547
3548             for (i = 0; i < from->n_hashes; i++) {
3549                 double old_ratio, new_ratio;
3550                 uint64_t delta = from->hashes[i]->tx_bytes;
3551
3552                 if (delta == 0 || from->tx_bytes - delta == 0) {
3553                     /* Pointless move. */
3554                     continue;
3555                 }
3556
3557                 order_swapped = from->tx_bytes - delta < to->tx_bytes + delta;
3558
3559                 if (to->tx_bytes == 0) {
3560                     /* Nothing on the new slave, move it. */
3561                     break;
3562                 }
3563
3564                 old_ratio = (double)from->tx_bytes / to->tx_bytes;
3565                 new_ratio = (double)(from->tx_bytes - delta) /
3566                             (to->tx_bytes + delta);
3567
3568                 if (new_ratio == 0) {
3569                     /* Should already be covered but check to prevent division
3570                      * by zero. */
3571                     continue;
3572                 }
3573
3574                 if (new_ratio < 1) {
3575                     new_ratio = 1 / new_ratio;
3576                 }
3577
3578                 if (old_ratio - new_ratio > 0.1) {
3579                     /* Would decrease the ratio, move it. */
3580                     break;
3581                 }
3582             }
3583             if (i < from->n_hashes) {
3584                 bond_shift_load(from, to, i);
3585
3586                 /* If the result of the migration changed the relative order of
3587                  * 'from' and 'to' swap them back to maintain invariants. */
3588                 if (order_swapped) {
3589                     swap_bals(from, to);
3590                 }
3591
3592                 /* Re-sort 'bals'.  Note that this may make 'from' and 'to'
3593                  * point to different slave_balance structures.  It is only
3594                  * valid to do these two operations in a row at all because we
3595                  * know that 'from' will not move past 'to' and vice versa. */
3596                 resort_bals(from, bals, n_bals);
3597                 resort_bals(to, bals, n_bals);
3598             } else {
3599                 from++;
3600             }
3601         }
3602     }
3603
3604     /* Implement exponentially weighted moving average.  A weight of 1/2 causes
3605      * historical data to decay to <1% in 7 rebalancing runs.  */
3606     for (e = &port->bond_hash[0]; e <= &port->bond_hash[BOND_MASK]; e++) {
3607         e->tx_bytes /= 2;
3608     }
3609
3610 exit:
3611     free(bals);
3612 }
3613
3614 static void
3615 bond_send_learning_packets(struct port *port)
3616 {
3617     struct bridge *br = port->bridge;
3618     struct mac_entry *e;
3619     struct ofpbuf packet;
3620     int error, n_packets, n_errors;
3621
3622     if (!port->n_ifaces || port->active_iface < 0 || bond_is_tcp_hash(port)) {
3623         return;
3624     }
3625
3626     ofpbuf_init(&packet, 128);
3627     error = n_packets = n_errors = 0;
3628     LIST_FOR_EACH (e, lru_node, &br->ml->lrus) {
3629         union ofp_action actions[2], *a;
3630         uint16_t dp_ifidx;
3631         tag_type tags = 0;
3632         struct flow flow;
3633         int retval;
3634
3635         if (e->port == port->port_idx) {
3636             continue;
3637         }
3638
3639         compose_benign_packet(&packet, "Open vSwitch Bond Failover", 0xf177,
3640                               e->mac);
3641         flow_extract(&packet, 0, ODPP_NONE, &flow);
3642
3643         if (!choose_output_iface(port, &flow, e->vlan, &dp_ifidx, &tags)) {
3644             continue;
3645         }
3646
3647         /* Compose actions. */
3648         memset(actions, 0, sizeof actions);
3649         a = actions;
3650         if (e->vlan) {
3651             a->vlan_vid.type = htons(OFPAT_SET_VLAN_VID);
3652             a->vlan_vid.len = htons(sizeof *a);
3653             a->vlan_vid.vlan_vid = htons(e->vlan);
3654             a++;
3655         }
3656         a->output.type = htons(OFPAT_OUTPUT);
3657         a->output.len = htons(sizeof *a);
3658         a->output.port = htons(odp_port_to_ofp_port(dp_ifidx));
3659         a++;
3660
3661         /* Send packet. */
3662         n_packets++;
3663         retval = ofproto_send_packet(br->ofproto, &flow, actions, a - actions,
3664                                      &packet);
3665         if (retval) {
3666             error = retval;
3667             n_errors++;
3668         }
3669     }
3670     ofpbuf_uninit(&packet);
3671
3672     if (n_errors) {
3673         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
3674         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
3675                      "packets, last error was: %s",
3676                      port->name, n_errors, n_packets, strerror(error));
3677     } else {
3678         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
3679                  port->name, n_packets);
3680     }
3681 }
3682 \f
3683 /* Bonding unixctl user interface functions. */
3684
3685 static void
3686 bond_unixctl_list(struct unixctl_conn *conn,
3687                   const char *args OVS_UNUSED, void *aux OVS_UNUSED)
3688 {
3689     struct ds ds = DS_EMPTY_INITIALIZER;
3690     const struct bridge *br;
3691
3692     ds_put_cstr(&ds, "bridge\tbond\ttype\tslaves\n");
3693
3694     LIST_FOR_EACH (br, node, &all_bridges) {
3695         size_t i;
3696
3697         for (i = 0; i < br->n_ports; i++) {
3698             const struct port *port = br->ports[i];
3699             if (port->n_ifaces > 1) {
3700                 size_t j;
3701
3702                 ds_put_format(&ds, "%s\t%s\t%s\t", br->name, port->name,
3703                               bond_mode_to_string(port->bond_mode));
3704                 for (j = 0; j < port->n_ifaces; j++) {
3705                     const struct iface *iface = port->ifaces[j];
3706                     if (j) {
3707                         ds_put_cstr(&ds, ", ");
3708                     }
3709                     ds_put_cstr(&ds, iface->name);
3710                 }
3711                 ds_put_char(&ds, '\n');
3712             }
3713         }
3714     }
3715     unixctl_command_reply(conn, 200, ds_cstr(&ds));
3716     ds_destroy(&ds);
3717 }
3718
3719 static struct port *
3720 bond_find(const char *name)
3721 {
3722     const struct bridge *br;
3723
3724     LIST_FOR_EACH (br, node, &all_bridges) {
3725         size_t i;
3726
3727         for (i = 0; i < br->n_ports; i++) {
3728             struct port *port = br->ports[i];
3729             if (!strcmp(port->name, name) && port->n_ifaces > 1) {
3730                 return port;
3731             }
3732         }
3733     }
3734     return NULL;
3735 }
3736
3737 static void
3738 ds_put_lacp_state(struct ds *ds, uint8_t state)
3739 {
3740     if (state & LACP_STATE_ACT) {
3741         ds_put_cstr(ds, "activity ");
3742     }
3743
3744     if (state & LACP_STATE_TIME) {
3745         ds_put_cstr(ds, "timeout ");
3746     }
3747
3748     if (state & LACP_STATE_AGG) {
3749         ds_put_cstr(ds, "aggregation ");
3750     }
3751
3752     if (state & LACP_STATE_SYNC) {
3753         ds_put_cstr(ds, "synchronized ");
3754     }
3755
3756     if (state & LACP_STATE_COL) {
3757         ds_put_cstr(ds, "collecting ");
3758     }
3759
3760     if (state & LACP_STATE_DIST) {
3761         ds_put_cstr(ds, "distributing ");
3762     }
3763
3764     if (state & LACP_STATE_DEF) {
3765         ds_put_cstr(ds, "defaulted ");
3766     }
3767
3768     if (state & LACP_STATE_EXP) {
3769         ds_put_cstr(ds, "expired ");
3770     }
3771 }
3772
3773 static void
3774 bond_unixctl_show(struct unixctl_conn *conn,
3775                   const char *args, void *aux OVS_UNUSED)
3776 {
3777     struct ds ds = DS_EMPTY_INITIALIZER;
3778     const struct port *port;
3779     size_t j;
3780
3781     port = bond_find(args);
3782     if (!port) {
3783         unixctl_command_reply(conn, 501, "no such bond");
3784         return;
3785     }
3786
3787     ds_put_format(&ds, "bond_mode: %s\n",
3788                   bond_mode_to_string(port->bond_mode));
3789
3790     if (port->lacp) {
3791         ds_put_format(&ds, "lacp: %s\n",
3792                       port->lacp & LACP_ACTIVE ? "active" : "passive");
3793     } else {
3794         ds_put_cstr(&ds, "lacp: off\n");
3795     }
3796
3797     if (port->bond_mode != BM_AB) {
3798         ds_put_format(&ds, "bond-hash-algorithm: %s\n",
3799                       bond_is_tcp_hash(port) ? "balance-tcp" : "balance-slb");
3800     }
3801
3802
3803     ds_put_format(&ds, "bond-detect-mode: %s\n",
3804                   port->miimon ? "miimon" : "carrier");
3805
3806     if (port->miimon) {
3807         ds_put_format(&ds, "bond-miimon-interval: %lld\n",
3808                       port->bond_miimon_interval);
3809     }
3810
3811     ds_put_format(&ds, "updelay: %d ms\n", port->updelay);
3812     ds_put_format(&ds, "downdelay: %d ms\n", port->downdelay);
3813
3814     if (port->bond_mode != BM_AB) {
3815         ds_put_format(&ds, "next rebalance: %lld ms\n",
3816                       port->bond_next_rebalance - time_msec());
3817     }
3818
3819     for (j = 0; j < port->n_ifaces; j++) {
3820         const struct iface *iface = port->ifaces[j];
3821         struct bond_entry *be;
3822         struct flow flow;
3823
3824         /* Basic info. */
3825         ds_put_format(&ds, "\nslave %s: %s\n",
3826                       iface->name, iface->enabled ? "enabled" : "disabled");
3827         if (j == port->active_iface) {
3828             ds_put_cstr(&ds, "\tactive slave\n");
3829         }
3830         if (iface->delay_expires != LLONG_MAX) {
3831             ds_put_format(&ds, "\t%s expires in %lld ms\n",
3832                           iface->enabled ? "downdelay" : "updelay",
3833                           iface->delay_expires - time_msec());
3834         }
3835
3836         if (port->lacp) {
3837             ds_put_cstr(&ds, "\tstatus: ");
3838
3839             if (iface->lacp_status & LACP_CURRENT) {
3840                 ds_put_cstr(&ds, "current ");
3841             }
3842
3843             if (iface->lacp_status & LACP_EXPIRED) {
3844                 ds_put_cstr(&ds, "expired ");
3845             }
3846
3847             if (iface->lacp_status & LACP_DEFAULTED) {
3848                 ds_put_cstr(&ds, "defaulted ");
3849             }
3850
3851             if (iface->lacp_status & LACP_ATTACHED) {
3852                 ds_put_cstr(&ds, "attached ");
3853             }
3854
3855             ds_put_cstr(&ds, "\n");
3856
3857             ds_put_cstr(&ds, "\n\tactor sysid: ");
3858             ds_put_format(&ds, ETH_ADDR_FMT,
3859                           ETH_ADDR_ARGS(iface->lacp_actor.sysid));
3860             ds_put_cstr(&ds, "\n");
3861
3862             ds_put_format(&ds, "\tactor sys_priority: %u\n",
3863                           ntohs(iface->lacp_actor.sys_priority));
3864
3865             ds_put_format(&ds, "\tactor portid: %u\n",
3866                           ntohs(iface->lacp_actor.portid));
3867
3868             ds_put_format(&ds, "\tactor port_priority: %u\n",
3869                           ntohs(iface->lacp_actor.port_priority));
3870
3871             ds_put_format(&ds, "\tactor key: %u\n",
3872                           ntohs(iface->lacp_actor.key));
3873
3874             ds_put_cstr(&ds, "\tactor state: ");
3875             ds_put_lacp_state(&ds, iface_get_lacp_state(iface));
3876             ds_put_cstr(&ds, "\n\n");
3877
3878             ds_put_cstr(&ds, "\tpartner sysid: ");
3879             ds_put_format(&ds, ETH_ADDR_FMT,
3880                           ETH_ADDR_ARGS(iface->lacp_partner.sysid));
3881             ds_put_cstr(&ds, "\n");
3882
3883             ds_put_format(&ds, "\tpartner sys_priority: %u\n",
3884                           ntohs(iface->lacp_partner.sys_priority));
3885
3886             ds_put_format(&ds, "\tpartner portid: %u\n",
3887                           ntohs(iface->lacp_partner.portid));
3888
3889             ds_put_format(&ds, "\tpartner port_priority: %u\n",
3890                           ntohs(iface->lacp_partner.port_priority));
3891
3892             ds_put_format(&ds, "\tpartner key: %u\n",
3893                           ntohs(iface->lacp_partner.key));
3894
3895             ds_put_cstr(&ds, "\tpartner state: ");
3896             ds_put_lacp_state(&ds, iface->lacp_partner.state);
3897             ds_put_cstr(&ds, "\n");
3898         }
3899
3900         if (port->bond_mode == BM_AB) {
3901             continue;
3902         }
3903
3904         /* Hashes. */
3905         memset(&flow, 0, sizeof flow);
3906         for (be = port->bond_hash; be <= &port->bond_hash[BOND_MASK]; be++) {
3907             int hash = be - port->bond_hash;
3908             struct mac_entry *me;
3909
3910             if (be->iface_idx != j) {
3911                 continue;
3912             }
3913
3914             ds_put_format(&ds, "\thash %d: %"PRIu64" kB load\n",
3915                           hash, be->tx_bytes / 1024);
3916
3917             if (port->bond_mode != BM_SLB) {
3918                 continue;
3919             }
3920
3921             /* MACs. */
3922             LIST_FOR_EACH (me, lru_node, &port->bridge->ml->lrus) {
3923                 uint16_t dp_ifidx;
3924                 tag_type tags = 0;
3925
3926                 memcpy(flow.dl_src, me->mac, ETH_ADDR_LEN);
3927                 if (bond_hash_src(me->mac, me->vlan) == hash
3928                     && me->port != port->port_idx
3929                     && choose_output_iface(port, &flow, me->vlan,
3930                                            &dp_ifidx, &tags)
3931                     && dp_ifidx == iface->dp_ifidx)
3932                 {
3933                     ds_put_format(&ds, "\t\t"ETH_ADDR_FMT"\n",
3934                                   ETH_ADDR_ARGS(me->mac));
3935                 }
3936             }
3937         }
3938     }
3939     unixctl_command_reply(conn, 200, ds_cstr(&ds));
3940     ds_destroy(&ds);
3941 }
3942
3943 static void
3944 bond_unixctl_migrate(struct unixctl_conn *conn, const char *args_,
3945                      void *aux OVS_UNUSED)
3946 {
3947     char *args = (char *) args_;
3948     char *save_ptr = NULL;
3949     char *bond_s, *hash_s, *slave_s;
3950     struct port *port;
3951     struct iface *iface;
3952     struct bond_entry *entry;
3953     int hash;
3954
3955     bond_s = strtok_r(args, " ", &save_ptr);
3956     hash_s = strtok_r(NULL, " ", &save_ptr);
3957     slave_s = strtok_r(NULL, " ", &save_ptr);
3958     if (!slave_s) {
3959         unixctl_command_reply(conn, 501,
3960                               "usage: bond/migrate BOND HASH SLAVE");
3961         return;
3962     }
3963
3964     port = bond_find(bond_s);
3965     if (!port) {
3966         unixctl_command_reply(conn, 501, "no such bond");
3967         return;
3968     }
3969
3970     if (port->bond_mode != BM_SLB) {
3971         unixctl_command_reply(conn, 501, "not an SLB bond");
3972         return;
3973     }
3974
3975     if (strspn(hash_s, "0123456789") == strlen(hash_s)) {
3976         hash = atoi(hash_s) & BOND_MASK;
3977     } else {
3978         unixctl_command_reply(conn, 501, "bad hash");
3979         return;
3980     }
3981
3982     iface = port_lookup_iface(port, slave_s);
3983     if (!iface) {
3984         unixctl_command_reply(conn, 501, "no such slave");
3985         return;
3986     }
3987
3988     if (!iface->enabled) {
3989         unixctl_command_reply(conn, 501, "cannot migrate to disabled slave");
3990         return;
3991     }
3992
3993     entry = &port->bond_hash[hash];
3994     ofproto_revalidate(port->bridge->ofproto, entry->iface_tag);
3995     entry->iface_idx = iface->port_ifidx;
3996     entry->iface_tag = tag_create_random();
3997     unixctl_command_reply(conn, 200, "migrated");
3998 }
3999
4000 static void
4001 bond_unixctl_set_active_slave(struct unixctl_conn *conn, const char *args_,
4002                               void *aux OVS_UNUSED)
4003 {
4004     char *args = (char *) args_;
4005     char *save_ptr = NULL;
4006     char *bond_s, *slave_s;
4007     struct port *port;
4008     struct iface *iface;
4009
4010     bond_s = strtok_r(args, " ", &save_ptr);
4011     slave_s = strtok_r(NULL, " ", &save_ptr);
4012     if (!slave_s) {
4013         unixctl_command_reply(conn, 501,
4014                               "usage: bond/set-active-slave BOND SLAVE");
4015         return;
4016     }
4017
4018     port = bond_find(bond_s);
4019     if (!port) {
4020         unixctl_command_reply(conn, 501, "no such bond");
4021         return;
4022     }
4023
4024     iface = port_lookup_iface(port, slave_s);
4025     if (!iface) {
4026         unixctl_command_reply(conn, 501, "no such slave");
4027         return;
4028     }
4029
4030     if (!iface->enabled) {
4031         unixctl_command_reply(conn, 501, "cannot make disabled slave active");
4032         return;
4033     }
4034
4035     if (port->active_iface != iface->port_ifidx) {
4036         ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
4037         port->active_iface = iface->port_ifidx;
4038         port->active_iface_tag = tag_create_random();
4039         VLOG_INFO("port %s: active interface is now %s",
4040                   port->name, iface->name);
4041         bond_send_learning_packets(port);
4042         unixctl_command_reply(conn, 200, "done");
4043     } else {
4044         unixctl_command_reply(conn, 200, "no change");
4045     }
4046 }
4047
4048 static void
4049 enable_slave(struct unixctl_conn *conn, const char *args_, bool enable)
4050 {
4051     char *args = (char *) args_;
4052     char *save_ptr = NULL;
4053     char *bond_s, *slave_s;
4054     struct port *port;
4055     struct iface *iface;
4056
4057     bond_s = strtok_r(args, " ", &save_ptr);
4058     slave_s = strtok_r(NULL, " ", &save_ptr);
4059     if (!slave_s) {
4060         unixctl_command_reply(conn, 501,
4061                               "usage: bond/enable/disable-slave BOND SLAVE");
4062         return;
4063     }
4064
4065     port = bond_find(bond_s);
4066     if (!port) {
4067         unixctl_command_reply(conn, 501, "no such bond");
4068         return;
4069     }
4070
4071     iface = port_lookup_iface(port, slave_s);
4072     if (!iface) {
4073         unixctl_command_reply(conn, 501, "no such slave");
4074         return;
4075     }
4076
4077     bond_enable_slave(iface, enable);
4078     unixctl_command_reply(conn, 501, enable ? "enabled" : "disabled");
4079 }
4080
4081 static void
4082 bond_unixctl_enable_slave(struct unixctl_conn *conn, const char *args,
4083                           void *aux OVS_UNUSED)
4084 {
4085     enable_slave(conn, args, true);
4086 }
4087
4088 static void
4089 bond_unixctl_disable_slave(struct unixctl_conn *conn, const char *args,
4090                            void *aux OVS_UNUSED)
4091 {
4092     enable_slave(conn, args, false);
4093 }
4094
4095 static void
4096 bond_unixctl_hash(struct unixctl_conn *conn, const char *args_,
4097                   void *aux OVS_UNUSED)
4098 {
4099     char *args = (char *) args_;
4100     uint8_t mac[ETH_ADDR_LEN];
4101     uint8_t hash;
4102     char *hash_cstr;
4103     unsigned int vlan;
4104     char *mac_s, *vlan_s;
4105     char *save_ptr = NULL;
4106
4107     mac_s  = strtok_r(args, " ", &save_ptr);
4108     vlan_s = strtok_r(NULL, " ", &save_ptr);
4109
4110     if (vlan_s) {
4111         if (sscanf(vlan_s, "%u", &vlan) != 1) {
4112             unixctl_command_reply(conn, 501, "invalid vlan");
4113             return;
4114         }
4115     } else {
4116         vlan = OFP_VLAN_NONE;
4117     }
4118
4119     if (sscanf(mac_s, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
4120         == ETH_ADDR_SCAN_COUNT) {
4121         hash = bond_hash_src(mac, vlan);
4122
4123         hash_cstr = xasprintf("%u", hash);
4124         unixctl_command_reply(conn, 200, hash_cstr);
4125         free(hash_cstr);
4126     } else {
4127         unixctl_command_reply(conn, 501, "invalid mac");
4128     }
4129 }
4130
4131 static void
4132 bond_init(void)
4133 {
4134     unixctl_command_register("bond/list", bond_unixctl_list, NULL);
4135     unixctl_command_register("bond/show", bond_unixctl_show, NULL);
4136     unixctl_command_register("bond/migrate", bond_unixctl_migrate, NULL);
4137     unixctl_command_register("bond/set-active-slave",
4138                              bond_unixctl_set_active_slave, NULL);
4139     unixctl_command_register("bond/enable-slave", bond_unixctl_enable_slave,
4140                              NULL);
4141     unixctl_command_register("bond/disable-slave", bond_unixctl_disable_slave,
4142                              NULL);
4143     unixctl_command_register("bond/hash", bond_unixctl_hash, NULL);
4144 }
4145 \f
4146 /* Port functions. */
4147
4148 static struct port *
4149 port_create(struct bridge *br, const char *name)
4150 {
4151     struct port *port;
4152
4153     port = xzalloc(sizeof *port);
4154     port->bridge = br;
4155     port->port_idx = br->n_ports;
4156     port->vlan = -1;
4157     port->trunks = NULL;
4158     port->name = xstrdup(name);
4159     port->active_iface = -1;
4160
4161     if (br->n_ports >= br->allocated_ports) {
4162         br->ports = x2nrealloc(br->ports, &br->allocated_ports,
4163                                sizeof *br->ports);
4164     }
4165     br->ports[br->n_ports++] = port;
4166     shash_add_assert(&br->port_by_name, port->name, port);
4167
4168     VLOG_INFO("created port %s on bridge %s", port->name, br->name);
4169     bridge_flush(br);
4170
4171     return port;
4172 }
4173
4174 static const char *
4175 get_port_other_config(const struct ovsrec_port *port, const char *key,
4176                       const char *default_value)
4177 {
4178     const char *value;
4179
4180     value = get_ovsrec_key_value(&port->header_, &ovsrec_port_col_other_config,
4181                                  key);
4182     return value ? value : default_value;
4183 }
4184
4185 static const char *
4186 get_interface_other_config(const struct ovsrec_interface *iface,
4187                            const char *key, const char *default_value)
4188 {
4189     const char *value;
4190
4191     value = get_ovsrec_key_value(&iface->header_,
4192                                  &ovsrec_interface_col_other_config, key);
4193     return value ? value : default_value;
4194 }
4195
4196 static void
4197 port_del_ifaces(struct port *port, const struct ovsrec_port *cfg)
4198 {
4199     struct shash new_ifaces;
4200     size_t i;
4201
4202     /* Collect list of new interfaces. */
4203     shash_init(&new_ifaces);
4204     for (i = 0; i < cfg->n_interfaces; i++) {
4205         const char *name = cfg->interfaces[i]->name;
4206         shash_add_once(&new_ifaces, name, NULL);
4207     }
4208
4209     /* Get rid of deleted interfaces. */
4210     for (i = 0; i < port->n_ifaces; ) {
4211         if (!shash_find(&new_ifaces, cfg->interfaces[i]->name)) {
4212             iface_destroy(port->ifaces[i]);
4213         } else {
4214             i++;
4215         }
4216     }
4217
4218     shash_destroy(&new_ifaces);
4219 }
4220
4221 static void
4222 port_reconfigure(struct port *port, const struct ovsrec_port *cfg)
4223 {
4224     const char *detect_mode;
4225     struct shash new_ifaces;
4226     long long int next_rebalance, miimon_next_update, lacp_priority;
4227     unsigned long *trunks;
4228     int vlan;
4229     size_t i;
4230
4231     port->cfg = cfg;
4232
4233     /* Update settings. */
4234     port->updelay = cfg->bond_updelay;
4235     if (port->updelay < 0) {
4236         port->updelay = 0;
4237     }
4238     port->downdelay = cfg->bond_downdelay;
4239     if (port->downdelay < 0) {
4240         port->downdelay = 0;
4241     }
4242     port->bond_rebalance_interval = atoi(
4243         get_port_other_config(cfg, "bond-rebalance-interval", "10000"));
4244     if (port->bond_rebalance_interval < 1000) {
4245         port->bond_rebalance_interval = 1000;
4246     }
4247     next_rebalance = time_msec() + port->bond_rebalance_interval;
4248     if (port->bond_next_rebalance > next_rebalance) {
4249         port->bond_next_rebalance = next_rebalance;
4250     }
4251
4252     detect_mode = get_port_other_config(cfg, "bond-detect-mode",
4253                                         "carrier");
4254
4255     if (!strcmp(detect_mode, "carrier")) {
4256         port->miimon = false;
4257     } else if (!strcmp(detect_mode, "miimon")) {
4258         port->miimon = true;
4259     } else {
4260         port->miimon = false;
4261         VLOG_WARN("port %s: unsupported bond-detect-mode %s, defaulting to "
4262                   "carrier", port->name, detect_mode);
4263     }
4264
4265     port->bond_miimon_interval = atoi(
4266         get_port_other_config(cfg, "bond-miimon-interval", "200"));
4267     if (port->bond_miimon_interval < 100) {
4268         port->bond_miimon_interval = 100;
4269     }
4270     miimon_next_update = time_msec() + port->bond_miimon_interval;
4271     if (port->bond_miimon_next_update > miimon_next_update) {
4272         port->bond_miimon_next_update = miimon_next_update;
4273     }
4274
4275     if (!port->cfg->bond_mode ||
4276         !strcmp(port->cfg->bond_mode, bond_mode_to_string(BM_SLB))) {
4277         port->bond_mode = BM_SLB;
4278     } else if (!strcmp(port->cfg->bond_mode, bond_mode_to_string(BM_AB))) {
4279         port->bond_mode = BM_AB;
4280     } else if (!strcmp(port->cfg->bond_mode, bond_mode_to_string(BM_TCP))) {
4281         port->bond_mode = BM_TCP;
4282     } else {
4283         port->bond_mode = BM_SLB;
4284         VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s",
4285                   port->name, port->cfg->bond_mode,
4286                   bond_mode_to_string(port->bond_mode));
4287     }
4288
4289     /* Add new interfaces and update 'cfg' member of existing ones. */
4290     shash_init(&new_ifaces);
4291     for (i = 0; i < cfg->n_interfaces; i++) {
4292         const struct ovsrec_interface *if_cfg = cfg->interfaces[i];
4293         struct iface *iface;
4294
4295         if (!shash_add_once(&new_ifaces, if_cfg->name, NULL)) {
4296             VLOG_WARN("port %s: %s specified twice as port interface",
4297                       port->name, if_cfg->name);
4298             iface_set_ofport(if_cfg, -1);
4299             continue;
4300         }
4301
4302         iface = iface_lookup(port->bridge, if_cfg->name);
4303         if (iface) {
4304             if (iface->port != port) {
4305                 VLOG_ERR("bridge %s: %s interface is on multiple ports, "
4306                          "removing from %s",
4307                          port->bridge->name, if_cfg->name, iface->port->name);
4308                 continue;
4309             }
4310             iface->cfg = if_cfg;
4311         } else {
4312             iface = iface_create(port, if_cfg);
4313         }
4314
4315         /* Determine interface type.  The local port always has type
4316          * "internal".  Other ports take their type from the database and
4317          * default to "system" if none is specified. */
4318         iface->type = (!strcmp(if_cfg->name, port->bridge->name) ? "internal"
4319                        : if_cfg->type[0] ? if_cfg->type
4320                        : "system");
4321
4322         lacp_priority =
4323             atoi(get_interface_other_config(if_cfg, "lacp-port-priority",
4324                                             "0"));
4325
4326         if (lacp_priority <= 0 || lacp_priority > UINT16_MAX) {
4327             iface->lacp_priority = UINT16_MAX;
4328         } else {
4329             iface->lacp_priority = lacp_priority;
4330         }
4331     }
4332     shash_destroy(&new_ifaces);
4333
4334     lacp_priority =
4335         atoi(get_port_other_config(cfg, "lacp-system-priority", "0"));
4336
4337     if (lacp_priority <= 0 || lacp_priority > UINT16_MAX) {
4338         /* Prefer bondable links if unspecified. */
4339         port->lacp_priority = port->n_ifaces > 1 ? UINT16_MAX - 1 : UINT16_MAX;
4340     } else {
4341         port->lacp_priority = lacp_priority;
4342     }
4343
4344     if (!port->cfg->lacp) {
4345         /* XXX when LACP implementation has been sufficiently tested, enable by
4346          * default and make active on bonded ports. */
4347         port->lacp = 0;
4348     } else if (!strcmp(port->cfg->lacp, "off")) {
4349         port->lacp = 0;
4350     } else if (!strcmp(port->cfg->lacp, "active")) {
4351         port->lacp = LACP_ACTIVE;
4352     } else if (!strcmp(port->cfg->lacp, "passive")) {
4353         port->lacp = LACP_PASSIVE;
4354     } else {
4355         VLOG_WARN("port %s: unknown LACP mode %s",
4356                   port->name, port->cfg->lacp);
4357         port->lacp = 0;
4358     }
4359
4360     /* Get VLAN tag. */
4361     vlan = -1;
4362     if (cfg->tag) {
4363         if (port->n_ifaces < 2) {
4364             vlan = *cfg->tag;
4365             if (vlan >= 0 && vlan <= 4095) {
4366                 VLOG_DBG("port %s: assigning VLAN tag %d", port->name, vlan);
4367             } else {
4368                 vlan = -1;
4369             }
4370         } else {
4371             /* It's possible that bonded, VLAN-tagged ports make sense.  Maybe
4372              * they even work as-is.  But they have not been tested. */
4373             VLOG_WARN("port %s: VLAN tags not supported on bonded ports",
4374                       port->name);
4375         }
4376     }
4377     if (port->vlan != vlan) {
4378         port->vlan = vlan;
4379         bridge_flush(port->bridge);
4380     }
4381
4382     /* Get trunked VLANs. */
4383     trunks = NULL;
4384     if (vlan < 0 && cfg->n_trunks) {
4385         size_t n_errors;
4386
4387         trunks = bitmap_allocate(4096);
4388         n_errors = 0;
4389         for (i = 0; i < cfg->n_trunks; i++) {
4390             int trunk = cfg->trunks[i];
4391             if (trunk >= 0) {
4392                 bitmap_set1(trunks, trunk);
4393             } else {
4394                 n_errors++;
4395             }
4396         }
4397         if (n_errors) {
4398             VLOG_ERR("port %s: invalid values for %zu trunk VLANs",
4399                      port->name, cfg->n_trunks);
4400         }
4401         if (n_errors == cfg->n_trunks) {
4402             VLOG_ERR("port %s: no valid trunks, trunking all VLANs",
4403                      port->name);
4404             bitmap_free(trunks);
4405             trunks = NULL;
4406         }
4407     } else if (vlan >= 0 && cfg->n_trunks) {
4408         VLOG_ERR("port %s: ignoring trunks in favor of implicit vlan",
4409                  port->name);
4410     }
4411     if (trunks == NULL
4412         ? port->trunks != NULL
4413         : port->trunks == NULL || !bitmap_equal(trunks, port->trunks, 4096)) {
4414         bridge_flush(port->bridge);
4415     }
4416     bitmap_free(port->trunks);
4417     port->trunks = trunks;
4418 }
4419
4420 static void
4421 port_destroy(struct port *port)
4422 {
4423     if (port) {
4424         struct bridge *br = port->bridge;
4425         struct port *del;
4426         int i;
4427
4428         for (i = 0; i < MAX_MIRRORS; i++) {
4429             struct mirror *m = br->mirrors[i];
4430             if (m && m->out_port == port) {
4431                 mirror_destroy(m);
4432             }
4433         }
4434
4435         while (port->n_ifaces > 0) {
4436             iface_destroy(port->ifaces[port->n_ifaces - 1]);
4437         }
4438
4439         shash_find_and_delete_assert(&br->port_by_name, port->name);
4440
4441         del = br->ports[port->port_idx] = br->ports[--br->n_ports];
4442         del->port_idx = port->port_idx;
4443
4444         VLOG_INFO("destroyed port %s on bridge %s", port->name, br->name);
4445
4446         netdev_monitor_destroy(port->monitor);
4447         free(port->ifaces);
4448         bitmap_free(port->trunks);
4449         free(port->name);
4450         free(port);
4451         bridge_flush(br);
4452     }
4453 }
4454
4455 static struct port *
4456 port_from_dp_ifidx(const struct bridge *br, uint16_t dp_ifidx)
4457 {
4458     struct iface *iface = iface_from_dp_ifidx(br, dp_ifidx);
4459     return iface ? iface->port : NULL;
4460 }
4461
4462 static struct port *
4463 port_lookup(const struct bridge *br, const char *name)
4464 {
4465     return shash_find_data(&br->port_by_name, name);
4466 }
4467
4468 static struct iface *
4469 port_lookup_iface(const struct port *port, const char *name)
4470 {
4471     struct iface *iface = iface_lookup(port->bridge, name);
4472     return iface && iface->port == port ? iface : NULL;
4473 }
4474
4475 static void
4476 port_update_lacp(struct port *port)
4477 {
4478     size_t i;
4479     bool key_changed;
4480
4481     if (!port->lacp || port->n_ifaces < 1) {
4482         for (i = 0; i < port->n_ifaces; i++) {
4483             iface_set_lacp_defaulted(port->ifaces[i]);
4484         }
4485         return;
4486     }
4487
4488     key_changed = true;
4489     for (i = 0; i < port->n_ifaces; i++) {
4490         struct iface *iface = port->ifaces[i];
4491
4492         if (iface->dp_ifidx <= 0 || iface->dp_ifidx > UINT16_MAX) {
4493             port->lacp = 0;
4494             return;
4495         }
4496
4497         if (iface->dp_ifidx == port->lacp_key) {
4498             key_changed = false;
4499         }
4500     }
4501
4502     if (key_changed) {
4503         port->lacp_key = port->ifaces[0]->dp_ifidx;
4504     }
4505
4506     for (i = 0; i < port->n_ifaces; i++) {
4507         struct iface *iface = port->ifaces[i];
4508
4509         iface->lacp_actor.sys_priority = htons(port->lacp_priority);
4510         memcpy(&iface->lacp_actor.sysid, port->bridge->ea, ETH_ADDR_LEN);
4511
4512         iface->lacp_actor.port_priority = htons(iface->lacp_priority);
4513         iface->lacp_actor.portid = htons(iface->dp_ifidx);
4514         iface->lacp_actor.key = htons(port->lacp_key);
4515
4516         iface->lacp_tx = 0;
4517     }
4518     port->lacp_need_update = true;
4519 }
4520
4521 static void
4522 port_update_bonding(struct port *port)
4523 {
4524     if (port->monitor) {
4525         netdev_monitor_destroy(port->monitor);
4526         port->monitor = NULL;
4527     }
4528     if (port->n_ifaces < 2) {
4529         /* Not a bonded port. */
4530         free(port->bond_hash);
4531         port->bond_hash = NULL;
4532         port->bond_fake_iface = false;
4533     } else {
4534         size_t i;
4535
4536         if (port->bond_mode != BM_AB && !port->bond_hash) {
4537             port->bond_hash = xcalloc(BOND_MASK + 1, sizeof *port->bond_hash);
4538             for (i = 0; i <= BOND_MASK; i++) {
4539                 struct bond_entry *e = &port->bond_hash[i];
4540                 e->iface_idx = -1;
4541                 e->tx_bytes = 0;
4542             }
4543             port->no_ifaces_tag = tag_create_random();
4544             bond_choose_active_iface(port);
4545             port->bond_next_rebalance
4546                 = time_msec() + port->bond_rebalance_interval;
4547
4548             if (port->cfg->bond_fake_iface) {
4549                 port->bond_next_fake_iface_update = time_msec();
4550             }
4551         } else if (port->bond_mode == BM_AB) {
4552             free(port->bond_hash);
4553             port->bond_hash = NULL;
4554         }
4555         port->bond_fake_iface = port->cfg->bond_fake_iface;
4556
4557         if (!port->miimon) {
4558             port->monitor = netdev_monitor_create();
4559             for (i = 0; i < port->n_ifaces; i++) {
4560                 netdev_monitor_add(port->monitor, port->ifaces[i]->netdev);
4561             }
4562         }
4563     }
4564 }
4565 \f
4566 /* Interface functions. */
4567
4568 static void
4569 iface_set_lacp_defaulted(struct iface *iface)
4570 {
4571     memset(&iface->lacp_partner, 0, sizeof iface->lacp_partner);
4572
4573     iface->lacp_status |= LACP_DEFAULTED;
4574     iface->lacp_status &= ~(LACP_CURRENT | LACP_EXPIRED);
4575     iface->lacp_tx = 0;
4576     iface->port->lacp_need_update = true;
4577 }
4578
4579 static void
4580 iface_set_lacp_expired(struct iface *iface)
4581 {
4582     iface->lacp_status &= ~LACP_CURRENT;
4583     iface->lacp_status |= LACP_EXPIRED;
4584     iface->lacp_partner.state |= LACP_STATE_TIME;
4585     iface->lacp_partner.state &= ~LACP_STATE_SYNC;
4586
4587     iface->lacp_rx = time_msec() + LACP_FAST_TIME_RX;
4588     iface->lacp_tx = 0;
4589 }
4590
4591 static uint8_t
4592 iface_get_lacp_state(const struct iface *iface)
4593 {
4594     uint8_t state = 0;
4595
4596     if (iface->port->lacp & LACP_ACTIVE) {
4597         state |= LACP_STATE_ACT;
4598     }
4599
4600     if (iface->lacp_status & LACP_ATTACHED) {
4601         state |= LACP_STATE_SYNC;
4602     }
4603
4604     if (iface->lacp_status & LACP_DEFAULTED) {
4605         state |= LACP_STATE_DEF;
4606     }
4607
4608     if (iface->lacp_status & LACP_EXPIRED) {
4609         state |= LACP_STATE_EXP;
4610     }
4611
4612     if (iface->port->n_ifaces > 1) {
4613         state |= LACP_STATE_AGG;
4614     }
4615
4616     if (iface->enabled) {
4617         state |= LACP_STATE_COL | LACP_STATE_DIST;
4618     }
4619
4620     return state;
4621 }
4622
4623 /* Given 'iface', populates 'priority' with data representing its LACP link
4624  * priority.  If two priority objects populated by this function are compared
4625  * using memcmp, the higher priority link will be less than the lower priority
4626  * link. */
4627 static void
4628 iface_get_lacp_priority(struct iface *iface, struct lacp_info *priority)
4629 {
4630     uint16_t partner_priority, actor_priority;
4631
4632     /* Choose the lacp_info of the higher priority system by comparing their
4633      * system priorities and mac addresses. */
4634     actor_priority   = ntohs(iface->lacp_actor.sys_priority);
4635     partner_priority = ntohs(iface->lacp_partner.sys_priority);
4636     if (actor_priority < partner_priority) {
4637         *priority = iface->lacp_actor;
4638     } else if (partner_priority < actor_priority) {
4639         *priority = iface->lacp_partner;
4640     } else if (eth_addr_compare_3way(iface->lacp_actor.sysid,
4641                                      iface->lacp_partner.sysid) < 0) {
4642         *priority = iface->lacp_actor;
4643     } else {
4644         *priority = iface->lacp_partner;
4645     }
4646
4647     /* Key and state are not used in priority comparisons. */
4648     priority->key = 0;
4649     priority->state = 0;
4650 }
4651
4652 static void
4653 iface_send_packet(struct iface *iface, struct ofpbuf *packet)
4654 {
4655     struct flow flow;
4656     union ofp_action action;
4657
4658     memset(&action, 0, sizeof action);
4659     action.output.type = htons(OFPAT_OUTPUT);
4660     action.output.len  = htons(sizeof action);
4661     action.output.port = htons(odp_port_to_ofp_port(iface->dp_ifidx));
4662
4663     flow_extract(packet, 0, ODPP_NONE, &flow);
4664
4665     if (ofproto_send_packet(iface->port->bridge->ofproto, &flow, &action, 1,
4666                             packet)) {
4667         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
4668         VLOG_WARN_RL(&rl, "interface %s: Failed to send packet.", iface->name);
4669     }
4670 }
4671
4672 static struct iface *
4673 iface_create(struct port *port, const struct ovsrec_interface *if_cfg)
4674 {
4675     struct bridge *br = port->bridge;
4676     struct iface *iface;
4677     char *name = if_cfg->name;
4678
4679     iface = xzalloc(sizeof *iface);
4680     iface->port = port;
4681     iface->port_ifidx = port->n_ifaces;
4682     iface->name = xstrdup(name);
4683     iface->dp_ifidx = -1;
4684     iface->tag = tag_create_random();
4685     iface->delay_expires = LLONG_MAX;
4686     iface->netdev = NULL;
4687     iface->cfg = if_cfg;
4688     iface_set_lacp_defaulted(iface);
4689
4690     if (port->lacp & LACP_ACTIVE) {
4691         iface_set_lacp_expired(iface);
4692     }
4693
4694     shash_add_assert(&br->iface_by_name, iface->name, iface);
4695
4696     if (port->n_ifaces >= port->allocated_ifaces) {
4697         port->ifaces = x2nrealloc(port->ifaces, &port->allocated_ifaces,
4698                                   sizeof *port->ifaces);
4699     }
4700     port->ifaces[port->n_ifaces++] = iface;
4701     if (port->n_ifaces > 1) {
4702         br->has_bonded_ports = true;
4703     }
4704
4705     VLOG_DBG("attached network device %s to port %s", iface->name, port->name);
4706
4707     bridge_flush(br);
4708
4709     return iface;
4710 }
4711
4712 static void
4713 iface_destroy(struct iface *iface)
4714 {
4715     if (iface) {
4716         struct port *port = iface->port;
4717         struct bridge *br = port->bridge;
4718         bool del_active = port->active_iface == iface->port_ifidx;
4719         struct iface *del;
4720
4721         if (port->monitor) {
4722             netdev_monitor_remove(port->monitor, iface->netdev);
4723         }
4724
4725         shash_find_and_delete_assert(&br->iface_by_name, iface->name);
4726
4727         if (iface->dp_ifidx >= 0) {
4728             hmap_remove(&br->ifaces, &iface->dp_ifidx_node);
4729         }
4730
4731         del = port->ifaces[iface->port_ifidx] = port->ifaces[--port->n_ifaces];
4732         del->port_ifidx = iface->port_ifidx;
4733
4734         netdev_close(iface->netdev);
4735
4736         if (del_active) {
4737             ofproto_revalidate(port->bridge->ofproto, port->active_iface_tag);
4738             bond_choose_active_iface(port);
4739             bond_send_learning_packets(port);
4740         }
4741
4742         cfm_destroy(iface->cfm);
4743
4744         free(iface->name);
4745         free(iface);
4746
4747         bridge_flush(port->bridge);
4748     }
4749 }
4750
4751 static struct iface *
4752 iface_lookup(const struct bridge *br, const char *name)
4753 {
4754     return shash_find_data(&br->iface_by_name, name);
4755 }
4756
4757 static struct iface *
4758 iface_from_dp_ifidx(const struct bridge *br, uint16_t dp_ifidx)
4759 {
4760     struct iface *iface;
4761
4762     HMAP_FOR_EACH_IN_BUCKET (iface, dp_ifidx_node,
4763                              hash_int(dp_ifidx, 0), &br->ifaces) {
4764         if (iface->dp_ifidx == dp_ifidx) {
4765             return iface;
4766         }
4767     }
4768     return NULL;
4769 }
4770
4771 /* Set Ethernet address of 'iface', if one is specified in the configuration
4772  * file. */
4773 static void
4774 iface_set_mac(struct iface *iface)
4775 {
4776     uint8_t ea[ETH_ADDR_LEN];
4777
4778     if (iface->cfg->mac && eth_addr_from_string(iface->cfg->mac, ea)) {
4779         if (eth_addr_is_multicast(ea)) {
4780             VLOG_ERR("interface %s: cannot set MAC to multicast address",
4781                      iface->name);
4782         } else if (iface->dp_ifidx == ODPP_LOCAL) {
4783             VLOG_ERR("ignoring iface.%s.mac; use bridge.%s.mac instead",
4784                      iface->name, iface->name);
4785         } else {
4786             int error = netdev_set_etheraddr(iface->netdev, ea);
4787             if (error) {
4788                 VLOG_ERR("interface %s: setting MAC failed (%s)",
4789                          iface->name, strerror(error));
4790             }
4791         }
4792     }
4793 }
4794
4795 /* Sets the ofport column of 'if_cfg' to 'ofport'. */
4796 static void
4797 iface_set_ofport(const struct ovsrec_interface *if_cfg, int64_t ofport)
4798 {
4799     if (if_cfg) {
4800         ovsrec_interface_set_ofport(if_cfg, &ofport, 1);
4801     }
4802 }
4803
4804 /* Adds the 'n' key-value pairs in 'keys' in 'values' to 'shash'.
4805  *
4806  * The value strings in '*shash' are taken directly from values[], not copied,
4807  * so the caller should not modify or free them. */
4808 static void
4809 shash_from_ovs_idl_map(char **keys, char **values, size_t n,
4810                        struct shash *shash)
4811 {
4812     size_t i;
4813
4814     shash_init(shash);
4815     for (i = 0; i < n; i++) {
4816         shash_add(shash, keys[i], values[i]);
4817     }
4818 }
4819
4820 /* Creates 'keys' and 'values' arrays from 'shash'.
4821  *
4822  * Sets 'keys' and 'values' to heap allocated arrays representing the key-value
4823  * pairs in 'shash'.  The caller takes ownership of 'keys' and 'values'.  They
4824  * are populated with with strings taken directly from 'shash' and thus have
4825  * the same ownership of the key-value pairs in shash.
4826  */
4827 static void
4828 shash_to_ovs_idl_map(struct shash *shash,
4829                      char ***keys, char ***values, size_t *n)
4830 {
4831     size_t i, count;
4832     char **k, **v;
4833     struct shash_node *sn;
4834
4835     count = shash_count(shash);
4836
4837     k = xmalloc(count * sizeof *k);
4838     v = xmalloc(count * sizeof *v);
4839
4840     i = 0;
4841     SHASH_FOR_EACH(sn, shash) {
4842         k[i] = sn->name;
4843         v[i] = sn->data;
4844         i++;
4845     }
4846
4847     *n      = count;
4848     *keys   = k;
4849     *values = v;
4850 }
4851
4852 struct iface_delete_queues_cbdata {
4853     struct netdev *netdev;
4854     const struct ovsdb_datum *queues;
4855 };
4856
4857 static bool
4858 queue_ids_include(const struct ovsdb_datum *queues, int64_t target)
4859 {
4860     union ovsdb_atom atom;
4861
4862     atom.integer = target;
4863     return ovsdb_datum_find_key(queues, &atom, OVSDB_TYPE_INTEGER) != UINT_MAX;
4864 }
4865
4866 static void
4867 iface_delete_queues(unsigned int queue_id,
4868                     const struct shash *details OVS_UNUSED, void *cbdata_)
4869 {
4870     struct iface_delete_queues_cbdata *cbdata = cbdata_;
4871
4872     if (!queue_ids_include(cbdata->queues, queue_id)) {
4873         netdev_delete_queue(cbdata->netdev, queue_id);
4874     }
4875 }
4876
4877 static void
4878 iface_update_qos(struct iface *iface, const struct ovsrec_qos *qos)
4879 {
4880     if (!qos || qos->type[0] == '\0') {
4881         netdev_set_qos(iface->netdev, NULL, NULL);
4882     } else {
4883         struct iface_delete_queues_cbdata cbdata;
4884         struct shash details;
4885         size_t i;
4886
4887         /* Configure top-level Qos for 'iface'. */
4888         shash_from_ovs_idl_map(qos->key_other_config, qos->value_other_config,
4889                                qos->n_other_config, &details);
4890         netdev_set_qos(iface->netdev, qos->type, &details);
4891         shash_destroy(&details);
4892
4893         /* Deconfigure queues that were deleted. */
4894         cbdata.netdev = iface->netdev;
4895         cbdata.queues = ovsrec_qos_get_queues(qos, OVSDB_TYPE_INTEGER,
4896                                               OVSDB_TYPE_UUID);
4897         netdev_dump_queues(iface->netdev, iface_delete_queues, &cbdata);
4898
4899         /* Configure queues for 'iface'. */
4900         for (i = 0; i < qos->n_queues; i++) {
4901             const struct ovsrec_queue *queue = qos->value_queues[i];
4902             unsigned int queue_id = qos->key_queues[i];
4903
4904             shash_from_ovs_idl_map(queue->key_other_config,
4905                                    queue->value_other_config,
4906                                    queue->n_other_config, &details);
4907             netdev_set_queue(iface->netdev, queue_id, &details);
4908             shash_destroy(&details);
4909         }
4910     }
4911 }
4912
4913 static void
4914 iface_update_cfm(struct iface *iface)
4915 {
4916     size_t i;
4917     struct cfm *cfm;
4918     uint16_t *remote_mps;
4919     struct ovsrec_monitor *mon;
4920     uint8_t ea[ETH_ADDR_LEN], maid[CCM_MAID_LEN];
4921
4922     mon = iface->cfg->monitor;
4923
4924     if (!mon) {
4925         cfm_destroy(iface->cfm);
4926         iface->cfm = NULL;
4927         return;
4928     }
4929
4930     if (netdev_get_etheraddr(iface->netdev, ea)) {
4931         VLOG_WARN("interface %s: Failed to get ethernet address. "
4932                   "Skipping Monitor.", iface->name);
4933         return;
4934     }
4935
4936     if (!cfm_generate_maid(mon->md_name, mon->ma_name, maid)) {
4937         VLOG_WARN("interface %s: Failed to generate MAID.", iface->name);
4938         return;
4939     }
4940
4941     if (!iface->cfm) {
4942         iface->cfm = cfm_create();
4943     }
4944
4945     cfm           = iface->cfm;
4946     cfm->mpid     = mon->mpid;
4947     cfm->interval = mon->interval ? *mon->interval : 1000;
4948
4949     memcpy(cfm->eth_src, ea, sizeof cfm->eth_src);
4950     memcpy(cfm->maid, maid, sizeof cfm->maid);
4951
4952     remote_mps = xzalloc(mon->n_remote_mps * sizeof *remote_mps);
4953     for(i = 0; i < mon->n_remote_mps; i++) {
4954         remote_mps[i] = mon->remote_mps[i]->mpid;
4955     }
4956     cfm_update_remote_mps(cfm, remote_mps, mon->n_remote_mps);
4957     free(remote_mps);
4958
4959     if (!cfm_configure(iface->cfm)) {
4960         cfm_destroy(iface->cfm);
4961         iface->cfm = NULL;
4962     }
4963 }
4964 \f
4965 /* Port mirroring. */
4966
4967 static struct mirror *
4968 mirror_find_by_uuid(struct bridge *br, const struct uuid *uuid)
4969 {
4970     int i;
4971
4972     for (i = 0; i < MAX_MIRRORS; i++) {
4973         struct mirror *m = br->mirrors[i];
4974         if (m && uuid_equals(uuid, &m->uuid)) {
4975             return m;
4976         }
4977     }
4978     return NULL;
4979 }
4980
4981 static void
4982 mirror_reconfigure(struct bridge *br)
4983 {
4984     unsigned long *rspan_vlans;
4985     int i;
4986
4987     /* Get rid of deleted mirrors. */
4988     for (i = 0; i < MAX_MIRRORS; i++) {
4989         struct mirror *m = br->mirrors[i];
4990         if (m) {
4991             const struct ovsdb_datum *mc;
4992             union ovsdb_atom atom;
4993
4994             mc = ovsrec_bridge_get_mirrors(br->cfg, OVSDB_TYPE_UUID);
4995             atom.uuid = br->mirrors[i]->uuid;
4996             if (ovsdb_datum_find_key(mc, &atom, OVSDB_TYPE_UUID) == UINT_MAX) {
4997                 mirror_destroy(m);
4998             }
4999         }
5000     }
5001
5002     /* Add new mirrors and reconfigure existing ones. */
5003     for (i = 0; i < br->cfg->n_mirrors; i++) {
5004         struct ovsrec_mirror *cfg = br->cfg->mirrors[i];
5005         struct mirror *m = mirror_find_by_uuid(br, &cfg->header_.uuid);
5006         if (m) {
5007             mirror_reconfigure_one(m, cfg);
5008         } else {
5009             mirror_create(br, cfg);
5010         }
5011     }
5012
5013     /* Update port reserved status. */
5014     for (i = 0; i < br->n_ports; i++) {
5015         br->ports[i]->is_mirror_output_port = false;
5016     }
5017     for (i = 0; i < MAX_MIRRORS; i++) {
5018         struct mirror *m = br->mirrors[i];
5019         if (m && m->out_port) {
5020             m->out_port->is_mirror_output_port = true;
5021         }
5022     }
5023
5024     /* Update flooded vlans (for RSPAN). */
5025     rspan_vlans = NULL;
5026     if (br->cfg->n_flood_vlans) {
5027         rspan_vlans = bitmap_allocate(4096);
5028
5029         for (i = 0; i < br->cfg->n_flood_vlans; i++) {
5030             int64_t vlan = br->cfg->flood_vlans[i];
5031             if (vlan >= 0 && vlan < 4096) {
5032                 bitmap_set1(rspan_vlans, vlan);
5033                 VLOG_INFO("bridge %s: disabling learning on vlan %"PRId64,
5034                           br->name, vlan);
5035             } else {
5036                 VLOG_ERR("bridge %s: invalid value %"PRId64 "for flood VLAN",
5037                          br->name, vlan);
5038             }
5039         }
5040     }
5041     if (mac_learning_set_flood_vlans(br->ml, rspan_vlans)) {
5042         bridge_flush(br);
5043     }
5044 }
5045
5046 static void
5047 mirror_create(struct bridge *br, struct ovsrec_mirror *cfg)
5048 {
5049     struct mirror *m;
5050     size_t i;
5051
5052     for (i = 0; ; i++) {
5053         if (i >= MAX_MIRRORS) {
5054             VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
5055                       "cannot create %s", br->name, MAX_MIRRORS, cfg->name);
5056             return;
5057         }
5058         if (!br->mirrors[i]) {
5059             break;
5060         }
5061     }
5062
5063     VLOG_INFO("created port mirror %s on bridge %s", cfg->name, br->name);
5064     bridge_flush(br);
5065
5066     br->mirrors[i] = m = xzalloc(sizeof *m);
5067     m->bridge = br;
5068     m->idx = i;
5069     m->name = xstrdup(cfg->name);
5070     shash_init(&m->src_ports);
5071     shash_init(&m->dst_ports);
5072     m->vlans = NULL;
5073     m->n_vlans = 0;
5074     m->out_vlan = -1;
5075     m->out_port = NULL;
5076
5077     mirror_reconfigure_one(m, cfg);
5078 }
5079
5080 static void
5081 mirror_destroy(struct mirror *m)
5082 {
5083     if (m) {
5084         struct bridge *br = m->bridge;
5085         size_t i;
5086
5087         for (i = 0; i < br->n_ports; i++) {
5088             br->ports[i]->src_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
5089             br->ports[i]->dst_mirrors &= ~(MIRROR_MASK_C(1) << m->idx);
5090         }
5091
5092         shash_destroy(&m->src_ports);
5093         shash_destroy(&m->dst_ports);
5094         free(m->vlans);
5095
5096         m->bridge->mirrors[m->idx] = NULL;
5097         free(m->name);
5098         free(m);
5099
5100         bridge_flush(br);
5101     }
5102 }
5103
5104 static void
5105 mirror_collect_ports(struct mirror *m, struct ovsrec_port **ports, int n_ports,
5106                      struct shash *names)
5107 {
5108     size_t i;
5109
5110     for (i = 0; i < n_ports; i++) {
5111         const char *name = ports[i]->name;
5112         if (port_lookup(m->bridge, name)) {
5113             shash_add_once(names, name, NULL);
5114         } else {
5115             VLOG_WARN("bridge %s: mirror %s cannot match on nonexistent "
5116                       "port %s", m->bridge->name, m->name, name);
5117         }
5118     }
5119 }
5120
5121 static size_t
5122 mirror_collect_vlans(struct mirror *m, const struct ovsrec_mirror *cfg,
5123                      int **vlans)
5124 {
5125     size_t n_vlans;
5126     size_t i;
5127
5128     *vlans = xmalloc(sizeof **vlans * cfg->n_select_vlan);
5129     n_vlans = 0;
5130     for (i = 0; i < cfg->n_select_vlan; i++) {
5131         int64_t vlan = cfg->select_vlan[i];
5132         if (vlan < 0 || vlan > 4095) {
5133             VLOG_WARN("bridge %s: mirror %s selects invalid VLAN %"PRId64,
5134                       m->bridge->name, m->name, vlan);
5135         } else {
5136             (*vlans)[n_vlans++] = vlan;
5137         }
5138     }
5139     return n_vlans;
5140 }
5141
5142 static bool
5143 vlan_is_mirrored(const struct mirror *m, int vlan)
5144 {
5145     size_t i;
5146
5147     for (i = 0; i < m->n_vlans; i++) {
5148         if (m->vlans[i] == vlan) {
5149             return true;
5150         }
5151     }
5152     return false;
5153 }
5154
5155 static bool
5156 port_trunks_any_mirrored_vlan(const struct mirror *m, const struct port *p)
5157 {
5158     size_t i;
5159
5160     for (i = 0; i < m->n_vlans; i++) {
5161         if (port_trunks_vlan(p, m->vlans[i])) {
5162             return true;
5163         }
5164     }
5165     return false;
5166 }
5167
5168 static void
5169 mirror_reconfigure_one(struct mirror *m, struct ovsrec_mirror *cfg)
5170 {
5171     struct shash src_ports, dst_ports;
5172     mirror_mask_t mirror_bit;
5173     struct port *out_port;
5174     int out_vlan;
5175     size_t n_vlans;
5176     int *vlans;
5177     size_t i;
5178
5179     /* Set name. */
5180     if (strcmp(cfg->name, m->name)) {
5181         free(m->name);
5182         m->name = xstrdup(cfg->name);
5183     }
5184
5185     /* Get output port. */
5186     if (cfg->output_port) {
5187         out_port = port_lookup(m->bridge, cfg->output_port->name);
5188         if (!out_port) {
5189             VLOG_ERR("bridge %s: mirror %s outputs to port not on bridge",
5190                      m->bridge->name, m->name);
5191             mirror_destroy(m);
5192             return;
5193         }
5194         out_vlan = -1;
5195
5196         if (cfg->output_vlan) {
5197             VLOG_ERR("bridge %s: mirror %s specifies both output port and "
5198                      "output vlan; ignoring output vlan",
5199                      m->bridge->name, m->name);
5200         }
5201     } else if (cfg->output_vlan) {
5202         out_port = NULL;
5203         out_vlan = *cfg->output_vlan;
5204     } else {
5205         VLOG_ERR("bridge %s: mirror %s does not specify output; ignoring",
5206                  m->bridge->name, m->name);
5207         mirror_destroy(m);
5208         return;
5209     }
5210
5211     shash_init(&src_ports);
5212     shash_init(&dst_ports);
5213     if (cfg->select_all) {
5214         for (i = 0; i < m->bridge->n_ports; i++) {
5215             const char *name = m->bridge->ports[i]->name;
5216             shash_add_once(&src_ports, name, NULL);
5217             shash_add_once(&dst_ports, name, NULL);
5218         }
5219         vlans = NULL;
5220         n_vlans = 0;
5221     } else {
5222         /* Get ports, and drop duplicates and ports that don't exist. */
5223         mirror_collect_ports(m, cfg->select_src_port, cfg->n_select_src_port,
5224                              &src_ports);
5225         mirror_collect_ports(m, cfg->select_dst_port, cfg->n_select_dst_port,
5226                              &dst_ports);
5227
5228         /* Get all the vlans, and drop duplicate and invalid vlans. */
5229         n_vlans = mirror_collect_vlans(m, cfg, &vlans);
5230     }
5231
5232     /* Update mirror data. */
5233     if (!shash_equal_keys(&m->src_ports, &src_ports)
5234         || !shash_equal_keys(&m->dst_ports, &dst_ports)
5235         || m->n_vlans != n_vlans
5236         || memcmp(m->vlans, vlans, sizeof *vlans * n_vlans)
5237         || m->out_port != out_port
5238         || m->out_vlan != out_vlan) {
5239         bridge_flush(m->bridge);
5240     }
5241     shash_swap(&m->src_ports, &src_ports);
5242     shash_swap(&m->dst_ports, &dst_ports);
5243     free(m->vlans);
5244     m->vlans = vlans;
5245     m->n_vlans = n_vlans;
5246     m->out_port = out_port;
5247     m->out_vlan = out_vlan;
5248
5249     /* Update ports. */
5250     mirror_bit = MIRROR_MASK_C(1) << m->idx;
5251     for (i = 0; i < m->bridge->n_ports; i++) {
5252         struct port *port = m->bridge->ports[i];
5253
5254         if (shash_find(&m->src_ports, port->name)
5255             || (m->n_vlans
5256                 && (!port->vlan
5257                     ? port_trunks_any_mirrored_vlan(m, port)
5258                     : vlan_is_mirrored(m, port->vlan)))) {
5259             port->src_mirrors |= mirror_bit;
5260         } else {
5261             port->src_mirrors &= ~mirror_bit;
5262         }
5263
5264         if (shash_find(&m->dst_ports, port->name)) {
5265             port->dst_mirrors |= mirror_bit;
5266         } else {
5267             port->dst_mirrors &= ~mirror_bit;
5268         }
5269     }
5270
5271     /* Clean up. */
5272     shash_destroy(&src_ports);
5273     shash_destroy(&dst_ports);
5274 }