Lines Matching refs:port
97 static int ad_lacpdu_send(struct port *port);
98 static int ad_marker_send(struct port *port, struct bond_marker *marker);
99 static void ad_mux_machine(struct port *port, bool *update_slave_arr);
100 static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port);
101 static void ad_tx_machine(struct port *port);
102 static void ad_periodic_machine(struct port *port, struct bond_params *bond_params);
103 static void ad_port_selection_logic(struct port *port, bool *update_slave_arr);
108 static void ad_initialize_port(struct port *port, int lacp_fast);
109 static void ad_enable_collecting_distributing(struct port *port,
111 static void ad_disable_collecting_distributing(struct port *port,
114 struct port *port);
116 struct port *port);
117 static void ad_update_actor_keys(struct port *port, bool reset);
123 * __get_bond_by_port - get the port's bonding struct
124 * @port: the port we're looking at
126 * Return @port's bonding struct, or %NULL if it can't be found.
128 static inline struct bonding *__get_bond_by_port(struct port *port)
130 if (port->slave == NULL)
133 return bond_get_bond_by_slave(port->slave);
138 * @port: the port we're looking at
144 static inline struct aggregator *__get_first_agg(struct port *port)
146 struct bonding *bond = __get_bond_by_port(port);
150 /* If there's no bond for this port, or bond has no slaves */
175 * __disable_port - disable the port's slave
176 * @port: the port we're looking at
178 static inline void __disable_port(struct port *port)
180 bond_set_slave_inactive_flags(port->slave, BOND_SLAVE_NOTIFY_LATER);
184 * __enable_port - enable the port's slave, if it's up
185 * @port: the port we're looking at
187 static inline void __enable_port(struct port *port)
189 struct slave *slave = port->slave;
196 * __port_is_enabled - check if the port's slave is in active state
197 * @port: the port we're looking at
199 static inline int __port_is_enabled(struct port *port)
201 return bond_is_active_slave(port->slave);
206 * @port: the port we're looking at
210 static inline u32 __get_agg_selection_mode(struct port *port)
212 struct bonding *bond = __get_bond_by_port(port);
222 * @port: the port we're looking at
224 static inline int __check_agg_selection_timer(struct port *port)
226 struct bonding *bond = __get_bond_by_port(port);
235 * __get_link_speed - get a port's speed
236 * @port: the port we're looking at
238 * Return @port's speed in 802.3ad enum format. i.e. one of:
257 static u16 __get_link_speed(struct port *port)
259 struct slave *slave = port->slave;
338 pr_err_once("%s: (slave %s): unknown ethtool speed (%d) for port %d (set it to 0)\n",
341 port->actor_port_number);
348 port->actor_port_number, speed);
353 * __get_duplex - get a port's duplex
354 * @port: the port we're looking at
356 * Return @port's duplex in 802.3ad bitmask format. i.e.:
360 static u8 __get_duplex(struct port *port)
362 struct slave *slave = port->slave;
373 port->actor_port_number);
379 port->actor_port_number);
386 static void __ad_actor_update_port(struct port *port)
388 const struct bonding *bond = bond_get_bond_by_slave(port->slave);
390 port->actor_system = BOND_AD_INFO(bond).system.sys_mac_addr;
391 port->actor_system_priority = BOND_AD_INFO(bond).system.sys_priority;
437 * __choose_matched - update a port's matched variable from a received lacpdu
439 * @port: the port we're looking at
459 static void __choose_matched(struct lacpdu *lacpdu, struct port *port)
465 if (((ntohs(lacpdu->partner_port) == port->actor_port_number) &&
466 (ntohs(lacpdu->partner_port_priority) == port->actor_port_priority) &&
467 MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) &&
468 (ntohs(lacpdu->partner_system_priority) == port->actor_system_priority) &&
469 (ntohs(lacpdu->partner_key) == port->actor_oper_port_key) &&
470 ((lacpdu->partner_state & LACP_STATE_AGGREGATION) == (port->actor_oper_port_state & LACP_STATE_AGGREGATION))) ||
473 port->sm_vars |= AD_PORT_MATCHED;
475 port->sm_vars &= ~AD_PORT_MATCHED;
482 * @port: the port we're looking at
488 static void __record_pdu(struct lacpdu *lacpdu, struct port *port)
490 if (lacpdu && port) {
491 struct port_params *partner = &port->partner_oper;
493 __choose_matched(lacpdu, port);
505 port->actor_oper_port_state &= ~LACP_STATE_DEFAULTED;
508 * and the port is matched
510 if ((port->sm_vars & AD_PORT_MATCHED) &&
513 slave_dbg(port->slave->bond->dev, port->slave->dev,
517 slave_dbg(port->slave->bond->dev, port->slave->dev,
525 * @port: the port we're looking at
531 static void __record_default(struct port *port)
533 if (port) {
535 memcpy(&port->partner_oper, &port->partner_admin,
539 port->actor_oper_port_state |= LACP_STATE_DEFAULTED;
544 * __update_selected - update a port's Selected variable from a received lacpdu
546 * @port: the port we're looking at
556 static void __update_selected(struct lacpdu *lacpdu, struct port *port)
558 if (lacpdu && port) {
559 const struct port_params *partner = &port->partner_oper;
570 port->sm_vars &= ~AD_PORT_SELECTED;
576 * __update_default_selected - update a port's Selected variable from Partner
577 * @port: the port we're looking at
587 static void __update_default_selected(struct port *port)
589 if (port) {
590 const struct port_params *admin = &port->partner_admin;
591 const struct port_params *oper = &port->partner_oper;
603 port->sm_vars &= ~AD_PORT_SELECTED;
609 * __update_ntt - update a port's ntt variable from a received lacpdu
611 * @port: the port we're looking at
620 static void __update_ntt(struct lacpdu *lacpdu, struct port *port)
622 /* validate lacpdu and port */
623 if (lacpdu && port) {
625 * update the port->ntt.
627 if ((ntohs(lacpdu->partner_port) != port->actor_port_number) ||
628 (ntohs(lacpdu->partner_port_priority) != port->actor_port_priority) ||
629 !MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) ||
630 (ntohs(lacpdu->partner_system_priority) != port->actor_system_priority) ||
631 (ntohs(lacpdu->partner_key) != port->actor_oper_port_key) ||
632 ((lacpdu->partner_state & LACP_STATE_LACP_ACTIVITY) != (port->actor_oper_port_state & LACP_STATE_LACP_ACTIVITY)) ||
633 ((lacpdu->partner_state & LACP_STATE_LACP_TIMEOUT) != (port->actor_oper_port_state & LACP_STATE_LACP_TIMEOUT)) ||
634 ((lacpdu->partner_state & LACP_STATE_SYNCHRONIZATION) != (port->actor_oper_port_state & LACP_STATE_SYNCHRONIZATION)) ||
635 ((lacpdu->partner_state & LACP_STATE_AGGREGATION) != (port->actor_oper_port_state & LACP_STATE_AGGREGATION))
637 port->ntt = true;
649 struct port *port;
656 for (port = aggregator->lag_ports;
657 port;
658 port = port->next_port_in_aggregator) {
659 if (!(port->sm_vars & AD_PORT_READY_N)) {
677 struct port *port;
679 for (port = aggregator->lag_ports; port;
680 port = port->next_port_in_aggregator) {
682 port->sm_vars |= AD_PORT_READY;
684 port->sm_vars &= ~AD_PORT_READY;
690 struct port *port;
693 for (port = agg->lag_ports; port;
694 port = port->next_port_in_aggregator) {
695 if (port->is_enabled)
792 * __update_lacpdu_from_port - update a port's lacpdu fields
793 * @port: the port we're looking at
795 static inline void __update_lacpdu_from_port(struct port *port)
797 struct lacpdu *lacpdu = &port->lacpdu;
798 const struct port_params *partner = &port->partner_oper;
807 lacpdu->actor_system_priority = htons(port->actor_system_priority);
808 lacpdu->actor_system = port->actor_system;
809 lacpdu->actor_key = htons(port->actor_oper_port_key);
810 lacpdu->actor_port_priority = htons(port->actor_port_priority);
811 lacpdu->actor_port = htons(port->actor_port_number);
812 lacpdu->actor_state = port->actor_oper_port_state;
813 slave_dbg(port->slave->bond->dev, port->slave->dev,
814 "update lacpdu: actor port state %x\n",
815 port->actor_oper_port_state);
843 * ad_lacpdu_send - send out a lacpdu packet on a given port
844 * @port: the port we're looking at
849 static int ad_lacpdu_send(struct port *port)
851 struct slave *slave = port->slave;
878 lacpdu_header->lacpdu = port->lacpdu;
886 * ad_marker_send - send marker information/response on a given port
887 * @port: the port we're looking at
893 static int ad_marker_send(struct port *port, struct bond_marker *marker)
895 struct slave *slave = port->slave;
939 * ad_mux_machine - handle a port's mux state machine
940 * @port: the port we're looking at
943 static void ad_mux_machine(struct port *port, bool *update_slave_arr)
950 last_state = port->sm_mux_state;
952 if (port->sm_vars & AD_PORT_BEGIN) {
953 port->sm_mux_state = AD_MUX_DETACHED;
955 switch (port->sm_mux_state) {
957 if ((port->sm_vars & AD_PORT_SELECTED)
958 || (port->sm_vars & AD_PORT_STANDBY))
960 port->sm_mux_state = AD_MUX_WAITING;
964 if (!(port->sm_vars & AD_PORT_SELECTED)) {
965 port->sm_vars &= ~AD_PORT_READY_N;
971 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
972 port->sm_mux_state = AD_MUX_DETACHED;
977 if (port->sm_mux_timer_counter
978 && !(--port->sm_mux_timer_counter))
979 port->sm_vars |= AD_PORT_READY_N;
986 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
988 /* if the wait_while_timer expired, and the port is
991 if ((port->sm_vars & AD_PORT_READY)
992 && !port->sm_mux_timer_counter)
993 port->sm_mux_state = AD_MUX_ATTACHED;
997 * edable port will take place only after this timer)
999 if ((port->sm_vars & AD_PORT_SELECTED) &&
1000 (port->partner_oper.port_state & LACP_STATE_SYNCHRONIZATION) &&
1001 !__check_agg_selection_timer(port)) {
1002 if (port->aggregator->is_active)
1003 port->sm_mux_state =
1005 } else if (!(port->sm_vars & AD_PORT_SELECTED) ||
1006 (port->sm_vars & AD_PORT_STANDBY)) {
1008 port->sm_vars &= ~AD_PORT_READY_N;
1014 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
1015 port->sm_mux_state = AD_MUX_DETACHED;
1016 } else if (port->aggregator->is_active) {
1017 port->actor_oper_port_state |=
1022 if (!(port->sm_vars & AD_PORT_SELECTED) ||
1023 (port->sm_vars & AD_PORT_STANDBY) ||
1024 !(port->partner_oper.port_state & LACP_STATE_SYNCHRONIZATION) ||
1025 !(port->actor_oper_port_state & LACP_STATE_SYNCHRONIZATION)) {
1026 port->sm_mux_state = AD_MUX_ATTACHED;
1028 /* if port state hasn't changed make
1030 * port in an active aggregator is enabled
1032 if (port->aggregator &&
1033 port->aggregator->is_active &&
1034 !__port_is_enabled(port)) {
1035 __enable_port(port);
1046 if (port->sm_mux_state != last_state) {
1047 slave_dbg(port->slave->bond->dev, port->slave->dev,
1049 port->actor_port_number,
1051 port->sm_mux_state);
1052 switch (port->sm_mux_state) {
1054 port->actor_oper_port_state &= ~LACP_STATE_SYNCHRONIZATION;
1055 ad_disable_collecting_distributing(port,
1057 port->actor_oper_port_state &= ~LACP_STATE_COLLECTING;
1058 port->actor_oper_port_state &= ~LACP_STATE_DISTRIBUTING;
1059 port->ntt = true;
1062 port->sm_mux_timer_counter = __ad_timer_to_ticks(AD_WAIT_WHILE_TIMER, 0);
1065 if (port->aggregator->is_active)
1066 port->actor_oper_port_state |=
1069 port->actor_oper_port_state &=
1071 port->actor_oper_port_state &= ~LACP_STATE_COLLECTING;
1072 port->actor_oper_port_state &= ~LACP_STATE_DISTRIBUTING;
1073 ad_disable_collecting_distributing(port,
1075 port->ntt = true;
1078 port->actor_oper_port_state |= LACP_STATE_COLLECTING;
1079 port->actor_oper_port_state |= LACP_STATE_DISTRIBUTING;
1080 port->actor_oper_port_state |= LACP_STATE_SYNCHRONIZATION;
1081 ad_enable_collecting_distributing(port,
1083 port->ntt = true;
1092 * ad_rx_machine - handle a port's rx State Machine
1094 * @port: the port we're looking at
1100 static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port)
1107 last_state = port->sm_rx_state;
1110 atomic64_inc(&SLAVE_AD_INFO(port->slave)->stats.lacpdu_rx);
1111 atomic64_inc(&BOND_AD_INFO(port->slave->bond).stats.lacpdu_rx);
1115 /* first, check if port was reinitialized */
1116 if (port->sm_vars & AD_PORT_BEGIN) {
1117 port->sm_rx_state = AD_RX_INITIALIZE;
1118 port->sm_vars |= AD_PORT_CHURNED;
1119 /* check if port is not enabled */
1120 } else if (!(port->sm_vars & AD_PORT_BEGIN) && !port->is_enabled)
1121 port->sm_rx_state = AD_RX_PORT_DISABLED;
1123 else if (lacpdu && ((port->sm_rx_state == AD_RX_EXPIRED) ||
1124 (port->sm_rx_state == AD_RX_DEFAULTED) ||
1125 (port->sm_rx_state == AD_RX_CURRENT))) {
1126 if (port->sm_rx_state != AD_RX_CURRENT)
1127 port->sm_vars |= AD_PORT_CHURNED;
1128 port->sm_rx_timer_counter = 0;
1129 port->sm_rx_state = AD_RX_CURRENT;
1132 if (port->sm_rx_timer_counter &&
1133 !(--port->sm_rx_timer_counter)) {
1134 switch (port->sm_rx_state) {
1136 port->sm_rx_state = AD_RX_DEFAULTED;
1139 port->sm_rx_state = AD_RX_EXPIRED;
1146 switch (port->sm_rx_state) {
1148 if (port->is_enabled &&
1149 (port->sm_vars & AD_PORT_LACP_ENABLED))
1150 port->sm_rx_state = AD_RX_EXPIRED;
1151 else if (port->is_enabled
1152 && ((port->sm_vars
1154 port->sm_rx_state = AD_RX_LACP_DISABLED;
1164 if ((port->sm_rx_state != last_state) || (lacpdu)) {
1165 slave_dbg(port->slave->bond->dev, port->slave->dev,
1167 port->actor_port_number,
1169 port->sm_rx_state);
1170 switch (port->sm_rx_state) {
1172 if (!(port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS))
1173 port->sm_vars &= ~AD_PORT_LACP_ENABLED;
1175 port->sm_vars |= AD_PORT_LACP_ENABLED;
1176 port->sm_vars &= ~AD_PORT_SELECTED;
1177 __record_default(port);
1178 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1179 port->sm_rx_state = AD_RX_PORT_DISABLED;
1183 port->sm_vars &= ~AD_PORT_MATCHED;
1186 port->sm_vars &= ~AD_PORT_SELECTED;
1187 __record_default(port);
1188 port->partner_oper.port_state &= ~LACP_STATE_AGGREGATION;
1189 port->sm_vars |= AD_PORT_MATCHED;
1190 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1194 * This reset cause to disable this port in the
1197 * the port.
1199 port->partner_oper.port_state &= ~LACP_STATE_SYNCHRONIZATION;
1200 port->sm_vars &= ~AD_PORT_MATCHED;
1201 port->partner_oper.port_state |= LACP_STATE_LACP_TIMEOUT;
1202 port->partner_oper.port_state |= LACP_STATE_LACP_ACTIVITY;
1203 port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(AD_SHORT_TIMEOUT));
1204 port->actor_oper_port_state |= LACP_STATE_EXPIRED;
1205 port->sm_vars |= AD_PORT_CHURNED;
1208 __update_default_selected(port);
1209 __record_default(port);
1210 port->sm_vars |= AD_PORT_MATCHED;
1211 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1216 &(port->actor_system))) {
1217 slave_err(port->slave->bond->dev, port->slave->dev, "An illegal loopback occurred on slave\n"
1221 __update_selected(lacpdu, port);
1222 __update_ntt(lacpdu, port);
1223 __record_pdu(lacpdu, port);
1224 port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(port->actor_oper_port_state & LACP_STATE_LACP_TIMEOUT));
1225 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1234 * ad_churn_machine - handle port churn's state machine
1235 * @port: the port we're looking at
1238 static void ad_churn_machine(struct port *port)
1240 if (port->sm_vars & AD_PORT_CHURNED) {
1241 port->sm_vars &= ~AD_PORT_CHURNED;
1242 port->sm_churn_actor_state = AD_CHURN_MONITOR;
1243 port->sm_churn_partner_state = AD_CHURN_MONITOR;
1244 port->sm_churn_actor_timer_counter =
1246 port->sm_churn_partner_timer_counter =
1250 if (port->sm_churn_actor_timer_counter &&
1251 !(--port->sm_churn_actor_timer_counter) &&
1252 port->sm_churn_actor_state == AD_CHURN_MONITOR) {
1253 if (port->actor_oper_port_state & LACP_STATE_SYNCHRONIZATION) {
1254 port->sm_churn_actor_state = AD_NO_CHURN;
1256 port->churn_actor_count++;
1257 port->sm_churn_actor_state = AD_CHURN;
1260 if (port->sm_churn_partner_timer_counter &&
1261 !(--port->sm_churn_partner_timer_counter) &&
1262 port->sm_churn_partner_state == AD_CHURN_MONITOR) {
1263 if (port->partner_oper.port_state & LACP_STATE_SYNCHRONIZATION) {
1264 port->sm_churn_partner_state = AD_NO_CHURN;
1266 port->churn_partner_count++;
1267 port->sm_churn_partner_state = AD_CHURN;
1273 * ad_tx_machine - handle a port's tx state machine
1274 * @port: the port we're looking at
1276 static void ad_tx_machine(struct port *port)
1281 if (port->sm_tx_timer_counter && !(--port->sm_tx_timer_counter)) {
1283 if (port->ntt && (port->sm_vars & AD_PORT_LACP_ENABLED)) {
1284 __update_lacpdu_from_port(port);
1286 if (ad_lacpdu_send(port) >= 0) {
1287 slave_dbg(port->slave->bond->dev,
1288 port->slave->dev,
1289 "Sent LACPDU on port %d\n",
1290 port->actor_port_number);
1295 port->ntt = false;
1301 port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
1306 * ad_periodic_machine - handle a port's periodic state machine
1307 * @port: the port we're looking at
1312 static void ad_periodic_machine(struct port *port, struct bond_params *bond_params)
1317 last_state = port->sm_periodic_state;
1319 /* check if port was reinitialized */
1320 if (((port->sm_vars & AD_PORT_BEGIN) || !(port->sm_vars & AD_PORT_LACP_ENABLED) || !port->is_enabled) ||
1321 (!(port->actor_oper_port_state & LACP_STATE_LACP_ACTIVITY) && !(port->partner_oper.port_state & LACP_STATE_LACP_ACTIVITY)) ||
1323 port->sm_periodic_state = AD_NO_PERIODIC;
1326 else if (port->sm_periodic_timer_counter) {
1328 if (!(--port->sm_periodic_timer_counter)) {
1330 port->sm_periodic_state = AD_PERIODIC_TX;
1335 switch (port->sm_periodic_state) {
1337 if (!(port->partner_oper.port_state
1339 port->sm_periodic_state = AD_SLOW_PERIODIC;
1342 if ((port->partner_oper.port_state & LACP_STATE_LACP_TIMEOUT)) {
1343 port->sm_periodic_timer_counter = 0;
1344 port->sm_periodic_state = AD_PERIODIC_TX;
1352 switch (port->sm_periodic_state) {
1354 port->sm_periodic_state = AD_FAST_PERIODIC;
1357 if (!(port->partner_oper.port_state &
1359 port->sm_periodic_state = AD_SLOW_PERIODIC;
1361 port->sm_periodic_state = AD_FAST_PERIODIC;
1369 if (port->sm_periodic_state != last_state) {
1370 slave_dbg(port->slave->bond->dev, port->slave->dev,
1372 port->actor_port_number, last_state,
1373 port->sm_periodic_state);
1374 switch (port->sm_periodic_state) {
1376 port->sm_periodic_timer_counter = 0;
1380 port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_FAST_PERIODIC_TIME))-1;
1384 port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_SLOW_PERIODIC_TIME))-1;
1387 port->ntt = true;
1397 * @port: the port we're looking at
1400 * Select aggregation groups, and assign each port for it's aggregetor. The
1404 static void ad_port_selection_logic(struct port *port, bool *update_slave_arr)
1407 struct port *last_port = NULL, *curr_port;
1413 /* if the port is already Selected, do nothing */
1414 if (port->sm_vars & AD_PORT_SELECTED)
1417 bond = __get_bond_by_port(port);
1419 /* if the port is connected to other aggregator, detach it */
1420 if (port->aggregator) {
1421 /* detach the port from its former aggregator */
1422 temp_aggregator = port->aggregator;
1426 if (curr_port == port) {
1428 /* if it is the first port attached to the
1433 port->next_port_in_aggregator;
1435 /* not the first port attached to the
1439 port->next_port_in_aggregator;
1442 /* clear the port's relations to this
1445 port->aggregator = NULL;
1446 port->next_port_in_aggregator = NULL;
1447 port->actor_port_aggregator_identifier = 0;
1449 slave_dbg(bond->dev, port->slave->dev, "Port %d left LAG %d\n",
1450 port->actor_port_number,
1461 /* meaning: the port was related to an aggregator
1462 * but was not on the aggregator port list
1464 net_warn_ratelimited("%s: (slave %s): Warning: Port %d was related to aggregator %d but was not on its port list\n",
1465 port->slave->bond->dev->name,
1466 port->slave->dev->name,
1467 port->actor_port_number,
1468 port->aggregator->aggregator_identifier);
1471 /* search on all aggregators for a suitable aggregator for this port */
1482 if (((aggregator->actor_oper_aggregator_key == port->actor_oper_port_key) && /* if all parameters match AND */
1483 MAC_ADDRESS_EQUAL(&(aggregator->partner_system), &(port->partner_oper.system)) &&
1484 (aggregator->partner_system_priority == port->partner_oper.system_priority) &&
1485 (aggregator->partner_oper_aggregator_key == port->partner_oper.key)
1487 ((!MAC_ADDRESS_EQUAL(&(port->partner_oper.system), &(null_mac_addr)) && /* partner answers */
1492 port->aggregator = aggregator;
1493 port->actor_port_aggregator_identifier =
1494 port->aggregator->aggregator_identifier;
1495 port->next_port_in_aggregator = aggregator->lag_ports;
1496 port->aggregator->num_of_ports++;
1497 aggregator->lag_ports = port;
1499 port->actor_port_number,
1500 port->aggregator->aggregator_identifier);
1502 /* mark this port as selected */
1503 port->sm_vars |= AD_PORT_SELECTED;
1509 /* the port couldn't find an aggregator - attach it to a new
1514 /* assign port a new aggregator */
1515 port->aggregator = free_aggregator;
1516 port->actor_port_aggregator_identifier =
1517 port->aggregator->aggregator_identifier;
1520 * if port was responsed from the end-user
1522 if (port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS)
1523 /* if port is full duplex */
1524 port->aggregator->is_individual = false;
1526 port->aggregator->is_individual = true;
1528 port->aggregator->actor_admin_aggregator_key =
1529 port->actor_admin_port_key;
1530 port->aggregator->actor_oper_aggregator_key =
1531 port->actor_oper_port_key;
1532 port->aggregator->partner_system =
1533 port->partner_oper.system;
1534 port->aggregator->partner_system_priority =
1535 port->partner_oper.system_priority;
1536 port->aggregator->partner_oper_aggregator_key = port->partner_oper.key;
1537 port->aggregator->receive_state = 1;
1538 port->aggregator->transmit_state = 1;
1539 port->aggregator->lag_ports = port;
1540 port->aggregator->num_of_ports++;
1542 /* mark this port as selected */
1543 port->sm_vars |= AD_PORT_SELECTED;
1545 slave_dbg(bond->dev, port->slave->dev, "Port %d joined LAG %d (new LAG)\n",
1546 port->actor_port_number,
1547 port->aggregator->aggregator_identifier);
1549 slave_err(bond->dev, port->slave->dev,
1551 port->actor_port_number);
1559 __set_agg_ports_ready(port->aggregator,
1560 __agg_ports_are_ready(port->aggregator));
1562 aggregator = __get_first_agg(port);
1565 if (!port->aggregator->is_active)
1566 port->actor_oper_port_state &= ~LACP_STATE_SYNCHRONIZATION;
1643 struct port *port = agg->lag_ports;
1645 if (!port)
1648 for (port = agg->lag_ports; port;
1649 port = port->next_port_in_aggregator) {
1650 if (netif_running(port->slave->dev) &&
1651 netif_carrier_ok(port->slave->dev))
1691 struct port *port;
1774 for (port = active->lag_ports; port;
1775 port = port->next_port_in_aggregator) {
1776 __disable_port(port);
1790 for (port = active->lag_ports; port;
1791 port = port->next_port_in_aggregator) {
1792 __enable_port(port);
1844 * ad_initialize_port - initialize a given port's parameters
1845 * @port: the port we're looking at
1848 static void ad_initialize_port(struct port *port, int lacp_fast)
1869 if (port) {
1870 port->actor_port_priority = 0xff;
1871 port->actor_port_aggregator_identifier = 0;
1872 port->ntt = false;
1873 port->actor_admin_port_state = LACP_STATE_AGGREGATION |
1875 port->actor_oper_port_state = LACP_STATE_AGGREGATION |
1879 port->actor_oper_port_state |= LACP_STATE_LACP_TIMEOUT;
1881 memcpy(&port->partner_admin, &tmpl, sizeof(tmpl));
1882 memcpy(&port->partner_oper, &tmpl, sizeof(tmpl));
1884 port->is_enabled = true;
1886 port->sm_vars = AD_PORT_BEGIN | AD_PORT_LACP_ENABLED;
1887 port->sm_rx_state = 0;
1888 port->sm_rx_timer_counter = 0;
1889 port->sm_periodic_state = 0;
1890 port->sm_periodic_timer_counter = 0;
1891 port->sm_mux_state = 0;
1892 port->sm_mux_timer_counter = 0;
1893 port->sm_tx_state = 0;
1894 port->aggregator = NULL;
1895 port->next_port_in_aggregator = NULL;
1896 port->transaction_id = 0;
1898 port->sm_churn_actor_timer_counter = 0;
1899 port->sm_churn_actor_state = 0;
1900 port->churn_actor_count = 0;
1901 port->sm_churn_partner_timer_counter = 0;
1902 port->sm_churn_partner_state = 0;
1903 port->churn_partner_count = 0;
1905 memcpy(&port->lacpdu, &lacpdu, sizeof(lacpdu));
1910 * ad_enable_collecting_distributing - enable a port's transmit/receive
1911 * @port: the port we're looking at
1914 * Enable @port if it's in an active aggregator
1916 static void ad_enable_collecting_distributing(struct port *port,
1919 if (port->aggregator->is_active) {
1920 slave_dbg(port->slave->bond->dev, port->slave->dev,
1921 "Enabling port %d (LAG %d)\n",
1922 port->actor_port_number,
1923 port->aggregator->aggregator_identifier);
1924 __enable_port(port);
1931 * ad_disable_collecting_distributing - disable a port's transmit/receive
1932 * @port: the port we're looking at
1935 static void ad_disable_collecting_distributing(struct port *port,
1938 if (port->aggregator &&
1939 !MAC_ADDRESS_EQUAL(&(port->aggregator->partner_system),
1941 slave_dbg(port->slave->bond->dev, port->slave->dev,
1942 "Disabling port %d (LAG %d)\n",
1943 port->actor_port_number,
1944 port->aggregator->aggregator_identifier);
1945 __disable_port(port);
1954 * @port: the port we're looking at
1957 struct port *port)
1961 atomic64_inc(&SLAVE_AD_INFO(port->slave)->stats.marker_rx);
1962 atomic64_inc(&BOND_AD_INFO(port->slave->bond).stats.marker_rx);
1970 if (ad_marker_send(port, &marker) >= 0)
1971 slave_dbg(port->slave->bond->dev, port->slave->dev,
1972 "Sent Marker Response on port %d\n",
1973 port->actor_port_number);
1979 * @port: the port we're looking at
1986 struct port *port)
1988 atomic64_inc(&SLAVE_AD_INFO(port->slave)->stats.marker_resp_rx);
1989 atomic64_inc(&BOND_AD_INFO(port->slave->bond).stats.marker_resp_rx);
2037 * bond_3ad_bind_slave - initialize a slave's port
2046 struct port *port;
2050 if (SLAVE_AD_INFO(slave)->port.slave != slave) {
2052 /* port initialization */
2053 port = &(SLAVE_AD_INFO(slave)->port);
2055 ad_initialize_port(port, bond->params.lacp_fast);
2057 port->slave = slave;
2058 port->actor_port_number = SLAVE_AD_INFO(slave)->id;
2062 port->actor_admin_port_key = bond->params.ad_user_port_key << 6;
2063 ad_update_actor_keys(port, false);
2065 __ad_actor_update_port(port);
2069 port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
2071 __disable_port(port);
2087 * bond_3ad_unbind_slave - deinitialize a slave's port
2090 * Search for the aggregator that is related to this port, remove the
2091 * aggregator and assign another aggregator for other port related to it
2092 * (if any), and remove the port.
2096 struct port *port, *prev_port, *temp_port;
2107 port = &(SLAVE_AD_INFO(slave)->port);
2109 /* if slave is null, the whole port is not initialized */
2110 if (!port->slave) {
2111 slave_warn(bond->dev, slave->dev, "Trying to unbind an uninitialized port\n");
2118 /* Tell the partner that this port is not suitable for aggregation */
2119 port->actor_oper_port_state &= ~LACP_STATE_SYNCHRONIZATION;
2120 port->actor_oper_port_state &= ~LACP_STATE_COLLECTING;
2121 port->actor_oper_port_state &= ~LACP_STATE_DISTRIBUTING;
2122 port->actor_oper_port_state &= ~LACP_STATE_AGGREGATION;
2123 __update_lacpdu_from_port(port);
2124 ad_lacpdu_send(port);
2129 * except the port related to this slave(thats ensure us that
2133 if ((aggregator->lag_ports != port) ||
2135 /* find new aggregator for the related port(s) */
2139 * connected to our port only
2142 ((new_aggregator->lag_ports == port) &&
2153 if ((new_aggregator) && ((!new_aggregator->lag_ports) || ((new_aggregator->lag_ports == port) && !new_aggregator->lag_ports->next_port_in_aggregator))) {
2154 slave_dbg(bond->dev, slave->dev, "Some port(s) related to LAG %d - replacing with LAG %d\n",
2158 if ((new_aggregator->lag_ports == port) &&
2188 ad_agg_selection_logic(__get_first_agg(port),
2194 /* in case that the only port related to this
2202 temp_aggregator = __get_first_agg(port);
2210 slave_dbg(bond->dev, slave->dev, "Unbinding port %d\n", port->actor_port_number);
2212 /* find the aggregator that this port is connected to */
2216 /* search the port in the aggregator's related ports */
2220 if (temp_port == port) {
2221 /* the aggregator found - detach the port from
2236 ad_agg_selection_logic(__get_first_agg(port),
2244 port->slave = NULL;
2254 * If an ad_actor setting gets changed we need to update the individual port
2274 struct port *port = &(SLAVE_AD_INFO(slave))->port;
2276 __ad_actor_update_port(port);
2277 port->ntt = true;
2324 struct port *port;
2328 /* Lock to protect data accessed by all (e.g., port->sm_vars) and
2341 port = slave ? &(SLAVE_AD_INFO(slave)->port) : NULL;
2344 if (port) {
2345 if (!port->slave) {
2346 net_warn_ratelimited("%s: Warning: bond's first port is uninitialized\n",
2351 aggregator = __get_first_agg(port);
2357 /* for each port run the state machines */
2359 port = &(SLAVE_AD_INFO(slave)->port);
2360 if (!port->slave) {
2361 net_warn_ratelimited("%s: Warning: Found an uninitialized port\n",
2366 ad_rx_machine(NULL, port);
2367 ad_periodic_machine(port, &bond->params);
2368 ad_port_selection_logic(port, &update_slave_arr);
2369 ad_mux_machine(port, &update_slave_arr);
2370 ad_tx_machine(port);
2371 ad_churn_machine(port);
2374 if (port->sm_vars & AD_PORT_BEGIN)
2375 port->sm_vars &= ~AD_PORT_BEGIN;
2412 struct port *port;
2415 port = &(SLAVE_AD_INFO(slave)->port);
2416 if (!port->slave) {
2417 net_warn_ratelimited("%s: Warning: port of slave %s is uninitialized\n",
2426 "Received LACPDU on port %d\n",
2427 port->actor_port_number);
2430 ad_rx_machine(lacpdu, port);
2441 slave_dbg(slave->bond->dev, slave->dev, "Received Marker Information on port %d\n",
2442 port->actor_port_number);
2443 ad_marker_info_received(marker, port);
2446 slave_dbg(slave->bond->dev, slave->dev, "Received Marker Response on port %d\n",
2447 port->actor_port_number);
2448 ad_marker_response_received(marker, port);
2451 slave_dbg(slave->bond->dev, slave->dev, "Received an unknown Marker subtype on port %d\n",
2452 port->actor_port_number);
2468 * ad_update_actor_keys - Update the oper / admin keys for a port based on
2471 * @port: the port we'are looking at
2475 * (a) A full duplex port can participate in LACP with partner.
2478 static void ad_update_actor_keys(struct port *port, bool reset)
2482 u16 old_oper_key = port->actor_oper_port_key;
2484 port->actor_admin_port_key &= ~(AD_SPEED_KEY_MASKS|AD_DUPLEX_KEY_MASKS);
2486 speed = __get_link_speed(port);
2488 duplex = __get_duplex(port);
2489 port->actor_admin_port_key |= (speed << 1) | duplex;
2491 port->actor_oper_port_key = port->actor_admin_port_key;
2493 if (old_oper_key != port->actor_oper_port_key) {
2494 /* Only 'duplex' port participates in LACP */
2496 port->sm_vars |= AD_PORT_LACP_ENABLED;
2498 port->sm_vars &= ~AD_PORT_LACP_ENABLED;
2502 slave_err(port->slave->bond->dev,
2503 port->slave->dev,
2504 "speed changed to 0 on port %d\n",
2505 port->actor_port_number);
2508 port->sm_vars |= AD_PORT_BEGIN;
2520 * Handle reselection of aggregator (if needed) for this port.
2524 struct port *port;
2526 port = &(SLAVE_AD_INFO(slave)->port);
2528 /* if slave is null, the whole port is not initialized */
2529 if (!port->slave) {
2531 "speed/duplex changed for uninitialized port\n");
2536 ad_update_actor_keys(port, false);
2539 port->actor_port_number);
2547 * Handle reselection of aggregator (if needed) for this port.
2552 struct port *port;
2555 port = &(SLAVE_AD_INFO(slave)->port);
2557 /* if slave is null, the whole port is not initialized */
2558 if (!port->slave) {
2559 slave_warn(slave->bond->dev, slave->dev, "link status changed for uninitialized port\n");
2572 port->is_enabled = true;
2573 ad_update_actor_keys(port, false);
2576 port->is_enabled = false;
2577 ad_update_actor_keys(port, true);
2579 agg = __get_first_agg(port);
2585 port->actor_port_number,
2653 struct port *port;
2656 port = &(SLAVE_AD_INFO(slave)->port);
2657 if (port->aggregator && port->aggregator->is_active) {
2658 aggregator = port->aggregator;
2712 * update actor_oper_port_state of each port.
2715 * so we can modify port->actor_oper_port_state,
2720 struct port *port = NULL;
2728 port = &(SLAVE_AD_INFO(slave)->port);
2730 port->actor_oper_port_state |= LACP_STATE_LACP_TIMEOUT;
2732 port->actor_oper_port_state &= ~LACP_STATE_LACP_TIMEOUT;