X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Flacp.c;h=22cba9429bb9a13cc804be21a5bec870f65a9d1e;hb=2c8fcc9cd6a7bbb948f6c79879e89c7ed791c9b1;hp=7d68661150be7fbbeedf8662e5d8e6809d463c0a;hpb=6aa7430820bb327b65de0e02baf928ed663bef2b;p=openvswitch diff --git a/lib/lacp.c b/lib/lacp.c index 7d686611..22cba942 100644 --- a/lib/lacp.c +++ b/lib/lacp.c @@ -25,12 +25,62 @@ #include "ofpbuf.h" #include "packets.h" #include "poll-loop.h" +#include "timer.h" #include "timeval.h" #include "unixctl.h" #include "vlog.h" VLOG_DEFINE_THIS_MODULE(lacp); +/* Masks for lacp_info state member. */ +#define LACP_STATE_ACT 0x01 /* Activity. Active or passive? */ +#define LACP_STATE_TIME 0x02 /* Timeout. Short or long timeout? */ +#define LACP_STATE_AGG 0x04 /* Aggregation. Is the link is bondable? */ +#define LACP_STATE_SYNC 0x08 /* Synchronization. Is the link in up to date? */ +#define LACP_STATE_COL 0x10 /* Collecting. Is the link receiving frames? */ +#define LACP_STATE_DIST 0x20 /* Distributing. Is the link sending frames? */ +#define LACP_STATE_DEF 0x40 /* Defaulted. Using default partner info? */ +#define LACP_STATE_EXP 0x80 /* Expired. Using expired partner info? */ + +#define LACP_FAST_TIME_TX 1000 /* Fast transmission rate. */ +#define LACP_SLOW_TIME_TX 30000 /* Slow transmission rate. */ +#define LACP_RX_MULTIPLIER 3 /* Multiply by TX rate to get RX rate. */ + +#define LACP_INFO_LEN 15 +struct lacp_info { + ovs_be16 sys_priority; /* System priority. */ + uint8_t sys_id[ETH_ADDR_LEN]; /* System ID. */ + ovs_be16 key; /* Operational key. */ + ovs_be16 port_priority; /* Port priority. */ + ovs_be16 port_id; /* Port ID. */ + uint8_t state; /* State mask. See LACP_STATE macros. */ +} __attribute__((packed)); +BUILD_ASSERT_DECL(LACP_INFO_LEN == sizeof(struct lacp_info)); + +#define LACP_PDU_LEN 110 +struct lacp_pdu { + uint8_t subtype; /* Always 1. */ + uint8_t version; /* Always 1. */ + + uint8_t actor_type; /* Always 1. */ + uint8_t actor_len; /* Always 20. */ + struct lacp_info actor; /* LACP actor information. */ + uint8_t z1[3]; /* Reserved. Always 0. */ + + uint8_t partner_type; /* Always 2. */ + uint8_t partner_len; /* Always 20. */ + struct lacp_info partner; /* LACP partner information. */ + uint8_t z2[3]; /* Reserved. Always 0. */ + + uint8_t collector_type; /* Always 3. */ + uint8_t collector_len; /* Always 16. */ + ovs_be16 collector_delay; /* Maximum collector delay. Set to UINT16_MAX. */ + uint8_t z3[64]; /* Combination of several fields. Always 0. */ +} __attribute__((packed)); +BUILD_ASSERT_DECL(LACP_PDU_LEN == sizeof(struct lacp_pdu)); + +/* Implementation. */ + enum slave_status { LACP_CURRENT, /* Current State. Partner up to date. */ LACP_EXPIRED, /* Expired State. Partner out of date. */ @@ -47,8 +97,11 @@ struct lacp { struct hmap slaves; /* Slaves this LACP object controls. */ struct slave *key_slave; /* Slave whose ID will be the aggregation key. */ + enum lacp_time lacp_time; /* Fast, Slow or Custom LACP time. */ + long long int custom_time; /* LACP_TIME_CUSTOM transmission rate. */ bool negotiated; /* True if LACP negotiations were successful. */ bool update; /* True if lacp_update() needs to be called. */ + bool heartbeat; /* LACP heartbeat mode. */ }; struct slave { @@ -58,15 +111,15 @@ struct slave { struct lacp *lacp; /* LACP object containing this slave. */ uint16_t port_id; /* Port ID. */ uint16_t port_priority; /* Port Priority. */ + uint16_t key; /* Aggregation Key. 0 if default. */ char *name; /* Name of this slave. */ enum slave_status status; /* Slave status. */ bool attached; /* Attached. Traffic may flow. */ - bool enabled; /* Enabled. Traffic is flowing. */ - struct lacp_info actor; /* Actor information. */ struct lacp_info partner; /* Partner information. */ - long long int tx; /* Next message transmission time. */ - long long int rx; /* Expected message receive time. */ + struct lacp_info ntt_actor; /* Used to decide if we Need To Transmit. */ + struct timer tx; /* Next message transmission timer. */ + struct timer rx; /* Expected message receive timer. */ }; static struct list all_lacps = LIST_INITIALIZER(&all_lacps); @@ -76,19 +129,65 @@ static void lacp_update_attached(struct lacp *); static void slave_destroy(struct slave *); static void slave_set_defaulted(struct slave *); static void slave_set_expired(struct slave *); -static void slave_update_actor(struct slave *); +static void slave_get_actor(struct slave *, struct lacp_info *actor); static void slave_get_priority(struct slave *, struct lacp_info *priority); static bool slave_may_tx(const struct slave *); static struct slave *slave_lookup(const struct lacp *, const void *slave); +static bool info_tx_equal(struct lacp_info *, struct lacp_info *); static void lacp_unixctl_show(struct unixctl_conn *, const char *args, void *aux); +/* Populates 'pdu' with a LACP PDU comprised of 'actor' and 'partner'. */ +static void +compose_lacp_pdu(const struct lacp_info *actor, + const struct lacp_info *partner, struct lacp_pdu *pdu) +{ + memset(pdu, 0, sizeof *pdu); + + pdu->subtype = 1; + pdu->version = 1; + + pdu->actor_type = 1; + pdu->actor_len = 20; + pdu->actor = *actor; + + pdu->partner_type = 2; + pdu->partner_len = 20; + pdu->partner = *partner; + + pdu->collector_type = 3; + pdu->collector_len = 16; + pdu->collector_delay = htons(0); +} + +/* Parses 'b' which represents a packet containing a LACP PDU. This function + * returns NULL if 'b' is malformed, or does not represent a LACP PDU format + * supported by OVS. Otherwise, it returns a pointer to the lacp_pdu contained + * within 'b'. */ +static const struct lacp_pdu * +parse_lacp_packet(const struct ofpbuf *b) +{ + const struct lacp_pdu *pdu; + + pdu = ofpbuf_at(b, (uint8_t *)b->l3 - (uint8_t *)b->data, LACP_PDU_LEN); + + if (pdu && pdu->subtype == 1 + && pdu->actor_type == 1 && pdu->actor_len == 20 + && pdu->partner_type == 2 && pdu->partner_len == 20) { + return pdu; + } else { + return NULL; + } +} + +/* LACP Protocol Implementation. */ + /* Initializes the lacp module. */ void lacp_init(void) { - unixctl_command_register("lacp/show", lacp_unixctl_show, NULL); + unixctl_command_register("lacp/show", "[port]", lacp_unixctl_show, NULL); } /* Creates a LACP object. */ @@ -121,42 +220,73 @@ lacp_destroy(struct lacp *lacp) } } -/* Configures 'lacp' with the given 'name', 'sys_id', 'sys_priority', and - * 'active' parameters. */ +/* Configures 'lacp' with settings from 's'. */ void -lacp_configure(struct lacp *lacp, const char *name, - uint8_t sys_id[ETH_ADDR_LEN], uint16_t sys_priority, - bool active) +lacp_configure(struct lacp *lacp, const struct lacp_settings *s) { - if (!lacp->name || strcmp(name, lacp->name)) { + if (!lacp->name || strcmp(s->name, lacp->name)) { free(lacp->name); - lacp->name = xstrdup(name); + lacp->name = xstrdup(s->name); } - memcpy(lacp->sys_id, sys_id, ETH_ADDR_LEN); - lacp->sys_priority = sys_priority; - lacp->active = active; + if (!eth_addr_equals(lacp->sys_id, s->id) + || lacp->sys_priority != s->priority + || lacp->heartbeat != s->heartbeat) { + memcpy(lacp->sys_id, s->id, ETH_ADDR_LEN); + lacp->sys_priority = s->priority; + lacp->heartbeat = s->heartbeat; + lacp->update = true; + } + + lacp->active = s->active; + lacp->lacp_time = s->lacp_time; + lacp->custom_time = MAX(TIME_UPDATE_INTERVAL, s->custom_time); +} + +/* Returns true if 'lacp' is configured in active mode, false if 'lacp' is + * configured for passive mode. */ +bool +lacp_is_active(const struct lacp *lacp) +{ + return lacp->active; } -/* Processes 'pdu', a parsed LACP packet received on 'slave_'. This function - * should be called on all packets received on 'slave_' with Ethernet Type - * ETH_TYPE_LACP and parsable by parse_lacp_packet(). */ +/* Processes 'packet' which was received on 'slave_'. This function should be + * called on all packets received on 'slave_' with Ethernet Type ETH_TYPE_LACP. + */ void -lacp_process_pdu(struct lacp *lacp, const void *slave_, - const struct lacp_pdu *pdu) +lacp_process_packet(struct lacp *lacp, const void *slave_, + const struct ofpbuf *packet) { + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); struct slave *slave = slave_lookup(lacp, slave_); + const struct lacp_pdu *pdu; + long long int tx_rate; - slave->status = LACP_CURRENT; - slave->rx = time_msec() + LACP_SLOW_TIME_RX; + pdu = parse_lacp_packet(packet); + if (!pdu) { + VLOG_WARN_RL(&rl, "%s: received an unparsable LACP PDU.", lacp->name); + return; + } - /* Check if our partner has incorrect information about our current state. - * If so update them. */ - slave_update_actor(slave); - if (memcmp(&slave->actor, &pdu->partner, sizeof pdu->partner)) { - slave->tx = LLONG_MIN; + switch (lacp->lacp_time) { + case LACP_TIME_FAST: + tx_rate = LACP_FAST_TIME_TX; + break; + case LACP_TIME_SLOW: + tx_rate = LACP_SLOW_TIME_TX; + break; + case LACP_TIME_CUSTOM: + tx_rate = lacp->custom_time; + break; + default: NOT_REACHED(); } + slave->status = LACP_CURRENT; + timer_set_duration(&slave->rx, LACP_RX_MULTIPLIER * tx_rate); + + slave->ntt_actor = pdu->partner; + /* Update our information about our partner if it's out of date. This may * cause priorities to change so re-calculate attached status of all * slaves. */ @@ -176,10 +306,10 @@ lacp_negotiated(const struct lacp *lacp) /* Registers 'slave_' as subordinate to 'lacp'. This should be called at least * once per slave in a LACP managed bond. Should also be called whenever a - * slave's name, port_id, or port_priority change. */ + * slave's settings change. */ void -lacp_slave_register(struct lacp *lacp, void *slave_, const char *name, - uint16_t port_id, uint16_t port_priority) +lacp_slave_register(struct lacp *lacp, void *slave_, + const struct lacp_slave_settings *s) { struct slave *slave = slave_lookup(lacp, slave_); @@ -195,17 +325,18 @@ lacp_slave_register(struct lacp *lacp, void *slave_, const char *name, } } - if (!slave->name || strcmp(name, slave->name)) { + if (!slave->name || strcmp(s->name, slave->name)) { free(slave->name); - slave->name = xstrdup(name); + slave->name = xstrdup(s->name); } - if (slave->port_id != port_id || slave->port_priority != port_priority) { + if (slave->port_id != s->id + || slave->port_priority != s->priority + || slave->key != s->key) { + slave->port_id = s->id; + slave->port_priority = s->priority; + slave->key = s->key; - slave->port_id = port_id; - slave->port_priority = port_priority; - - slave->tx = LLONG_MIN; lacp->update = true; if (lacp->active || lacp->negotiated) { @@ -222,21 +353,7 @@ lacp_slave_unregister(struct lacp *lacp, const void *slave_) if (slave) { slave_destroy(slave); - } -} - -/* Should be called regularly to indicate whether 'slave_' is enabled. An - * enabled slave is allowed to send and receive traffic. Generally a slave - * should not be enabled if its carrier is down, or lacp_slave_may_enable() - * indicates it should not be enabled. */ -void -lacp_slave_enable(struct lacp *lacp, void *slave_, bool enabled) -{ - struct slave *slave = slave_lookup(lacp, slave_); - - if (slave->enabled != enabled) { - slave->enabled = enabled; - slave->tx = LLONG_MIN; + lacp->update = true; } } @@ -247,7 +364,6 @@ lacp_slave_carrier_changed(const struct lacp *lacp, const void *slave_) { struct slave *slave = slave_lookup(lacp, slave_); - slave->tx = LLONG_MIN; if (slave->status == LACP_CURRENT || slave->lacp->active) { slave_set_expired(slave); } @@ -274,6 +390,23 @@ lacp_slave_may_enable(const struct lacp *lacp, const void *slave_) } } +/* Returns the port ID used for 'slave_' in LACP communications. */ +uint16_t +lacp_slave_get_port_id(const struct lacp *lacp, const void *slave_) +{ + struct slave *slave = slave_lookup(lacp, slave_); + return slave->port_id; +} + +/* Returns true if partner information on 'slave_' is up to date. 'slave_' + * not being current, generally indicates a connectivity problem, or a + * misconfigured (or broken) partner. */ +bool +lacp_slave_is_current(const struct lacp *lacp, const void *slave_) +{ + return slave_lookup(lacp, slave_)->status != LACP_DEFAULTED; +} + /* This function should be called periodically to update 'lacp'. */ void lacp_run(struct lacp *lacp, lacp_send_pdu *send_pdu) @@ -281,14 +414,13 @@ lacp_run(struct lacp *lacp, lacp_send_pdu *send_pdu) struct slave *slave; HMAP_FOR_EACH (slave, node, &lacp->slaves) { - if (time_msec() >= slave->rx) { + if (timer_expired(&slave->rx)) { if (slave->status == LACP_CURRENT) { slave_set_expired(slave); } else if (slave->status == LACP_EXPIRED) { slave_set_defaulted(slave); } } - slave_update_actor(slave); } if (lacp->update) { @@ -296,19 +428,33 @@ lacp_run(struct lacp *lacp, lacp_send_pdu *send_pdu) } HMAP_FOR_EACH (slave, node, &lacp->slaves) { - struct lacp_pdu pdu; + struct lacp_info actor; - if (time_msec() < slave->tx || !slave_may_tx(slave)) { + if (!slave_may_tx(slave)) { continue; } - compose_lacp_pdu(&slave->actor, &slave->partner, &pdu); - send_pdu(slave->aux, &pdu); + slave_get_actor(slave, &actor); + + if (timer_expired(&slave->tx) + || !info_tx_equal(&actor, &slave->ntt_actor)) { + long long int duration; + struct lacp_pdu pdu; + + slave->ntt_actor = actor; + compose_lacp_pdu(&actor, &slave->partner, &pdu); + send_pdu(slave->aux, &pdu, sizeof pdu); + + if (lacp->lacp_time == LACP_TIME_CUSTOM) { + duration = lacp->custom_time; + } else { + duration = (slave->partner.state & LACP_STATE_TIME + ? LACP_FAST_TIME_TX + : LACP_SLOW_TIME_TX); + } - slave->tx = time_msec() + - (slave->partner.state & LACP_STATE_TIME - ? LACP_FAST_TIME_TX - : LACP_SLOW_TIME_TX); + timer_set_duration(&slave->tx, duration); + } } } @@ -320,18 +466,18 @@ lacp_wait(struct lacp *lacp) HMAP_FOR_EACH (slave, node, &lacp->slaves) { if (slave_may_tx(slave)) { - poll_timer_wait_until(slave->tx); + timer_wait(&slave->tx); } if (slave->status != LACP_DEFAULTED) { - poll_timer_wait_until(slave->rx); + timer_wait(&slave->rx); } } } /* Static Helpers. */ -/* Updates the attached status of all slaves controlled b 'lacp' and sets its +/* Updates the attached status of all slaves controlled by 'lacp' and sets its * negotiated parameter to true if any slaves are attachable. */ static void lacp_update_attached(struct lacp *lacp) @@ -340,6 +486,13 @@ lacp_update_attached(struct lacp *lacp) struct lacp_info lead_pri; static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10); + if (lacp->heartbeat) { + HMAP_FOR_EACH (slave, node, &lacp->slaves) { + slave->attached = slave->status != LACP_DEFAULTED; + } + return; + } + lacp->update = false; lead = NULL; @@ -350,7 +503,7 @@ lacp_update_attached(struct lacp *lacp) /* XXX: In the future allow users to configure the expected system ID. * For now just special case loopback. */ - if (eth_addr_equals(slave->partner.sys_id, slave->actor.sys_id)) { + if (eth_addr_equals(slave->partner.sys_id, slave->lacp->sys_id)) { VLOG_WARN_RL(&rl, "slave %s: Loopback detected. Slave is " "connected to its own bond", slave->name); slave->attached = false; @@ -412,7 +565,6 @@ slave_set_defaulted(struct slave *slave) { memset(&slave->partner, 0, sizeof slave->partner); - slave->tx = LLONG_MIN; slave->lacp->update = true; slave->status = LACP_DEFAULTED; } @@ -420,23 +572,35 @@ slave_set_defaulted(struct slave *slave) static void slave_set_expired(struct slave *slave) { + struct lacp *lacp = slave->lacp; + slave->status = LACP_EXPIRED; slave->partner.state |= LACP_STATE_TIME; slave->partner.state &= ~LACP_STATE_SYNC; - slave->rx = time_msec() + LACP_FAST_TIME_RX; - slave->tx = LLONG_MIN; + /* The spec says we should wait LACP_RX_MULTIPLIER * LACP_FAST_TIME_TX. + * This doesn't make sense when using custom times which can be much + * smaller than LACP_FAST_TIME. */ + timer_set_duration(&slave->rx, (lacp->lacp_time == LACP_TIME_CUSTOM + ? lacp->custom_time + : LACP_RX_MULTIPLIER * LACP_FAST_TIME_TX)); } static void -slave_update_actor(struct slave *slave) +slave_get_actor(struct slave *slave, struct lacp_info *actor) { + struct lacp *lacp = slave->lacp; + uint16_t key; uint8_t state = 0; - if (slave->lacp->active) { + if (lacp->active) { state |= LACP_STATE_ACT; } + if (lacp->lacp_time != LACP_TIME_SLOW) { + state |= LACP_STATE_TIME; + } + if (slave->attached) { state |= LACP_STATE_SYNC; } @@ -449,20 +613,25 @@ slave_update_actor(struct slave *slave) state |= LACP_STATE_EXP; } - if (hmap_count(&slave->lacp->slaves) > 1) { + if (lacp->heartbeat || hmap_count(&lacp->slaves) > 1) { state |= LACP_STATE_AGG; } - if (slave->enabled) { + if (slave->attached || !lacp->negotiated) { state |= LACP_STATE_COL | LACP_STATE_DIST; } - slave->actor.state = state; - slave->actor.key = htons(slave->lacp->key_slave->port_id); - slave->actor.port_priority = htons(slave->port_priority); - slave->actor.port_id = htons(slave->port_id); - slave->actor.sys_priority = htons(slave->lacp->sys_priority); - memcpy(&slave->actor.sys_id, slave->lacp->sys_id, ETH_ADDR_LEN); + key = lacp->key_slave->key; + if (!key) { + key = lacp->key_slave->port_id; + } + + actor->state = state; + actor->key = htons(key); + actor->port_priority = htons(slave->port_priority); + actor->port_id = htons(slave->port_id); + actor->sys_priority = htons(lacp->sys_priority); + memcpy(&actor->sys_id, lacp->sys_id, ETH_ADDR_LEN); } /* Given 'slave', populates 'priority' with data representing its LACP link @@ -476,15 +645,15 @@ slave_get_priority(struct slave *slave, struct lacp_info *priority) /* Choose the lacp_info of the higher priority system by comparing their * system priorities and mac addresses. */ - actor_priority = ntohs(slave->actor.sys_priority); + actor_priority = slave->lacp->sys_priority; partner_priority = ntohs(slave->partner.sys_priority); if (actor_priority < partner_priority) { - *priority = slave->actor; + slave_get_actor(slave, priority); } else if (partner_priority < actor_priority) { *priority = slave->partner; - } else if (eth_addr_compare_3way(slave->actor.sys_id, + } else if (eth_addr_compare_3way(slave->lacp->sys_id, slave->partner.sys_id) < 0) { - *priority = slave->actor; + slave_get_actor(slave, priority); } else { *priority = slave->partner; } @@ -514,6 +683,28 @@ slave_lookup(const struct lacp *lacp, const void *slave_) return NULL; } + +/* Two lacp_info structures are tx_equal if and only if they do not differ in + * ways which would require a lacp_pdu transmission. */ +static bool +info_tx_equal(struct lacp_info *a, struct lacp_info *b) +{ + + /* LACP specification dictates that we transmit whenever the actor and + * remote_actor differ in the following fields: Port, Port Priority, + * System, System Priority, Aggregation Key, Activity State, Timeout State, + * Sync State, and Aggregation State. The state flags are most likely to + * change so are checked first. */ + return !((a->state ^ b->state) & (LACP_STATE_ACT + | LACP_STATE_TIME + | LACP_STATE_SYNC + | LACP_STATE_AGG)) + && a->port_id == b->port_id + && a->port_priority == b->port_priority + && a->key == b->key + && a->sys_priority == b->sys_priority + && eth_addr_equals(a->sys_id, b->sys_id); +} static struct lacp * lacp_find(const char *name) @@ -566,37 +757,50 @@ ds_put_lacp_state(struct ds *ds, uint8_t state) } static void -lacp_unixctl_show(struct unixctl_conn *conn, - const char *args, void *aux OVS_UNUSED) +lacp_print_details(struct ds *ds, struct lacp *lacp) { - struct ds ds = DS_EMPTY_INITIALIZER; - struct lacp *lacp; struct slave *slave; - lacp = lacp_find(args); - if (!lacp) { - unixctl_command_reply(conn, 501, "no such lacp object"); - return; + ds_put_format(ds, "---- %s ----\n", lacp->name); + ds_put_format(ds, "\tstatus: %s", lacp->active ? "active" : "passive"); + if (lacp->heartbeat) { + ds_put_cstr(ds, " heartbeat"); } + if (lacp->negotiated) { + ds_put_cstr(ds, " negotiated"); + } + ds_put_cstr(ds, "\n"); - ds_put_format(&ds, "lacp: %s\n", lacp->name); - ds_put_format(&ds, "\tstatus: %s %s\n", - lacp->active ? "active" : "passive", - lacp->negotiated ? "negotiated" : ""); - ds_put_format(&ds, "\tsys_id: " ETH_ADDR_FMT "\n", ETH_ADDR_ARGS(lacp->sys_id)); - ds_put_format(&ds, "\tsys_priority: %u\n", lacp->sys_priority); - ds_put_cstr(&ds, "\taggregation key: "); + ds_put_format(ds, "\tsys_id: " ETH_ADDR_FMT "\n", ETH_ADDR_ARGS(lacp->sys_id)); + ds_put_format(ds, "\tsys_priority: %u\n", lacp->sys_priority); + ds_put_cstr(ds, "\taggregation key: "); if (lacp->key_slave) { - ds_put_format(&ds, "%u", lacp->key_slave->port_id); + ds_put_format(ds, "%u", lacp->key_slave->port_id); } else { - ds_put_cstr(&ds, "none"); + ds_put_cstr(ds, "none"); + } + ds_put_cstr(ds, "\n"); + + ds_put_cstr(ds, "\tlacp_time: "); + switch (lacp->lacp_time) { + case LACP_TIME_FAST: + ds_put_cstr(ds, "fast\n"); + break; + case LACP_TIME_SLOW: + ds_put_cstr(ds, "slow\n"); + break; + case LACP_TIME_CUSTOM: + ds_put_format(ds, "custom (%lld)\n", lacp->custom_time); + break; + default: + ds_put_cstr(ds, "unknown\n"); } - ds_put_cstr(&ds, "\n"); HMAP_FOR_EACH (slave, node, &lacp->slaves) { char *status; + struct lacp_info actor; - slave_update_actor(slave); + slave_get_actor(slave, &actor); switch (slave->status) { case LACP_CURRENT: status = "current"; @@ -611,39 +815,59 @@ lacp_unixctl_show(struct unixctl_conn *conn, NOT_REACHED(); } - ds_put_format(&ds, "\nslave: %s: %s %s %s\n", slave->name, status, - slave->attached ? "attached" : "detached", - slave->enabled ? "enabled" : "disabled"); - ds_put_format(&ds, "\tport_id: %u\n", slave->port_id); - ds_put_format(&ds, "\tport_priority: %u\n", slave->port_priority); - - ds_put_format(&ds, "\n\tactor sys_id: " ETH_ADDR_FMT "\n", - ETH_ADDR_ARGS(slave->actor.sys_id)); - ds_put_format(&ds, "\tactor sys_priority: %u\n", - ntohs(slave->actor.sys_priority)); - ds_put_format(&ds, "\tactor port_id: %u\n", - ntohs(slave->actor.port_id)); - ds_put_format(&ds, "\tactor port_priority: %u\n", - ntohs(slave->actor.port_priority)); - ds_put_format(&ds, "\tactor key: %u\n", - ntohs(slave->actor.key)); - ds_put_cstr(&ds, "\tactor state: "); - ds_put_lacp_state(&ds, slave->actor.state); - ds_put_cstr(&ds, "\n\n"); - - ds_put_format(&ds, "\tpartner sys_id: " ETH_ADDR_FMT "\n", + ds_put_format(ds, "\nslave: %s: %s %s\n", slave->name, status, + slave->attached ? "attached" : "detached"); + ds_put_format(ds, "\tport_id: %u\n", slave->port_id); + ds_put_format(ds, "\tport_priority: %u\n", slave->port_priority); + + ds_put_format(ds, "\n\tactor sys_id: " ETH_ADDR_FMT "\n", + ETH_ADDR_ARGS(actor.sys_id)); + ds_put_format(ds, "\tactor sys_priority: %u\n", + ntohs(actor.sys_priority)); + ds_put_format(ds, "\tactor port_id: %u\n", + ntohs(actor.port_id)); + ds_put_format(ds, "\tactor port_priority: %u\n", + ntohs(actor.port_priority)); + ds_put_format(ds, "\tactor key: %u\n", + ntohs(actor.key)); + ds_put_cstr(ds, "\tactor state: "); + ds_put_lacp_state(ds, actor.state); + ds_put_cstr(ds, "\n\n"); + + ds_put_format(ds, "\tpartner sys_id: " ETH_ADDR_FMT "\n", ETH_ADDR_ARGS(slave->partner.sys_id)); - ds_put_format(&ds, "\tpartner sys_priority: %u\n", + ds_put_format(ds, "\tpartner sys_priority: %u\n", ntohs(slave->partner.sys_priority)); - ds_put_format(&ds, "\tpartner port_id: %u\n", + ds_put_format(ds, "\tpartner port_id: %u\n", ntohs(slave->partner.port_id)); - ds_put_format(&ds, "\tpartner port_priority: %u\n", + ds_put_format(ds, "\tpartner port_priority: %u\n", ntohs(slave->partner.port_priority)); - ds_put_format(&ds, "\tpartner key: %u\n", + ds_put_format(ds, "\tpartner key: %u\n", ntohs(slave->partner.key)); - ds_put_cstr(&ds, "\tpartner state: "); - ds_put_lacp_state(&ds, slave->partner.state); - ds_put_cstr(&ds, "\n"); + ds_put_cstr(ds, "\tpartner state: "); + ds_put_lacp_state(ds, slave->partner.state); + ds_put_cstr(ds, "\n"); + } +} + +static void +lacp_unixctl_show(struct unixctl_conn *conn, + const char *args, void *aux OVS_UNUSED) +{ + struct ds ds = DS_EMPTY_INITIALIZER; + struct lacp *lacp; + + if (strlen(args)) { + lacp = lacp_find(args); + if (!lacp) { + unixctl_command_reply(conn, 501, "no such lacp object"); + return; + } + lacp_print_details(&ds, lacp); + } else { + LIST_FOR_EACH (lacp, node, &all_lacps) { + lacp_print_details(&ds, lacp); + } } unixctl_command_reply(conn, 200, ds_cstr(&ds));