unixctl: New JSON RPC back-end.
[openvswitch] / lib / lacp.c
1 /* Copyright (c) 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 "lacp.h"
18
19 #include <assert.h>
20 #include <stdlib.h>
21
22 #include "dynamic-string.h"
23 #include "hash.h"
24 #include "hmap.h"
25 #include "ofpbuf.h"
26 #include "packets.h"
27 #include "poll-loop.h"
28 #include "shash.h"
29 #include "timer.h"
30 #include "timeval.h"
31 #include "unixctl.h"
32 #include "vlog.h"
33
34 VLOG_DEFINE_THIS_MODULE(lacp);
35
36 /* Masks for lacp_info state member. */
37 #define LACP_STATE_ACT  0x01 /* Activity. Active or passive? */
38 #define LACP_STATE_TIME 0x02 /* Timeout. Short or long timeout? */
39 #define LACP_STATE_AGG  0x04 /* Aggregation. Is the link is bondable? */
40 #define LACP_STATE_SYNC 0x08 /* Synchronization. Is the link in up to date? */
41 #define LACP_STATE_COL  0x10 /* Collecting. Is the link receiving frames? */
42 #define LACP_STATE_DIST 0x20 /* Distributing. Is the link sending frames? */
43 #define LACP_STATE_DEF  0x40 /* Defaulted. Using default partner info? */
44 #define LACP_STATE_EXP  0x80 /* Expired. Using expired partner info? */
45
46 #define LACP_FAST_TIME_TX 1000  /* Fast transmission rate. */
47 #define LACP_SLOW_TIME_TX 30000 /* Slow transmission rate. */
48 #define LACP_RX_MULTIPLIER 3    /* Multiply by TX rate to get RX rate. */
49
50 #define LACP_INFO_LEN 15
51 struct lacp_info {
52     ovs_be16 sys_priority;            /* System priority. */
53     uint8_t sys_id[ETH_ADDR_LEN];     /* System ID. */
54     ovs_be16 key;                     /* Operational key. */
55     ovs_be16 port_priority;           /* Port priority. */
56     ovs_be16 port_id;                 /* Port ID. */
57     uint8_t state;                    /* State mask.  See LACP_STATE macros. */
58 } __attribute__((packed));
59 BUILD_ASSERT_DECL(LACP_INFO_LEN == sizeof(struct lacp_info));
60
61 #define LACP_PDU_LEN 110
62 struct lacp_pdu {
63     uint8_t subtype;          /* Always 1. */
64     uint8_t version;          /* Always 1. */
65
66     uint8_t actor_type;       /* Always 1. */
67     uint8_t actor_len;        /* Always 20. */
68     struct lacp_info actor;   /* LACP actor information. */
69     uint8_t z1[3];            /* Reserved.  Always 0. */
70
71     uint8_t partner_type;     /* Always 2. */
72     uint8_t partner_len;      /* Always 20. */
73     struct lacp_info partner; /* LACP partner information. */
74     uint8_t z2[3];            /* Reserved.  Always 0. */
75
76     uint8_t collector_type;   /* Always 3. */
77     uint8_t collector_len;    /* Always 16. */
78     ovs_be16 collector_delay; /* Maximum collector delay. Set to UINT16_MAX. */
79     uint8_t z3[64];           /* Combination of several fields.  Always 0. */
80 } __attribute__((packed));
81 BUILD_ASSERT_DECL(LACP_PDU_LEN == sizeof(struct lacp_pdu));
82 \f
83 /* Implementation. */
84
85 enum slave_status {
86     LACP_CURRENT,   /* Current State.  Partner up to date. */
87     LACP_EXPIRED,   /* Expired State.  Partner out of date. */
88     LACP_DEFAULTED, /* Defaulted State.  No partner. */
89 };
90
91 struct lacp {
92     struct list node;             /* Node in all_lacps list. */
93     char *name;                   /* Name of this lacp object. */
94     uint8_t sys_id[ETH_ADDR_LEN]; /* System ID. */
95     uint16_t sys_priority;        /* System Priority. */
96     bool active;                  /* Active or Passive. */
97
98     struct hmap slaves;      /* Slaves this LACP object controls. */
99     struct slave *key_slave; /* Slave whose ID will be the aggregation key. */
100
101     enum lacp_time lacp_time;  /* Fast, Slow or Custom LACP time. */
102     long long int custom_time; /* LACP_TIME_CUSTOM transmission rate. */
103     bool negotiated;         /* True if LACP negotiations were successful. */
104     bool update;             /* True if lacp_update() needs to be called. */
105     bool heartbeat;          /* LACP heartbeat mode. */
106 };
107
108 struct slave {
109     void *aux;                    /* Handle used to identify this slave. */
110     struct hmap_node node;        /* Node in master's slaves map. */
111
112     struct lacp *lacp;            /* LACP object containing this slave. */
113     uint16_t port_id;             /* Port ID. */
114     uint16_t port_priority;       /* Port Priority. */
115     uint16_t key;                 /* Aggregation Key. 0 if default. */
116     char *name;                   /* Name of this slave. */
117
118     enum slave_status status;     /* Slave status. */
119     bool attached;                /* Attached. Traffic may flow. */
120     struct lacp_info partner;     /* Partner information. */
121     struct lacp_info ntt_actor;   /* Used to decide if we Need To Transmit. */
122     struct timer tx;              /* Next message transmission timer. */
123     struct timer rx;              /* Expected message receive timer. */
124 };
125
126 static struct list all_lacps = LIST_INITIALIZER(&all_lacps);
127
128 static void lacp_update_attached(struct lacp *);
129
130 static void slave_destroy(struct slave *);
131 static void slave_set_defaulted(struct slave *);
132 static void slave_set_expired(struct slave *);
133 static void slave_get_actor(struct slave *, struct lacp_info *actor);
134 static void slave_get_priority(struct slave *, struct lacp_info *priority);
135 static bool slave_may_tx(const struct slave *);
136 static struct slave *slave_lookup(const struct lacp *, const void *slave);
137 static bool info_tx_equal(struct lacp_info *, struct lacp_info *);
138
139 static unixctl_cb_func lacp_unixctl_show;
140
141 /* Populates 'pdu' with a LACP PDU comprised of 'actor' and 'partner'. */
142 static void
143 compose_lacp_pdu(const struct lacp_info *actor,
144                  const struct lacp_info *partner, struct lacp_pdu *pdu)
145 {
146     memset(pdu, 0, sizeof *pdu);
147
148     pdu->subtype = 1;
149     pdu->version = 1;
150
151     pdu->actor_type = 1;
152     pdu->actor_len = 20;
153     pdu->actor = *actor;
154
155     pdu->partner_type = 2;
156     pdu->partner_len = 20;
157     pdu->partner = *partner;
158
159     pdu->collector_type = 3;
160     pdu->collector_len = 16;
161     pdu->collector_delay = htons(0);
162 }
163
164 /* Parses 'b' which represents a packet containing a LACP PDU.  This function
165  * returns NULL if 'b' is malformed, or does not represent a LACP PDU format
166  * supported by OVS.  Otherwise, it returns a pointer to the lacp_pdu contained
167  * within 'b'. */
168 static const struct lacp_pdu *
169 parse_lacp_packet(const struct ofpbuf *b)
170 {
171     const struct lacp_pdu *pdu;
172
173     pdu = ofpbuf_at(b, (uint8_t *)b->l3 - (uint8_t *)b->data, LACP_PDU_LEN);
174
175     if (pdu && pdu->subtype == 1
176         && pdu->actor_type == 1 && pdu->actor_len == 20
177         && pdu->partner_type == 2 && pdu->partner_len == 20) {
178         return pdu;
179     } else {
180         return NULL;
181     }
182 }
183 \f
184 /* LACP Protocol Implementation. */
185
186 /* Initializes the lacp module. */
187 void
188 lacp_init(void)
189 {
190     unixctl_command_register("lacp/show", "[port]", 0, 1,
191                              lacp_unixctl_show, NULL);
192 }
193
194 /* Creates a LACP object. */
195 struct lacp *
196 lacp_create(void)
197 {
198     struct lacp *lacp;
199
200     lacp = xzalloc(sizeof *lacp);
201     hmap_init(&lacp->slaves);
202     list_push_back(&all_lacps, &lacp->node);
203     return lacp;
204 }
205
206 /* Destroys 'lacp' and its slaves. Does nothing if 'lacp' is NULL. */
207 void
208 lacp_destroy(struct lacp *lacp)
209 {
210     if (lacp) {
211         struct slave *slave, *next;
212
213         HMAP_FOR_EACH_SAFE (slave, next, node, &lacp->slaves) {
214             slave_destroy(slave);
215         }
216
217         hmap_destroy(&lacp->slaves);
218         list_remove(&lacp->node);
219         free(lacp->name);
220         free(lacp);
221     }
222 }
223
224 /* Configures 'lacp' with settings from 's'. */
225 void
226 lacp_configure(struct lacp *lacp, const struct lacp_settings *s)
227 {
228     assert(!eth_addr_is_zero(s->id));
229
230     if (!lacp->name || strcmp(s->name, lacp->name)) {
231         free(lacp->name);
232         lacp->name = xstrdup(s->name);
233     }
234
235     if (!eth_addr_equals(lacp->sys_id, s->id)
236         || lacp->sys_priority != s->priority
237         || lacp->heartbeat != s->heartbeat) {
238         memcpy(lacp->sys_id, s->id, ETH_ADDR_LEN);
239         lacp->sys_priority = s->priority;
240         lacp->heartbeat = s->heartbeat;
241         lacp->update = true;
242     }
243
244     lacp->active = s->active;
245     lacp->lacp_time = s->lacp_time;
246     lacp->custom_time = (s->lacp_time == LACP_TIME_CUSTOM
247                          ? MAX(TIME_UPDATE_INTERVAL, s->custom_time)
248                          : 0);
249 }
250
251 /* Returns true if 'lacp' is configured in active mode, false if 'lacp' is
252  * configured for passive mode. */
253 bool
254 lacp_is_active(const struct lacp *lacp)
255 {
256     return lacp->active;
257 }
258
259 /* Processes 'packet' which was received on 'slave_'.  This function should be
260  * called on all packets received on 'slave_' with Ethernet Type ETH_TYPE_LACP.
261  */
262 void
263 lacp_process_packet(struct lacp *lacp, const void *slave_,
264                     const struct ofpbuf *packet)
265 {
266     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
267     struct slave *slave = slave_lookup(lacp, slave_);
268     const struct lacp_pdu *pdu;
269     long long int tx_rate;
270
271     pdu = parse_lacp_packet(packet);
272     if (!pdu) {
273         VLOG_WARN_RL(&rl, "%s: received an unparsable LACP PDU.", lacp->name);
274         return;
275     }
276
277     switch (lacp->lacp_time) {
278     case LACP_TIME_FAST:
279         tx_rate = LACP_FAST_TIME_TX;
280         break;
281     case LACP_TIME_SLOW:
282         tx_rate = LACP_SLOW_TIME_TX;
283         break;
284     case LACP_TIME_CUSTOM:
285         tx_rate = lacp->custom_time;
286         break;
287     default: NOT_REACHED();
288     }
289
290     slave->status = LACP_CURRENT;
291     timer_set_duration(&slave->rx, LACP_RX_MULTIPLIER * tx_rate);
292
293     slave->ntt_actor = pdu->partner;
294
295     /* Update our information about our partner if it's out of date.  This may
296      * cause priorities to change so re-calculate attached status of all
297      * slaves.  */
298     if (memcmp(&slave->partner, &pdu->actor, sizeof pdu->actor)) {
299         lacp->update = true;
300         slave->partner = pdu->actor;
301     }
302 }
303
304 /* Returns the lacp_status of the given 'lacp' object (which may be NULL). */
305 enum lacp_status
306 lacp_status(const struct lacp *lacp)
307 {
308     if (!lacp) {
309         return LACP_DISABLED;
310     } else if (lacp->negotiated) {
311         return LACP_NEGOTIATED;
312     } else {
313         return LACP_CONFIGURED;
314     }
315 }
316
317 /* Registers 'slave_' as subordinate to 'lacp'.  This should be called at least
318  * once per slave in a LACP managed bond.  Should also be called whenever a
319  * slave's settings change. */
320 void
321 lacp_slave_register(struct lacp *lacp, void *slave_,
322                     const struct lacp_slave_settings *s)
323 {
324     struct slave *slave = slave_lookup(lacp, slave_);
325
326     if (!slave) {
327         slave = xzalloc(sizeof *slave);
328         slave->lacp = lacp;
329         slave->aux = slave_;
330         hmap_insert(&lacp->slaves, &slave->node, hash_pointer(slave_, 0));
331         slave_set_defaulted(slave);
332
333         if (!lacp->key_slave) {
334             lacp->key_slave = slave;
335         }
336     }
337
338     if (!slave->name || strcmp(s->name, slave->name)) {
339         free(slave->name);
340         slave->name = xstrdup(s->name);
341     }
342
343     if (slave->port_id != s->id
344         || slave->port_priority != s->priority
345         || slave->key != s->key) {
346         slave->port_id = s->id;
347         slave->port_priority = s->priority;
348         slave->key = s->key;
349
350         lacp->update = true;
351
352         if (lacp->active || lacp->negotiated) {
353             slave_set_expired(slave);
354         }
355     }
356 }
357
358 /* Unregisters 'slave_' with 'lacp'.  */
359 void
360 lacp_slave_unregister(struct lacp *lacp, const void *slave_)
361 {
362     struct slave *slave = slave_lookup(lacp, slave_);
363
364     if (slave) {
365         slave_destroy(slave);
366         lacp->update = true;
367     }
368 }
369
370 /* This function should be called whenever the carrier status of 'slave_' has
371  * changed. */
372 void
373 lacp_slave_carrier_changed(const struct lacp *lacp, const void *slave_)
374 {
375     struct slave *slave = slave_lookup(lacp, slave_);
376
377     if (slave->status == LACP_CURRENT || slave->lacp->active) {
378         slave_set_expired(slave);
379     }
380 }
381
382 /* This function should be called before enabling 'slave_' to send or receive
383  * traffic.  If it returns false, 'slave_' should not enabled.  As a
384  * convenience, returns true if 'lacp' is NULL. */
385 bool
386 lacp_slave_may_enable(const struct lacp *lacp, const void *slave_)
387 {
388     if (lacp) {
389         struct slave *slave = slave_lookup(lacp, slave_);
390
391         /* The slave may be enabled if it's attached to an aggregator and its
392          * partner is synchronized.*/
393         return slave->attached && (slave->partner.state & LACP_STATE_SYNC);
394     } else {
395         return true;
396     }
397 }
398
399 /* Returns the port ID used for 'slave_' in LACP communications. */
400 uint16_t
401 lacp_slave_get_port_id(const struct lacp *lacp, const void *slave_)
402 {
403     struct slave *slave = slave_lookup(lacp, slave_);
404     return slave->port_id;
405 }
406
407 /* Returns true if partner information on 'slave_' is up to date.  'slave_'
408  * not being current, generally indicates a connectivity problem, or a
409  * misconfigured (or broken) partner. */
410 bool
411 lacp_slave_is_current(const struct lacp *lacp, const void *slave_)
412 {
413     return slave_lookup(lacp, slave_)->status != LACP_DEFAULTED;
414 }
415
416 /* This function should be called periodically to update 'lacp'. */
417 void
418 lacp_run(struct lacp *lacp, lacp_send_pdu *send_pdu)
419 {
420     struct slave *slave;
421
422     HMAP_FOR_EACH (slave, node, &lacp->slaves) {
423         if (timer_expired(&slave->rx)) {
424             if (slave->status == LACP_CURRENT) {
425                 slave_set_expired(slave);
426             } else if (slave->status == LACP_EXPIRED) {
427                 slave_set_defaulted(slave);
428             }
429         }
430     }
431
432     if (lacp->update) {
433         lacp_update_attached(lacp);
434     }
435
436     HMAP_FOR_EACH (slave, node, &lacp->slaves) {
437         struct lacp_info actor;
438
439         if (!slave_may_tx(slave)) {
440             continue;
441         }
442
443         slave_get_actor(slave, &actor);
444
445         if (timer_expired(&slave->tx)
446             || !info_tx_equal(&actor, &slave->ntt_actor)) {
447             long long int duration;
448             struct lacp_pdu pdu;
449
450             slave->ntt_actor = actor;
451             compose_lacp_pdu(&actor, &slave->partner, &pdu);
452             send_pdu(slave->aux, &pdu, sizeof pdu);
453
454             if (lacp->lacp_time == LACP_TIME_CUSTOM) {
455                 duration = lacp->custom_time;
456             } else {
457                 duration = (slave->partner.state & LACP_STATE_TIME
458                             ? LACP_FAST_TIME_TX
459                             : LACP_SLOW_TIME_TX);
460             }
461
462             timer_set_duration(&slave->tx, duration);
463         }
464     }
465 }
466
467 /* Causes poll_block() to wake up when lacp_run() needs to be called again. */
468 void
469 lacp_wait(struct lacp *lacp)
470 {
471     struct slave *slave;
472
473     HMAP_FOR_EACH (slave, node, &lacp->slaves) {
474         if (slave_may_tx(slave)) {
475             timer_wait(&slave->tx);
476         }
477
478         if (slave->status != LACP_DEFAULTED) {
479             timer_wait(&slave->rx);
480         }
481     }
482 }
483 \f
484 /* Static Helpers. */
485
486 /* Updates the attached status of all slaves controlled by 'lacp' and sets its
487  * negotiated parameter to true if any slaves are attachable. */
488 static void
489 lacp_update_attached(struct lacp *lacp)
490 {
491     struct slave *lead, *slave;
492     struct lacp_info lead_pri;
493     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
494
495     if (lacp->heartbeat) {
496         HMAP_FOR_EACH (slave, node, &lacp->slaves) {
497             slave->attached = slave->status != LACP_DEFAULTED;
498         }
499         return;
500     }
501
502     lacp->update = false;
503
504     lead = NULL;
505     HMAP_FOR_EACH (slave, node, &lacp->slaves) {
506         struct lacp_info pri;
507
508         slave->attached = false;
509
510         /* XXX: In the future allow users to configure the expected system ID.
511          * For now just special case loopback. */
512         if (eth_addr_equals(slave->partner.sys_id, slave->lacp->sys_id)) {
513             VLOG_WARN_RL(&rl, "slave %s: Loopback detected. Slave is "
514                          "connected to its own bond", slave->name);
515             continue;
516         }
517
518         if (slave->status == LACP_DEFAULTED) {
519             continue;
520         }
521
522         slave->attached = true;
523         slave_get_priority(slave, &pri);
524
525         if (!lead || memcmp(&pri, &lead_pri, sizeof pri) < 0) {
526             lead = slave;
527             lead_pri = pri;
528         }
529     }
530
531     lacp->negotiated = lead != NULL;
532
533     if (lead) {
534         HMAP_FOR_EACH (slave, node, &lacp->slaves) {
535             if (lead->partner.key != slave->partner.key
536                 || !eth_addr_equals(lead->partner.sys_id,
537                                     slave->partner.sys_id)) {
538                 slave->attached = false;
539             }
540         }
541     }
542 }
543
544 static void
545 slave_destroy(struct slave *slave)
546 {
547     if (slave) {
548         struct lacp *lacp = slave->lacp;
549
550         lacp->update = true;
551         hmap_remove(&lacp->slaves, &slave->node);
552
553         if (lacp->key_slave == slave) {
554             struct hmap_node *slave_node = hmap_first(&lacp->slaves);
555
556             if (slave_node) {
557                 lacp->key_slave = CONTAINER_OF(slave_node, struct slave, node);
558             } else {
559                 lacp->key_slave = NULL;
560             }
561         }
562
563         free(slave->name);
564         free(slave);
565     }
566 }
567
568 static void
569 slave_set_defaulted(struct slave *slave)
570 {
571     memset(&slave->partner, 0, sizeof slave->partner);
572
573     slave->lacp->update = true;
574     slave->status = LACP_DEFAULTED;
575 }
576
577 static void
578 slave_set_expired(struct slave *slave)
579 {
580     struct lacp *lacp = slave->lacp;
581
582     slave->status = LACP_EXPIRED;
583     slave->partner.state |= LACP_STATE_TIME;
584     slave->partner.state &= ~LACP_STATE_SYNC;
585
586     /* The spec says we should wait LACP_RX_MULTIPLIER * LACP_FAST_TIME_TX.
587      * This doesn't make sense when using custom times which can be much
588      * smaller than LACP_FAST_TIME. */
589     timer_set_duration(&slave->rx, (lacp->lacp_time == LACP_TIME_CUSTOM
590                                     ? lacp->custom_time
591                                     : LACP_RX_MULTIPLIER * LACP_FAST_TIME_TX));
592 }
593
594 static void
595 slave_get_actor(struct slave *slave, struct lacp_info *actor)
596 {
597     struct lacp *lacp = slave->lacp;
598     uint16_t key;
599     uint8_t state = 0;
600
601     if (lacp->active) {
602         state |= LACP_STATE_ACT;
603     }
604
605     if (lacp->lacp_time != LACP_TIME_SLOW) {
606         state |= LACP_STATE_TIME;
607     }
608
609     if (slave->attached) {
610         state |= LACP_STATE_SYNC;
611     }
612
613     if (slave->status == LACP_DEFAULTED) {
614         state |= LACP_STATE_DEF;
615     }
616
617     if (slave->status == LACP_EXPIRED) {
618         state |= LACP_STATE_EXP;
619     }
620
621     if (lacp->heartbeat || hmap_count(&lacp->slaves) > 1) {
622         state |= LACP_STATE_AGG;
623     }
624
625     if (slave->attached || !lacp->negotiated) {
626         state |= LACP_STATE_COL | LACP_STATE_DIST;
627     }
628
629     key = lacp->key_slave->key;
630     if (!key) {
631         key = lacp->key_slave->port_id;
632     }
633
634     actor->state = state;
635     actor->key = htons(key);
636     actor->port_priority = htons(slave->port_priority);
637     actor->port_id = htons(slave->port_id);
638     actor->sys_priority = htons(lacp->sys_priority);
639     memcpy(&actor->sys_id, lacp->sys_id, ETH_ADDR_LEN);
640 }
641
642 /* Given 'slave', populates 'priority' with data representing its LACP link
643  * priority.  If two priority objects populated by this function are compared
644  * using memcmp, the higher priority link will be less than the lower priority
645  * link. */
646 static void
647 slave_get_priority(struct slave *slave, struct lacp_info *priority)
648 {
649     uint16_t partner_priority, actor_priority;
650
651     /* Choose the lacp_info of the higher priority system by comparing their
652      * system priorities and mac addresses. */
653     actor_priority = slave->lacp->sys_priority;
654     partner_priority = ntohs(slave->partner.sys_priority);
655     if (actor_priority < partner_priority) {
656         slave_get_actor(slave, priority);
657     } else if (partner_priority < actor_priority) {
658         *priority = slave->partner;
659     } else if (eth_addr_compare_3way(slave->lacp->sys_id,
660                                      slave->partner.sys_id) < 0) {
661         slave_get_actor(slave, priority);
662     } else {
663         *priority = slave->partner;
664     }
665
666     /* Key and state are not used in priority comparisons. */
667     priority->key = 0;
668     priority->state = 0;
669 }
670
671 static bool
672 slave_may_tx(const struct slave *slave)
673 {
674     return slave->lacp->active || slave->status != LACP_DEFAULTED;
675 }
676
677 static struct slave *
678 slave_lookup(const struct lacp *lacp, const void *slave_)
679 {
680     struct slave *slave;
681
682     HMAP_FOR_EACH_IN_BUCKET (slave, node, hash_pointer(slave_, 0),
683                              &lacp->slaves) {
684         if (slave->aux == slave_) {
685             return slave;
686         }
687     }
688
689     return NULL;
690 }
691
692 /* Two lacp_info structures are tx_equal if and only if they do not differ in
693  * ways which would require a lacp_pdu transmission. */
694 static bool
695 info_tx_equal(struct lacp_info *a, struct lacp_info *b)
696 {
697
698     /* LACP specification dictates that we transmit whenever the actor and
699      * remote_actor differ in the following fields: Port, Port Priority,
700      * System, System Priority, Aggregation Key, Activity State, Timeout State,
701      * Sync State, and Aggregation State. The state flags are most likely to
702      * change so are checked first. */
703     return !((a->state ^ b->state) & (LACP_STATE_ACT
704                                       | LACP_STATE_TIME
705                                       | LACP_STATE_SYNC
706                                       | LACP_STATE_AGG))
707         && a->port_id == b->port_id
708         && a->port_priority == b->port_priority
709         && a->key == b->key
710         && a->sys_priority == b->sys_priority
711         && eth_addr_equals(a->sys_id, b->sys_id);
712 }
713 \f
714 static struct lacp *
715 lacp_find(const char *name)
716 {
717     struct lacp *lacp;
718
719     LIST_FOR_EACH (lacp, node, &all_lacps) {
720         if (!strcmp(lacp->name, name)) {
721             return lacp;
722         }
723     }
724
725     return NULL;
726 }
727
728 static void
729 ds_put_lacp_state(struct ds *ds, uint8_t state)
730 {
731     if (state & LACP_STATE_ACT) {
732         ds_put_cstr(ds, " activity");
733     }
734
735     if (state & LACP_STATE_TIME) {
736         ds_put_cstr(ds, " timeout");
737     }
738
739     if (state & LACP_STATE_AGG) {
740         ds_put_cstr(ds, " aggregation");
741     }
742
743     if (state & LACP_STATE_SYNC) {
744         ds_put_cstr(ds, " synchronized");
745     }
746
747     if (state & LACP_STATE_COL) {
748         ds_put_cstr(ds, " collecting");
749     }
750
751     if (state & LACP_STATE_DIST) {
752         ds_put_cstr(ds, " distributing");
753     }
754
755     if (state & LACP_STATE_DEF) {
756         ds_put_cstr(ds, " defaulted");
757     }
758
759     if (state & LACP_STATE_EXP) {
760         ds_put_cstr(ds, " expired");
761     }
762 }
763
764 static void
765 lacp_print_details(struct ds *ds, struct lacp *lacp)
766 {
767     struct shash slave_shash = SHASH_INITIALIZER(&slave_shash);
768     const struct shash_node **sorted_slaves = NULL;
769
770     struct slave *slave;
771     int i;
772
773     ds_put_format(ds, "---- %s ----\n", lacp->name);
774     ds_put_format(ds, "\tstatus: %s", lacp->active ? "active" : "passive");
775     if (lacp->heartbeat) {
776         ds_put_cstr(ds, " heartbeat");
777     }
778     if (lacp->negotiated) {
779         ds_put_cstr(ds, " negotiated");
780     }
781     ds_put_cstr(ds, "\n");
782
783     ds_put_format(ds, "\tsys_id: " ETH_ADDR_FMT "\n", ETH_ADDR_ARGS(lacp->sys_id));
784     ds_put_format(ds, "\tsys_priority: %u\n", lacp->sys_priority);
785     ds_put_cstr(ds, "\taggregation key: ");
786     if (lacp->key_slave) {
787         ds_put_format(ds, "%u", lacp->key_slave->port_id);
788     } else {
789         ds_put_cstr(ds, "none");
790     }
791     ds_put_cstr(ds, "\n");
792
793     ds_put_cstr(ds, "\tlacp_time: ");
794     switch (lacp->lacp_time) {
795     case LACP_TIME_FAST:
796         ds_put_cstr(ds, "fast\n");
797         break;
798     case LACP_TIME_SLOW:
799         ds_put_cstr(ds, "slow\n");
800         break;
801     case LACP_TIME_CUSTOM:
802         ds_put_format(ds, "custom (%lld)\n", lacp->custom_time);
803         break;
804     default:
805         ds_put_cstr(ds, "unknown\n");
806     }
807
808     HMAP_FOR_EACH (slave, node, &lacp->slaves) {
809         shash_add(&slave_shash, slave->name, slave);
810     }
811     sorted_slaves = shash_sort(&slave_shash);
812
813     for (i = 0; i < shash_count(&slave_shash); i++) {
814         char *status;
815         struct lacp_info actor;
816
817         slave = sorted_slaves[i]->data;
818         slave_get_actor(slave, &actor);
819         switch (slave->status) {
820         case LACP_CURRENT:
821             status = "current";
822             break;
823         case LACP_EXPIRED:
824             status = "expired";
825             break;
826         case LACP_DEFAULTED:
827             status = "defaulted";
828             break;
829         default:
830             NOT_REACHED();
831         }
832
833         ds_put_format(ds, "\nslave: %s: %s %s\n", slave->name, status,
834                       slave->attached ? "attached" : "detached");
835         ds_put_format(ds, "\tport_id: %u\n", slave->port_id);
836         ds_put_format(ds, "\tport_priority: %u\n", slave->port_priority);
837
838         ds_put_format(ds, "\n\tactor sys_id: " ETH_ADDR_FMT "\n",
839                       ETH_ADDR_ARGS(actor.sys_id));
840         ds_put_format(ds, "\tactor sys_priority: %u\n",
841                       ntohs(actor.sys_priority));
842         ds_put_format(ds, "\tactor port_id: %u\n",
843                       ntohs(actor.port_id));
844         ds_put_format(ds, "\tactor port_priority: %u\n",
845                       ntohs(actor.port_priority));
846         ds_put_format(ds, "\tactor key: %u\n",
847                       ntohs(actor.key));
848         ds_put_cstr(ds, "\tactor state:");
849         ds_put_lacp_state(ds, actor.state);
850         ds_put_cstr(ds, "\n\n");
851
852         ds_put_format(ds, "\tpartner sys_id: " ETH_ADDR_FMT "\n",
853                       ETH_ADDR_ARGS(slave->partner.sys_id));
854         ds_put_format(ds, "\tpartner sys_priority: %u\n",
855                       ntohs(slave->partner.sys_priority));
856         ds_put_format(ds, "\tpartner port_id: %u\n",
857                       ntohs(slave->partner.port_id));
858         ds_put_format(ds, "\tpartner port_priority: %u\n",
859                       ntohs(slave->partner.port_priority));
860         ds_put_format(ds, "\tpartner key: %u\n",
861                       ntohs(slave->partner.key));
862         ds_put_cstr(ds, "\tpartner state:");
863         ds_put_lacp_state(ds, slave->partner.state);
864         ds_put_cstr(ds, "\n");
865     }
866
867     shash_destroy(&slave_shash);
868     free(sorted_slaves);
869 }
870
871 static void
872 lacp_unixctl_show(struct unixctl_conn *conn, int argc, const char *argv[],
873                   void *aux OVS_UNUSED)
874 {
875     struct ds ds = DS_EMPTY_INITIALIZER;
876     struct lacp *lacp;
877
878     if (argc > 1) {
879         lacp = lacp_find(argv[1]);
880         if (!lacp) {
881             unixctl_command_reply_error(conn, "no such lacp object");
882             return;
883         }
884         lacp_print_details(&ds, lacp);
885     } else {
886         LIST_FOR_EACH (lacp, node, &all_lacps) {
887             lacp_print_details(&ds, lacp);
888         }
889     }
890
891     unixctl_command_reply(conn, ds_cstr(&ds));
892     ds_destroy(&ds);
893 }