Lines Matching refs:port
93 static int ad_lacpdu_send(struct port *port);
94 static int ad_marker_send(struct port *port, struct bond_marker *marker);
95 static void ad_mux_machine(struct port *port, bool *update_slave_arr);
96 static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port);
97 static void ad_tx_machine(struct port *port);
98 static void ad_periodic_machine(struct port *port);
99 static void ad_port_selection_logic(struct port *port, bool *update_slave_arr);
104 static void ad_initialize_port(struct port *port, int lacp_fast);
105 static void ad_enable_collecting_distributing(struct port *port,
107 static void ad_disable_collecting_distributing(struct port *port,
110 struct port *port);
112 struct port *port);
113 static void ad_update_actor_keys(struct port *port, bool reset);
119 * __get_bond_by_port - get the port's bonding struct
120 * @port: the port we're looking at
122 * Return @port's bonding struct, or %NULL if it can't be found.
124 static inline struct bonding *__get_bond_by_port(struct port *port)
126 if (port->slave == NULL)
129 return bond_get_bond_by_slave(port->slave);
134 * @port: the port we're looking at
140 static inline struct aggregator *__get_first_agg(struct port *port)
142 struct bonding *bond = __get_bond_by_port(port);
146 /* If there's no bond for this port, or bond has no slaves */
171 * __disable_port - disable the port's slave
172 * @port: the port we're looking at
174 static inline void __disable_port(struct port *port)
176 bond_set_slave_inactive_flags(port->slave, BOND_SLAVE_NOTIFY_LATER);
180 * __enable_port - enable the port's slave, if it's up
181 * @port: the port we're looking at
183 static inline void __enable_port(struct port *port)
185 struct slave *slave = port->slave;
192 * __port_is_enabled - check if the port's slave is in active state
193 * @port: the port we're looking at
195 static inline int __port_is_enabled(struct port *port)
197 return bond_is_active_slave(port->slave);
202 * @port: the port we're looking at
206 static inline u32 __get_agg_selection_mode(struct port *port)
208 struct bonding *bond = __get_bond_by_port(port);
218 * @port: the port we're looking at
220 static inline int __check_agg_selection_timer(struct port *port)
222 struct bonding *bond = __get_bond_by_port(port);
231 * __get_link_speed - get a port's speed
232 * @port: the port we're looking at
234 * Return @port's speed in 802.3ad enum format. i.e. one of:
250 static u16 __get_link_speed(struct port *port)
252 struct slave *slave = port->slave;
319 pr_warn_once("%s: (slave %s): unknown ethtool speed (%d) for port %d (set it to 0)\n",
322 port->actor_port_number);
329 port->actor_port_number, speed);
334 * __get_duplex - get a port's duplex
335 * @port: the port we're looking at
337 * Return @port's duplex in 802.3ad bitmask format. i.e.:
341 static u8 __get_duplex(struct port *port)
343 struct slave *slave = port->slave;
354 port->actor_port_number);
360 port->actor_port_number);
367 static void __ad_actor_update_port(struct port *port)
369 const struct bonding *bond = bond_get_bond_by_slave(port->slave);
371 port->actor_system = BOND_AD_INFO(bond).system.sys_mac_addr;
372 port->actor_system_priority = BOND_AD_INFO(bond).system.sys_priority;
418 * __choose_matched - update a port's matched variable from a received lacpdu
420 * @port: the port we're looking at
440 static void __choose_matched(struct lacpdu *lacpdu, struct port *port)
446 if (((ntohs(lacpdu->partner_port) == port->actor_port_number) &&
447 (ntohs(lacpdu->partner_port_priority) == port->actor_port_priority) &&
448 MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) &&
449 (ntohs(lacpdu->partner_system_priority) == port->actor_system_priority) &&
450 (ntohs(lacpdu->partner_key) == port->actor_oper_port_key) &&
451 ((lacpdu->partner_state & LACP_STATE_AGGREGATION) == (port->actor_oper_port_state & LACP_STATE_AGGREGATION))) ||
454 port->sm_vars |= AD_PORT_MATCHED;
456 port->sm_vars &= ~AD_PORT_MATCHED;
463 * @port: the port we're looking at
469 static void __record_pdu(struct lacpdu *lacpdu, struct port *port)
471 if (lacpdu && port) {
472 struct port_params *partner = &port->partner_oper;
474 __choose_matched(lacpdu, port);
486 port->actor_oper_port_state &= ~LACP_STATE_DEFAULTED;
489 * and the port is matched
491 if ((port->sm_vars & AD_PORT_MATCHED) &&
494 slave_dbg(port->slave->bond->dev, port->slave->dev,
498 slave_dbg(port->slave->bond->dev, port->slave->dev,
506 * @port: the port we're looking at
512 static void __record_default(struct port *port)
514 if (port) {
516 memcpy(&port->partner_oper, &port->partner_admin,
520 port->actor_oper_port_state |= LACP_STATE_DEFAULTED;
525 * __update_selected - update a port's Selected variable from a received lacpdu
527 * @port: the port we're looking at
537 static void __update_selected(struct lacpdu *lacpdu, struct port *port)
539 if (lacpdu && port) {
540 const struct port_params *partner = &port->partner_oper;
551 port->sm_vars &= ~AD_PORT_SELECTED;
557 * __update_default_selected - update a port's Selected variable from Partner
558 * @port: the port we're looking at
568 static void __update_default_selected(struct port *port)
570 if (port) {
571 const struct port_params *admin = &port->partner_admin;
572 const struct port_params *oper = &port->partner_oper;
584 port->sm_vars &= ~AD_PORT_SELECTED;
590 * __update_ntt - update a port's ntt variable from a received lacpdu
592 * @port: the port we're looking at
601 static void __update_ntt(struct lacpdu *lacpdu, struct port *port)
603 /* validate lacpdu and port */
604 if (lacpdu && port) {
606 * update the port->ntt.
608 if ((ntohs(lacpdu->partner_port) != port->actor_port_number) ||
609 (ntohs(lacpdu->partner_port_priority) != port->actor_port_priority) ||
610 !MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) ||
611 (ntohs(lacpdu->partner_system_priority) != port->actor_system_priority) ||
612 (ntohs(lacpdu->partner_key) != port->actor_oper_port_key) ||
613 ((lacpdu->partner_state & LACP_STATE_LACP_ACTIVITY) != (port->actor_oper_port_state & LACP_STATE_LACP_ACTIVITY)) ||
614 ((lacpdu->partner_state & LACP_STATE_LACP_TIMEOUT) != (port->actor_oper_port_state & LACP_STATE_LACP_TIMEOUT)) ||
615 ((lacpdu->partner_state & LACP_STATE_SYNCHRONIZATION) != (port->actor_oper_port_state & LACP_STATE_SYNCHRONIZATION)) ||
616 ((lacpdu->partner_state & LACP_STATE_AGGREGATION) != (port->actor_oper_port_state & LACP_STATE_AGGREGATION))
618 port->ntt = true;
630 struct port *port;
637 for (port = aggregator->lag_ports;
638 port;
639 port = port->next_port_in_aggregator) {
640 if (!(port->sm_vars & AD_PORT_READY_N)) {
658 struct port *port;
660 for (port = aggregator->lag_ports; port;
661 port = port->next_port_in_aggregator) {
663 port->sm_vars |= AD_PORT_READY;
665 port->sm_vars &= ~AD_PORT_READY;
671 struct port *port;
674 for (port = agg->lag_ports; port;
675 port = port->next_port_in_aggregator) {
676 if (port->is_enabled)
764 * __update_lacpdu_from_port - update a port's lacpdu fields
765 * @port: the port we're looking at
767 static inline void __update_lacpdu_from_port(struct port *port)
769 struct lacpdu *lacpdu = &port->lacpdu;
770 const struct port_params *partner = &port->partner_oper;
779 lacpdu->actor_system_priority = htons(port->actor_system_priority);
780 lacpdu->actor_system = port->actor_system;
781 lacpdu->actor_key = htons(port->actor_oper_port_key);
782 lacpdu->actor_port_priority = htons(port->actor_port_priority);
783 lacpdu->actor_port = htons(port->actor_port_number);
784 lacpdu->actor_state = port->actor_oper_port_state;
785 slave_dbg(port->slave->bond->dev, port->slave->dev,
786 "update lacpdu: actor port state %x\n",
787 port->actor_oper_port_state);
815 * ad_lacpdu_send - send out a lacpdu packet on a given port
816 * @port: the port we're looking at
821 static int ad_lacpdu_send(struct port *port)
823 struct slave *slave = port->slave;
850 lacpdu_header->lacpdu = port->lacpdu;
858 * ad_marker_send - send marker information/response on a given port
859 * @port: the port we're looking at
865 static int ad_marker_send(struct port *port, struct bond_marker *marker)
867 struct slave *slave = port->slave;
911 * ad_mux_machine - handle a port's mux state machine
912 * @port: the port we're looking at
915 static void ad_mux_machine(struct port *port, bool *update_slave_arr)
922 last_state = port->sm_mux_state;
924 if (port->sm_vars & AD_PORT_BEGIN) {
925 port->sm_mux_state = AD_MUX_DETACHED;
927 switch (port->sm_mux_state) {
929 if ((port->sm_vars & AD_PORT_SELECTED)
930 || (port->sm_vars & AD_PORT_STANDBY))
932 port->sm_mux_state = AD_MUX_WAITING;
936 if (!(port->sm_vars & AD_PORT_SELECTED)) {
937 port->sm_vars &= ~AD_PORT_READY_N;
943 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
944 port->sm_mux_state = AD_MUX_DETACHED;
949 if (port->sm_mux_timer_counter
950 && !(--port->sm_mux_timer_counter))
951 port->sm_vars |= AD_PORT_READY_N;
958 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
960 /* if the wait_while_timer expired, and the port is
963 if ((port->sm_vars & AD_PORT_READY)
964 && !port->sm_mux_timer_counter)
965 port->sm_mux_state = AD_MUX_ATTACHED;
969 * edable port will take place only after this timer)
971 if ((port->sm_vars & AD_PORT_SELECTED) &&
972 (port->partner_oper.port_state & LACP_STATE_SYNCHRONIZATION) &&
973 !__check_agg_selection_timer(port)) {
974 if (port->aggregator->is_active)
975 port->sm_mux_state =
977 } else if (!(port->sm_vars & AD_PORT_SELECTED) ||
978 (port->sm_vars & AD_PORT_STANDBY)) {
980 port->sm_vars &= ~AD_PORT_READY_N;
986 __set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
987 port->sm_mux_state = AD_MUX_DETACHED;
988 } else if (port->aggregator->is_active) {
989 port->actor_oper_port_state |=
994 if (!(port->sm_vars & AD_PORT_SELECTED) ||
995 (port->sm_vars & AD_PORT_STANDBY) ||
996 !(port->partner_oper.port_state & LACP_STATE_SYNCHRONIZATION) ||
997 !(port->actor_oper_port_state & LACP_STATE_SYNCHRONIZATION)) {
998 port->sm_mux_state = AD_MUX_ATTACHED;
1000 /* if port state hasn't changed make
1002 * port in an active aggregator is enabled
1004 if (port->aggregator &&
1005 port->aggregator->is_active &&
1006 !__port_is_enabled(port)) {
1007 __enable_port(port);
1018 if (port->sm_mux_state != last_state) {
1019 slave_dbg(port->slave->bond->dev, port->slave->dev,
1021 port->actor_port_number,
1023 port->sm_mux_state);
1024 switch (port->sm_mux_state) {
1026 port->actor_oper_port_state &= ~LACP_STATE_SYNCHRONIZATION;
1027 ad_disable_collecting_distributing(port,
1029 port->actor_oper_port_state &= ~LACP_STATE_COLLECTING;
1030 port->actor_oper_port_state &= ~LACP_STATE_DISTRIBUTING;
1031 port->ntt = true;
1034 port->sm_mux_timer_counter = __ad_timer_to_ticks(AD_WAIT_WHILE_TIMER, 0);
1037 if (port->aggregator->is_active)
1038 port->actor_oper_port_state |=
1041 port->actor_oper_port_state &=
1043 port->actor_oper_port_state &= ~LACP_STATE_COLLECTING;
1044 port->actor_oper_port_state &= ~LACP_STATE_DISTRIBUTING;
1045 ad_disable_collecting_distributing(port,
1047 port->ntt = true;
1050 port->actor_oper_port_state |= LACP_STATE_COLLECTING;
1051 port->actor_oper_port_state |= LACP_STATE_DISTRIBUTING;
1052 port->actor_oper_port_state |= LACP_STATE_SYNCHRONIZATION;
1053 ad_enable_collecting_distributing(port,
1055 port->ntt = true;
1064 * ad_rx_machine - handle a port's rx State Machine
1066 * @port: the port we're looking at
1072 static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port)
1079 last_state = port->sm_rx_state;
1082 atomic64_inc(&SLAVE_AD_INFO(port->slave)->stats.lacpdu_rx);
1083 atomic64_inc(&BOND_AD_INFO(port->slave->bond).stats.lacpdu_rx);
1087 /* first, check if port was reinitialized */
1088 if (port->sm_vars & AD_PORT_BEGIN) {
1089 port->sm_rx_state = AD_RX_INITIALIZE;
1090 port->sm_vars |= AD_PORT_CHURNED;
1091 /* check if port is not enabled */
1092 } else if (!(port->sm_vars & AD_PORT_BEGIN) && !port->is_enabled)
1093 port->sm_rx_state = AD_RX_PORT_DISABLED;
1095 else if (lacpdu && ((port->sm_rx_state == AD_RX_EXPIRED) ||
1096 (port->sm_rx_state == AD_RX_DEFAULTED) ||
1097 (port->sm_rx_state == AD_RX_CURRENT))) {
1098 if (port->sm_rx_state != AD_RX_CURRENT)
1099 port->sm_vars |= AD_PORT_CHURNED;
1100 port->sm_rx_timer_counter = 0;
1101 port->sm_rx_state = AD_RX_CURRENT;
1104 if (port->sm_rx_timer_counter &&
1105 !(--port->sm_rx_timer_counter)) {
1106 switch (port->sm_rx_state) {
1108 port->sm_rx_state = AD_RX_DEFAULTED;
1111 port->sm_rx_state = AD_RX_EXPIRED;
1118 switch (port->sm_rx_state) {
1120 if (port->is_enabled &&
1121 (port->sm_vars & AD_PORT_LACP_ENABLED))
1122 port->sm_rx_state = AD_RX_EXPIRED;
1123 else if (port->is_enabled
1124 && ((port->sm_vars
1126 port->sm_rx_state = AD_RX_LACP_DISABLED;
1136 if ((port->sm_rx_state != last_state) || (lacpdu)) {
1137 slave_dbg(port->slave->bond->dev, port->slave->dev,
1139 port->actor_port_number,
1141 port->sm_rx_state);
1142 switch (port->sm_rx_state) {
1144 if (!(port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS))
1145 port->sm_vars &= ~AD_PORT_LACP_ENABLED;
1147 port->sm_vars |= AD_PORT_LACP_ENABLED;
1148 port->sm_vars &= ~AD_PORT_SELECTED;
1149 __record_default(port);
1150 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1151 port->sm_rx_state = AD_RX_PORT_DISABLED;
1155 port->sm_vars &= ~AD_PORT_MATCHED;
1158 port->sm_vars &= ~AD_PORT_SELECTED;
1159 __record_default(port);
1160 port->partner_oper.port_state &= ~LACP_STATE_AGGREGATION;
1161 port->sm_vars |= AD_PORT_MATCHED;
1162 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1166 * This reset cause to disable this port in the
1169 * the port.
1171 port->partner_oper.port_state &= ~LACP_STATE_SYNCHRONIZATION;
1172 port->sm_vars &= ~AD_PORT_MATCHED;
1173 port->partner_oper.port_state |= LACP_STATE_LACP_TIMEOUT;
1174 port->partner_oper.port_state |= LACP_STATE_LACP_ACTIVITY;
1175 port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(AD_SHORT_TIMEOUT));
1176 port->actor_oper_port_state |= LACP_STATE_EXPIRED;
1177 port->sm_vars |= AD_PORT_CHURNED;
1180 __update_default_selected(port);
1181 __record_default(port);
1182 port->sm_vars |= AD_PORT_MATCHED;
1183 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1188 &(port->actor_system))) {
1189 slave_err(port->slave->bond->dev, port->slave->dev, "An illegal loopback occurred on slave\n"
1193 __update_selected(lacpdu, port);
1194 __update_ntt(lacpdu, port);
1195 __record_pdu(lacpdu, port);
1196 port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(port->actor_oper_port_state & LACP_STATE_LACP_TIMEOUT));
1197 port->actor_oper_port_state &= ~LACP_STATE_EXPIRED;
1206 * ad_churn_machine - handle port churn's state machine
1207 * @port: the port we're looking at
1210 static void ad_churn_machine(struct port *port)
1212 if (port->sm_vars & AD_PORT_CHURNED) {
1213 port->sm_vars &= ~AD_PORT_CHURNED;
1214 port->sm_churn_actor_state = AD_CHURN_MONITOR;
1215 port->sm_churn_partner_state = AD_CHURN_MONITOR;
1216 port->sm_churn_actor_timer_counter =
1218 port->sm_churn_partner_timer_counter =
1222 if (port->sm_churn_actor_timer_counter &&
1223 !(--port->sm_churn_actor_timer_counter) &&
1224 port->sm_churn_actor_state == AD_CHURN_MONITOR) {
1225 if (port->actor_oper_port_state & LACP_STATE_SYNCHRONIZATION) {
1226 port->sm_churn_actor_state = AD_NO_CHURN;
1228 port->churn_actor_count++;
1229 port->sm_churn_actor_state = AD_CHURN;
1232 if (port->sm_churn_partner_timer_counter &&
1233 !(--port->sm_churn_partner_timer_counter) &&
1234 port->sm_churn_partner_state == AD_CHURN_MONITOR) {
1235 if (port->partner_oper.port_state & LACP_STATE_SYNCHRONIZATION) {
1236 port->sm_churn_partner_state = AD_NO_CHURN;
1238 port->churn_partner_count++;
1239 port->sm_churn_partner_state = AD_CHURN;
1245 * ad_tx_machine - handle a port's tx state machine
1246 * @port: the port we're looking at
1248 static void ad_tx_machine(struct port *port)
1253 if (port->sm_tx_timer_counter && !(--port->sm_tx_timer_counter)) {
1255 if (port->ntt && (port->sm_vars & AD_PORT_LACP_ENABLED)) {
1256 __update_lacpdu_from_port(port);
1258 if (ad_lacpdu_send(port) >= 0) {
1259 slave_dbg(port->slave->bond->dev,
1260 port->slave->dev,
1261 "Sent LACPDU on port %d\n",
1262 port->actor_port_number);
1267 port->ntt = false;
1273 port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
1278 * ad_periodic_machine - handle a port's periodic state machine
1279 * @port: the port we're looking at
1283 static void ad_periodic_machine(struct port *port)
1288 last_state = port->sm_periodic_state;
1290 /* check if port was reinitialized */
1291 if (((port->sm_vars & AD_PORT_BEGIN) || !(port->sm_vars & AD_PORT_LACP_ENABLED) || !port->is_enabled) ||
1292 (!(port->actor_oper_port_state & LACP_STATE_LACP_ACTIVITY) && !(port->partner_oper.port_state & LACP_STATE_LACP_ACTIVITY))
1294 port->sm_periodic_state = AD_NO_PERIODIC;
1297 else if (port->sm_periodic_timer_counter) {
1299 if (!(--port->sm_periodic_timer_counter)) {
1301 port->sm_periodic_state = AD_PERIODIC_TX;
1306 switch (port->sm_periodic_state) {
1308 if (!(port->partner_oper.port_state
1310 port->sm_periodic_state = AD_SLOW_PERIODIC;
1313 if ((port->partner_oper.port_state & LACP_STATE_LACP_TIMEOUT)) {
1314 port->sm_periodic_timer_counter = 0;
1315 port->sm_periodic_state = AD_PERIODIC_TX;
1323 switch (port->sm_periodic_state) {
1325 port->sm_periodic_state = AD_FAST_PERIODIC;
1328 if (!(port->partner_oper.port_state &
1330 port->sm_periodic_state = AD_SLOW_PERIODIC;
1332 port->sm_periodic_state = AD_FAST_PERIODIC;
1340 if (port->sm_periodic_state != last_state) {
1341 slave_dbg(port->slave->bond->dev, port->slave->dev,
1343 port->actor_port_number, last_state,
1344 port->sm_periodic_state);
1345 switch (port->sm_periodic_state) {
1347 port->sm_periodic_timer_counter = 0;
1351 port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_FAST_PERIODIC_TIME))-1;
1355 port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_SLOW_PERIODIC_TIME))-1;
1358 port->ntt = true;
1368 * @port: the port we're looking at
1371 * Select aggregation groups, and assign each port for it's aggregetor. The
1375 static void ad_port_selection_logic(struct port *port, bool *update_slave_arr)
1378 struct port *last_port = NULL, *curr_port;
1384 /* if the port is already Selected, do nothing */
1385 if (port->sm_vars & AD_PORT_SELECTED)
1388 bond = __get_bond_by_port(port);
1390 /* if the port is connected to other aggregator, detach it */
1391 if (port->aggregator) {
1392 /* detach the port from its former aggregator */
1393 temp_aggregator = port->aggregator;
1397 if (curr_port == port) {
1399 /* if it is the first port attached to the
1404 port->next_port_in_aggregator;
1406 /* not the first port attached to the
1410 port->next_port_in_aggregator;
1413 /* clear the port's relations to this
1416 port->aggregator = NULL;
1417 port->next_port_in_aggregator = NULL;
1418 port->actor_port_aggregator_identifier = 0;
1420 slave_dbg(bond->dev, port->slave->dev, "Port %d left LAG %d\n",
1421 port->actor_port_number,
1432 /* meaning: the port was related to an aggregator
1433 * but was not on the aggregator port list
1435 net_warn_ratelimited("%s: (slave %s): Warning: Port %d was related to aggregator %d but was not on its port list\n",
1436 port->slave->bond->dev->name,
1437 port->slave->dev->name,
1438 port->actor_port_number,
1439 port->aggregator->aggregator_identifier);
1442 /* search on all aggregators for a suitable aggregator for this port */
1453 if (((aggregator->actor_oper_aggregator_key == port->actor_oper_port_key) && /* if all parameters match AND */
1454 MAC_ADDRESS_EQUAL(&(aggregator->partner_system), &(port->partner_oper.system)) &&
1455 (aggregator->partner_system_priority == port->partner_oper.system_priority) &&
1456 (aggregator->partner_oper_aggregator_key == port->partner_oper.key)
1458 ((!MAC_ADDRESS_EQUAL(&(port->partner_oper.system), &(null_mac_addr)) && /* partner answers */
1463 port->aggregator = aggregator;
1464 port->actor_port_aggregator_identifier =
1465 port->aggregator->aggregator_identifier;
1466 port->next_port_in_aggregator = aggregator->lag_ports;
1467 port->aggregator->num_of_ports++;
1468 aggregator->lag_ports = port;
1470 port->actor_port_number,
1471 port->aggregator->aggregator_identifier);
1473 /* mark this port as selected */
1474 port->sm_vars |= AD_PORT_SELECTED;
1480 /* the port couldn't find an aggregator - attach it to a new
1485 /* assign port a new aggregator */
1486 port->aggregator = free_aggregator;
1487 port->actor_port_aggregator_identifier =
1488 port->aggregator->aggregator_identifier;
1491 * if port was responsed from the end-user
1493 if (port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS)
1494 /* if port is full duplex */
1495 port->aggregator->is_individual = false;
1497 port->aggregator->is_individual = true;
1499 port->aggregator->actor_admin_aggregator_key =
1500 port->actor_admin_port_key;
1501 port->aggregator->actor_oper_aggregator_key =
1502 port->actor_oper_port_key;
1503 port->aggregator->partner_system =
1504 port->partner_oper.system;
1505 port->aggregator->partner_system_priority =
1506 port->partner_oper.system_priority;
1507 port->aggregator->partner_oper_aggregator_key = port->partner_oper.key;
1508 port->aggregator->receive_state = 1;
1509 port->aggregator->transmit_state = 1;
1510 port->aggregator->lag_ports = port;
1511 port->aggregator->num_of_ports++;
1513 /* mark this port as selected */
1514 port->sm_vars |= AD_PORT_SELECTED;
1516 slave_dbg(bond->dev, port->slave->dev, "Port %d joined LAG %d (new LAG)\n",
1517 port->actor_port_number,
1518 port->aggregator->aggregator_identifier);
1520 slave_err(bond->dev, port->slave->dev,
1522 port->actor_port_number);
1529 __set_agg_ports_ready(port->aggregator,
1530 __agg_ports_are_ready(port->aggregator));
1532 aggregator = __get_first_agg(port);
1535 if (!port->aggregator->is_active)
1536 port->actor_oper_port_state &= ~LACP_STATE_SYNCHRONIZATION;
1613 struct port *port = agg->lag_ports;
1615 if (!port)
1618 for (port = agg->lag_ports; port;
1619 port = port->next_port_in_aggregator) {
1620 if (netif_running(port->slave->dev) &&
1621 netif_carrier_ok(port->slave->dev))
1661 struct port *port;
1744 for (port = active->lag_ports; port;
1745 port = port->next_port_in_aggregator) {
1746 __disable_port(port);
1760 for (port = active->lag_ports; port;
1761 port = port->next_port_in_aggregator) {
1762 __enable_port(port);
1814 * ad_initialize_port - initialize a given port's parameters
1815 * @port: the port we're looking at
1818 static void ad_initialize_port(struct port *port, int lacp_fast)
1839 if (port) {
1840 port->actor_port_priority = 0xff;
1841 port->actor_port_aggregator_identifier = 0;
1842 port->ntt = false;
1843 port->actor_admin_port_state = LACP_STATE_AGGREGATION |
1845 port->actor_oper_port_state = LACP_STATE_AGGREGATION |
1849 port->actor_oper_port_state |= LACP_STATE_LACP_TIMEOUT;
1851 memcpy(&port->partner_admin, &tmpl, sizeof(tmpl));
1852 memcpy(&port->partner_oper, &tmpl, sizeof(tmpl));
1854 port->is_enabled = true;
1856 port->sm_vars = AD_PORT_BEGIN | AD_PORT_LACP_ENABLED;
1857 port->sm_rx_state = 0;
1858 port->sm_rx_timer_counter = 0;
1859 port->sm_periodic_state = 0;
1860 port->sm_periodic_timer_counter = 0;
1861 port->sm_mux_state = 0;
1862 port->sm_mux_timer_counter = 0;
1863 port->sm_tx_state = 0;
1864 port->aggregator = NULL;
1865 port->next_port_in_aggregator = NULL;
1866 port->transaction_id = 0;
1868 port->sm_churn_actor_timer_counter = 0;
1869 port->sm_churn_actor_state = 0;
1870 port->churn_actor_count = 0;
1871 port->sm_churn_partner_timer_counter = 0;
1872 port->sm_churn_partner_state = 0;
1873 port->churn_partner_count = 0;
1875 memcpy(&port->lacpdu, &lacpdu, sizeof(lacpdu));
1880 * ad_enable_collecting_distributing - enable a port's transmit/receive
1881 * @port: the port we're looking at
1884 * Enable @port if it's in an active aggregator
1886 static void ad_enable_collecting_distributing(struct port *port,
1889 if (port->aggregator->is_active) {
1890 slave_dbg(port->slave->bond->dev, port->slave->dev,
1891 "Enabling port %d (LAG %d)\n",
1892 port->actor_port_number,
1893 port->aggregator->aggregator_identifier);
1894 __enable_port(port);
1901 * ad_disable_collecting_distributing - disable a port's transmit/receive
1902 * @port: the port we're looking at
1905 static void ad_disable_collecting_distributing(struct port *port,
1908 if (port->aggregator &&
1909 !MAC_ADDRESS_EQUAL(&(port->aggregator->partner_system),
1911 slave_dbg(port->slave->bond->dev, port->slave->dev,
1912 "Disabling port %d (LAG %d)\n",
1913 port->actor_port_number,
1914 port->aggregator->aggregator_identifier);
1915 __disable_port(port);
1924 * @port: the port we're looking at
1927 struct port *port)
1931 atomic64_inc(&SLAVE_AD_INFO(port->slave)->stats.marker_rx);
1932 atomic64_inc(&BOND_AD_INFO(port->slave->bond).stats.marker_rx);
1940 if (ad_marker_send(port, &marker) >= 0)
1941 slave_dbg(port->slave->bond->dev, port->slave->dev,
1942 "Sent Marker Response on port %d\n",
1943 port->actor_port_number);
1949 * @port: the port we're looking at
1956 struct port *port)
1958 atomic64_inc(&SLAVE_AD_INFO(port->slave)->stats.marker_resp_rx);
1959 atomic64_inc(&BOND_AD_INFO(port->slave->bond).stats.marker_resp_rx);
2013 * bond_3ad_bind_slave - initialize a slave's port
2022 struct port *port;
2026 if (SLAVE_AD_INFO(slave)->port.slave != slave) {
2028 /* port initialization */
2029 port = &(SLAVE_AD_INFO(slave)->port);
2031 ad_initialize_port(port, bond->params.lacp_fast);
2033 port->slave = slave;
2034 port->actor_port_number = SLAVE_AD_INFO(slave)->id;
2038 port->actor_admin_port_key = bond->params.ad_user_port_key << 6;
2039 ad_update_actor_keys(port, false);
2041 __ad_actor_update_port(port);
2045 port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
2047 __disable_port(port);
2063 * bond_3ad_unbind_slave - deinitialize a slave's port
2066 * Search for the aggregator that is related to this port, remove the
2067 * aggregator and assign another aggregator for other port related to it
2068 * (if any), and remove the port.
2072 struct port *port, *prev_port, *temp_port;
2083 port = &(SLAVE_AD_INFO(slave)->port);
2085 /* if slave is null, the whole port is not initialized */
2086 if (!port->slave) {
2087 slave_warn(bond->dev, slave->dev, "Trying to unbind an uninitialized port\n");
2094 /* Tell the partner that this port is not suitable for aggregation */
2095 port->actor_oper_port_state &= ~LACP_STATE_SYNCHRONIZATION;
2096 port->actor_oper_port_state &= ~LACP_STATE_COLLECTING;
2097 port->actor_oper_port_state &= ~LACP_STATE_DISTRIBUTING;
2098 port->actor_oper_port_state &= ~LACP_STATE_AGGREGATION;
2099 __update_lacpdu_from_port(port);
2100 ad_lacpdu_send(port);
2105 * except the port related to this slave(thats ensure us that
2109 if ((aggregator->lag_ports != port) ||
2111 /* find new aggregator for the related port(s) */
2115 * connected to our port only
2118 ((new_aggregator->lag_ports == port) &&
2129 if ((new_aggregator) && ((!new_aggregator->lag_ports) || ((new_aggregator->lag_ports == port) && !new_aggregator->lag_ports->next_port_in_aggregator))) {
2130 slave_dbg(bond->dev, slave->dev, "Some port(s) related to LAG %d - replacing with LAG %d\n",
2134 if ((new_aggregator->lag_ports == port) &&
2164 ad_agg_selection_logic(__get_first_agg(port),
2170 /* in case that the only port related to this
2178 temp_aggregator = __get_first_agg(port);
2186 slave_dbg(bond->dev, slave->dev, "Unbinding port %d\n", port->actor_port_number);
2188 /* find the aggregator that this port is connected to */
2192 /* search the port in the aggregator's related ports */
2196 if (temp_port == port) {
2197 /* the aggregator found - detach the port from
2212 ad_agg_selection_logic(__get_first_agg(port),
2220 port->slave = NULL;
2230 * If an ad_actor setting gets changed we need to update the individual port
2250 struct port *port = &(SLAVE_AD_INFO(slave))->port;
2252 __ad_actor_update_port(port);
2253 port->ntt = true;
2300 struct port *port;
2304 /* Lock to protect data accessed by all (e.g., port->sm_vars) and
2317 port = slave ? &(SLAVE_AD_INFO(slave)->port) : NULL;
2320 if (port) {
2321 if (!port->slave) {
2322 net_warn_ratelimited("%s: Warning: bond's first port is uninitialized\n",
2327 aggregator = __get_first_agg(port);
2333 /* for each port run the state machines */
2335 port = &(SLAVE_AD_INFO(slave)->port);
2336 if (!port->slave) {
2337 net_warn_ratelimited("%s: Warning: Found an uninitialized port\n",
2342 ad_rx_machine(NULL, port);
2343 ad_periodic_machine(port);
2344 ad_port_selection_logic(port, &update_slave_arr);
2345 ad_mux_machine(port, &update_slave_arr);
2346 ad_tx_machine(port);
2347 ad_churn_machine(port);
2350 if (port->sm_vars & AD_PORT_BEGIN)
2351 port->sm_vars &= ~AD_PORT_BEGIN;
2388 struct port *port;
2391 port = &(SLAVE_AD_INFO(slave)->port);
2392 if (!port->slave) {
2393 net_warn_ratelimited("%s: Warning: port of slave %s is uninitialized\n",
2402 "Received LACPDU on port %d\n",
2403 port->actor_port_number);
2406 ad_rx_machine(lacpdu, port);
2417 slave_dbg(slave->bond->dev, slave->dev, "Received Marker Information on port %d\n",
2418 port->actor_port_number);
2419 ad_marker_info_received(marker, port);
2422 slave_dbg(slave->bond->dev, slave->dev, "Received Marker Response on port %d\n",
2423 port->actor_port_number);
2424 ad_marker_response_received(marker, port);
2427 slave_dbg(slave->bond->dev, slave->dev, "Received an unknown Marker subtype on port %d\n",
2428 port->actor_port_number);
2444 * ad_update_actor_keys - Update the oper / admin keys for a port based on
2447 * @port: the port we'are looking at
2451 * (a) A full duplex port can participate in LACP with partner.
2454 static void ad_update_actor_keys(struct port *port, bool reset)
2458 u16 old_oper_key = port->actor_oper_port_key;
2460 port->actor_admin_port_key &= ~(AD_SPEED_KEY_MASKS|AD_DUPLEX_KEY_MASKS);
2462 speed = __get_link_speed(port);
2464 duplex = __get_duplex(port);
2465 port->actor_admin_port_key |= (speed << 1) | duplex;
2467 port->actor_oper_port_key = port->actor_admin_port_key;
2469 if (old_oper_key != port->actor_oper_port_key) {
2470 /* Only 'duplex' port participates in LACP */
2472 port->sm_vars |= AD_PORT_LACP_ENABLED;
2474 port->sm_vars &= ~AD_PORT_LACP_ENABLED;
2478 slave_err(port->slave->bond->dev,
2479 port->slave->dev,
2480 "speed changed to 0 on port %d\n",
2481 port->actor_port_number);
2484 port->sm_vars |= AD_PORT_BEGIN;
2496 * Handle reselection of aggregator (if needed) for this port.
2500 struct port *port;
2502 port = &(SLAVE_AD_INFO(slave)->port);
2504 /* if slave is null, the whole port is not initialized */
2505 if (!port->slave) {
2507 "speed/duplex changed for uninitialized port\n");
2512 ad_update_actor_keys(port, false);
2515 port->actor_port_number);
2523 * Handle reselection of aggregator (if needed) for this port.
2528 struct port *port;
2531 port = &(SLAVE_AD_INFO(slave)->port);
2533 /* if slave is null, the whole port is not initialized */
2534 if (!port->slave) {
2535 slave_warn(slave->bond->dev, slave->dev, "link status changed for uninitialized port\n");
2548 port->is_enabled = true;
2549 ad_update_actor_keys(port, false);
2552 port->is_enabled = false;
2553 ad_update_actor_keys(port, true);
2555 agg = __get_first_agg(port);
2561 port->actor_port_number,
2629 struct port *port;
2632 port = &(SLAVE_AD_INFO(slave)->port);
2633 if (port->aggregator && port->aggregator->is_active) {
2634 aggregator = port->aggregator;
2688 * update actor_oper_port_state of each port.
2691 * so we can modify port->actor_oper_port_state,
2696 struct port *port = NULL;
2704 port = &(SLAVE_AD_INFO(slave)->port);
2706 port->actor_oper_port_state |= LACP_STATE_LACP_TIMEOUT;
2708 port->actor_oper_port_state &= ~LACP_STATE_LACP_TIMEOUT;