Lines Matching defs:lp
232 struct lacp_port *lp = LACP_PORT(lgp);
243 lacp_pdu_input(lp, m);
247 lacp_marker_input(lp, m);
259 lacp_pdu_input(struct lacp_port *lp, struct mbuf *m)
261 struct lacp_softc *lsc = lp->lp_lsc;
307 lacp_dprintf(lp, "lacpdu receive\n");
311 if ((1 << lp->lp_ifp->if_dunit) & lp->lp_lsc->lsc_debug.lsc_rx_test) {
312 LACP_TPRINTF((lp, "Dropping RX PDU\n"));
317 lacp_sm_rx(lp, du);
329 lacp_fill_actorinfo(struct lacp_port *lp, struct lacp_peerinfo *info)
331 struct lagg_port *lgp = lp->lp_lagg;
338 info->lip_portid.lpi_portno = htons(lp->lp_ifp->if_index);
339 info->lip_state = lp->lp_state;
343 lacp_fill_markerinfo(struct lacp_port *lp, struct lacp_markerinfo *info)
345 struct ifnet *ifp = lp->lp_ifp;
349 memcpy(&info->mi_rq_system, lp->lp_systemid.lsi_mac, ETHER_ADDR_LEN);
354 lacp_xmit_lacpdu(struct lacp_port *lp)
356 struct lagg_port *lgp = lp->lp_lagg;
361 LACP_LOCK_ASSERT(lp->lp_lsc);
381 du->ldu_actor = lp->lp_actor;
385 du->ldu_partner = lp->lp_partner;
392 lacp_dprintf(lp, "lacpdu transmit\n");
403 error = lagg_enqueue(lp->lp_ifp, m);
408 lacp_xmit_marker(struct lacp_port *lp)
410 struct lagg_port *lgp = lp->lp_lagg;
415 LACP_LOCK_ASSERT(lp->lp_lsc);
435 lp->lp_marker.mi_rq_xid = htonl(ntohl(lp->lp_marker.mi_rq_xid) + 1);
437 mdu->mdu_info = lp->lp_marker;
439 LACP_DPRINTF((lp, "marker transmit, port=%u, sys=%6D, id=%u\n",
444 error = lagg_enqueue(lp->lp_ifp, m);
451 struct lacp_port *lp = LACP_PORT(lgp);
452 struct lacp_softc *lsc = lp->lp_lsc;
467 LACP_DPRINTF((lp, "media changed 0x%x -> 0x%x, ether = %d, fdx = %d, "
468 "link = %d\n", lp->lp_media, media, IFM_TYPE(media) == IFM_ETHER,
470 old_state = lp->lp_state;
471 old_key = lp->lp_key;
473 lp->lp_media = media;
480 lacp_port_disable(lp);
482 lacp_port_enable(lp);
484 lp->lp_key = lacp_compose_key(lp);
486 if (old_state != lp->lp_state || old_key != lp->lp_key) {
487 LACP_DPRINTF((lp, "-> UNSELECTED\n"));
488 lp->lp_selected = LACP_UNSELECTED;
497 struct lacp_port *lp;
499 LIST_FOREACH(lp, &lsc->lsc_ports, lp_next) {
500 if ((lp->lp_state & LACP_STATE_AGGREGATION) == 0)
503 CURVNET_SET(lp->lp_ifp->if_vnet);
504 lacp_run_timers(lp);
506 lacp_select(lp);
507 lacp_sm_mux(lp);
508 lacp_sm_tx(lp);
509 lacp_sm_ptx_tx_schedule(lp);
520 struct lacp_port *lp;
541 lp = malloc(sizeof(struct lacp_port),
543 if (lp == NULL)
547 lgp->lp_psc = (caddr_t)lp;
548 lp->lp_ifp = ifp;
549 lp->lp_lagg = lgp;
550 lp->lp_lsc = lsc;
551 lp->lp_ifma = rifma;
553 LIST_INSERT_HEAD(&lsc->lsc_ports, lp, lp_next);
555 lacp_fill_actorinfo(lp, &lp->lp_actor);
556 lacp_fill_markerinfo(lp, &lp->lp_marker);
557 lp->lp_state = LACP_STATE_ACTIVITY;
558 lp->lp_aggregator = NULL;
559 lacp_sm_rx_set_expired(lp);
569 struct lacp_port *lp = LACP_PORT(lgp);
570 struct lacp_softc *lsc = lp->lp_lsc;
575 LACP_TIMER_DISARM(lp, i);
578 lacp_disable_collecting(lp);
579 lacp_disable_distributing(lp);
580 lacp_unselect(lp);
582 LIST_REMOVE(lp, lp_next);
587 if_delmulti_ifma(lp->lp_ifma);
589 free(lp, M_DEVBUF);
635 struct lacp_port *lp = LACP_PORT(lgp);
636 struct lacp_softc *lsc = lp->lp_lsc;
639 req->actor_prio = ntohs(lp->lp_actor.lip_systemid.lsi_prio);
640 memcpy(&req->actor_mac, &lp->lp_actor.lip_systemid.lsi_mac,
642 req->actor_key = ntohs(lp->lp_actor.lip_key);
643 req->actor_portprio = ntohs(lp->lp_actor.lip_portid.lpi_prio);
644 req->actor_portno = ntohs(lp->lp_actor.lip_portid.lpi_portno);
645 req->actor_state = lp->lp_actor.lip_state;
647 req->partner_prio = ntohs(lp->lp_partner.lip_systemid.lsi_prio);
648 memcpy(&req->partner_mac, &lp->lp_partner.lip_systemid.lsi_mac,
650 req->partner_key = ntohs(lp->lp_partner.lip_key);
651 req->partner_portprio = ntohs(lp->lp_partner.lip_portid.lpi_prio);
652 req->partner_portno = ntohs(lp->lp_partner.lip_portid.lpi_portno);
653 req->partner_state = lp->lp_partner.lip_state;
658 lacp_disable_collecting(struct lacp_port *lp)
660 LACP_DPRINTF((lp, "collecting disabled\n"));
661 lp->lp_state &= ~LACP_STATE_COLLECTING;
665 lacp_enable_collecting(struct lacp_port *lp)
667 LACP_DPRINTF((lp, "collecting enabled\n"));
668 lp->lp_state |= LACP_STATE_COLLECTING;
672 lacp_disable_distributing(struct lacp_port *lp)
674 struct lacp_aggregator *la = lp->lp_aggregator;
675 struct lacp_softc *lsc = lp->lp_lsc;
681 if (la == NULL || (lp->lp_state & LACP_STATE_DISTRIBUTING) == 0) {
689 LACP_DPRINTF((lp, "disable distributing on aggregator %s, "
694 TAILQ_REMOVE(&la->la_ports, lp, lp_dist_q);
705 lp->lp_state &= ~LACP_STATE_DISTRIBUTING;
709 lacp_enable_distributing(struct lacp_port *lp)
711 struct lacp_aggregator *la = lp->lp_aggregator;
712 struct lacp_softc *lsc = lp->lp_lsc;
718 if ((lp->lp_state & LACP_STATE_DISTRIBUTING) != 0) {
722 LACP_DPRINTF((lp, "enable distributing on aggregator %s, "
728 TAILQ_INSERT_HEAD(&la->la_ports, lp, lp_dist_q);
732 lp->lp_state |= LACP_STATE_DISTRIBUTING;
825 struct lacp_port *lp;
845 lp = pm->pm_map[hash];
847 KASSERT((lp->lp_state & LACP_STATE_DISTRIBUTING) != 0,
850 return (lp->lp_lagg);
860 struct lacp_port *lp;
871 LIST_FOREACH(lp, &lsc->lsc_ports, lp_next) {
872 lp->lp_flags |= LACP_PORT_MARK;
873 lacp_xmit_marker(lp);
907 struct lacp_port *lp;
910 lp = TAILQ_FIRST(&la->la_ports);
911 if (lp == NULL) {
915 speed = ifmedia_baudrate(lp->lp_media);
918 LACP_DPRINTF((lp, "speed 0? media=0x%x nports=%d\n",
919 lp->lp_media, la->la_nports));
1002 struct lacp_port *lp;
1016 TAILQ_FOREACH(lp, &la->la_ports, lp_dist_q)
1017 p->pm_map[i++] = lp;
1031 lacp_compose_key(struct lacp_port *lp)
1033 struct lagg_port *lgp = lp->lp_lagg;
1035 u_int media = lp->lp_media;
1038 if ((lp->lp_state & LACP_STATE_AGGREGATION) == 0) {
1047 key = lp->lp_ifp->if_index;
1194 lacp_aggregator_get(struct lacp_softc *lsc, struct lacp_port *lp)
1215 lacp_fill_aggregator_id(struct lacp_aggregator *la, const struct lacp_port *lp)
1217 lacp_fill_aggregator_id_peer(&la->la_partner, &lp->lp_partner);
1218 lacp_fill_aggregator_id_peer(&la->la_actor, &lp->lp_actor);
1220 la->la_actor.lip_state = lp->lp_state & LACP_STATE_AGGREGATION;
1238 const struct lacp_port *lp)
1240 if (!(lp->lp_state & LACP_STATE_AGGREGATION) ||
1241 !(lp->lp_partner.lip_state & LACP_STATE_AGGREGATION)) {
1249 if (!lacp_peerinfo_is_compatible(&la->la_partner, &lp->lp_partner)) {
1253 if (!lacp_peerinfo_is_compatible(&la->la_actor, &lp->lp_actor)) {
1277 lacp_port_enable(struct lacp_port *lp)
1279 lp->lp_state |= LACP_STATE_AGGREGATION;
1283 lacp_port_disable(struct lacp_port *lp)
1285 lacp_set_mux(lp, LACP_MUX_DETACHED);
1287 lp->lp_state &= ~LACP_STATE_AGGREGATION;
1288 lp->lp_selected = LACP_UNSELECTED;
1289 lacp_sm_rx_record_default(lp);
1290 lp->lp_partner.lip_state &= ~LACP_STATE_AGGREGATION;
1291 lp->lp_state &= ~LACP_STATE_EXPIRED;
1298 lacp_select(struct lacp_port *lp)
1300 struct lacp_softc *lsc = lp->lp_lsc;
1304 if (lp->lp_aggregator) {
1308 KASSERT(!LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE),
1311 LACP_DPRINTF((lp, "port lagid=%s\n",
1312 lacp_format_lagid(&lp->lp_actor, &lp->lp_partner,
1316 if (lacp_aggregator_is_compatible(la, lp)) {
1322 la = lacp_aggregator_get(lsc, lp);
1324 LACP_DPRINTF((lp, "aggregator creation failed\n"));
1332 lacp_fill_aggregator_id(la, lp);
1333 LACP_DPRINTF((lp, "aggregator created\n"));
1335 LACP_DPRINTF((lp, "compatible aggregator found\n"));
1341 LACP_DPRINTF((lp, "aggregator lagid=%s\n",
1345 lp->lp_aggregator = la;
1346 lp->lp_selected = LACP_SELECTED;
1354 lacp_unselect(struct lacp_port *lp)
1356 struct lacp_softc *lsc = lp->lp_lsc;
1357 struct lacp_aggregator *la = lp->lp_aggregator;
1359 KASSERT(!LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE),
1366 lp->lp_aggregator = NULL;
1373 lacp_sm_mux(struct lacp_port *lp)
1375 struct lagg_port *lgp = lp->lp_lagg;
1379 (lp->lp_partner.lip_state & LACP_STATE_SYNC) != 0;
1381 (lp->lp_partner.lip_state & LACP_STATE_COLLECTING) != 0;
1382 enum lacp_selected selected = lp->lp_selected;
1386 lacp_dprintf(lp, "%s: state= 0x%x, selected= 0x%x, "
1388 lp->lp_mux_state, selected, p_sync, p_collecting);
1391 la = lp->lp_aggregator;
1392 KASSERT(lp->lp_mux_state == LACP_MUX_DETACHED || la != NULL,
1394 new_state = lp->lp_mux_state;
1395 switch (lp->lp_mux_state) {
1403 !LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE),
1428 lacp_dprintf(lp, "Interface stopped DISTRIBUTING, possible flapping\n");
1436 if (lp->lp_mux_state == new_state) {
1440 lacp_set_mux(lp, new_state);
1445 lacp_set_mux(struct lacp_port *lp, enum lacp_mux_state new_state)
1447 struct lacp_aggregator *la = lp->lp_aggregator;
1449 if (lp->lp_mux_state == new_state) {
1455 lp->lp_state &= ~LACP_STATE_SYNC;
1456 lacp_disable_distributing(lp);
1457 lacp_disable_collecting(lp);
1458 lacp_sm_assert_ntt(lp);
1460 if (LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE)) {
1465 LACP_TIMER_DISARM(lp, LACP_TIMER_WAIT_WHILE);
1466 lacp_unselect(lp);
1469 LACP_TIMER_ARM(lp, LACP_TIMER_WAIT_WHILE,
1474 lp->lp_state |= LACP_STATE_SYNC;
1475 lacp_disable_collecting(lp);
1476 lacp_sm_assert_ntt(lp);
1479 lacp_enable_collecting(lp);
1480 lacp_disable_distributing(lp);
1481 lacp_sm_assert_ntt(lp);
1484 lacp_enable_distributing(lp);
1490 LACP_DPRINTF((lp, "mux_state %d -> %d\n", lp->lp_mux_state, new_state));
1492 lp->lp_mux_state = new_state;
1496 lacp_sm_mux_timer(struct lacp_port *lp)
1498 struct lacp_aggregator *la = lp->lp_aggregator;
1503 LACP_DPRINTF((lp, "%s: aggregator %s, pending %d -> %d\n", __func__,
1514 lacp_sm_ptx_update_timeout(struct lacp_port *lp, uint8_t oldpstate)
1516 if (LACP_STATE_EQ(oldpstate, lp->lp_partner.lip_state,
1521 LACP_DPRINTF((lp, "partner timeout changed\n"));
1531 LACP_TIMER_DISARM(lp, LACP_TIMER_PERIODIC);
1537 if ((lp->lp_partner.lip_state & LACP_STATE_TIMEOUT)) {
1538 lacp_sm_assert_ntt(lp);
1543 lacp_sm_ptx_tx_schedule(struct lacp_port *lp)
1547 if (!(lp->lp_state & LACP_STATE_ACTIVITY) &&
1548 !(lp->lp_partner.lip_state & LACP_STATE_ACTIVITY)) {
1554 LACP_TIMER_DISARM(lp, LACP_TIMER_PERIODIC);
1558 if (LACP_TIMER_ISARMED(lp, LACP_TIMER_PERIODIC)) {
1562 timeout = (lp->lp_partner.lip_state & LACP_STATE_TIMEOUT) ?
1565 LACP_TIMER_ARM(lp, LACP_TIMER_PERIODIC, timeout);
1569 lacp_sm_ptx_timer(struct lacp_port *lp)
1571 lacp_sm_assert_ntt(lp);
1575 lacp_sm_rx(struct lacp_port *lp, const struct lacpdu *du)
1583 if (!(lp->lp_state & LACP_STATE_AGGREGATION)) {
1592 &lp->lp_actor.lip_systemid)) {
1600 lacp_sm_rx_update_selected(lp, du);
1601 lacp_sm_rx_update_ntt(lp, du);
1602 lacp_sm_rx_record_pdu(lp, du);
1604 timeout = (lp->lp_state & LACP_STATE_TIMEOUT) ?
1606 LACP_TIMER_ARM(lp, LACP_TIMER_CURRENT_WHILE, timeout);
1608 lp->lp_state &= ~LACP_STATE_EXPIRED;
1614 lacp_sm_tx(lp);
1618 lacp_sm_rx_set_expired(struct lacp_port *lp)
1620 lp->lp_partner.lip_state &= ~LACP_STATE_SYNC;
1621 lp->lp_partner.lip_state |= LACP_STATE_TIMEOUT;
1622 LACP_TIMER_ARM(lp, LACP_TIMER_CURRENT_WHILE, LACP_SHORT_TIMEOUT_TIME);
1623 lp->lp_state |= LACP_STATE_EXPIRED;
1627 lacp_sm_rx_timer(struct lacp_port *lp)
1629 if ((lp->lp_state & LACP_STATE_EXPIRED) == 0) {
1631 LACP_DPRINTF((lp, "%s: CURRENT -> EXPIRED\n", __func__));
1632 lacp_sm_rx_set_expired(lp);
1635 LACP_DPRINTF((lp, "%s: EXPIRED -> DEFAULTED\n", __func__));
1636 lacp_sm_rx_update_default_selected(lp);
1637 lacp_sm_rx_record_default(lp);
1638 lp->lp_state &= ~LACP_STATE_EXPIRED;
1643 lacp_sm_rx_record_pdu(struct lacp_port *lp, const struct lacpdu *du)
1649 LACP_TRACE(lp);
1651 oldpstate = lp->lp_partner.lip_state;
1654 || ((lp->lp_state & LACP_STATE_ACTIVITY) &&
1657 lp->lp_partner = du->ldu_actor;
1659 ((LACP_STATE_EQ(lp->lp_state, du->ldu_partner.lip_state,
1661 !lacp_compare_peerinfo(&lp->lp_actor, &du->ldu_partner))
1665 lp->lp_partner.lip_state &= ~LACP_STATE_SYNC;
1668 lp->lp_state &= ~LACP_STATE_DEFAULTED;
1670 if (oldpstate != lp->lp_partner.lip_state) {
1671 LACP_DPRINTF((lp, "old pstate %s\n",
1673 LACP_DPRINTF((lp, "new pstate %s\n",
1674 lacp_format_state(lp->lp_partner.lip_state, buf,
1679 if (lp->lp_lsc->lsc_strict_mode)
1680 lp->lp_partner.lip_state |= LACP_STATE_SYNC;
1682 lacp_sm_ptx_update_timeout(lp, oldpstate);
1686 lacp_sm_rx_update_ntt(struct lacp_port *lp, const struct lacpdu *du)
1689 LACP_TRACE(lp);
1691 if (lacp_compare_peerinfo(&lp->lp_actor, &du->ldu_partner) ||
1692 !LACP_STATE_EQ(lp->lp_state, du->ldu_partner.lip_state,
1694 LACP_DPRINTF((lp, "%s: assert ntt\n", __func__));
1695 lacp_sm_assert_ntt(lp);
1700 lacp_sm_rx_record_default(struct lacp_port *lp)
1704 LACP_TRACE(lp);
1706 oldpstate = lp->lp_partner.lip_state;
1707 if (lp->lp_lsc->lsc_strict_mode)
1708 lp->lp_partner = lacp_partner_admin_strict;
1710 lp->lp_partner = lacp_partner_admin_optimistic;
1711 lp->lp_state |= LACP_STATE_DEFAULTED;
1712 lacp_sm_ptx_update_timeout(lp, oldpstate);
1716 lacp_sm_rx_update_selected_from_peerinfo(struct lacp_port *lp,
1720 LACP_TRACE(lp);
1722 if (lacp_compare_peerinfo(&lp->lp_partner, info) ||
1723 !LACP_STATE_EQ(lp->lp_partner.lip_state, info->lip_state,
1725 lp->lp_selected = LACP_UNSELECTED;
1726 /* mux machine will clean up lp->lp_aggregator */
1731 lacp_sm_rx_update_selected(struct lacp_port *lp, const struct lacpdu *du)
1734 LACP_TRACE(lp);
1736 lacp_sm_rx_update_selected_from_peerinfo(lp, &du->ldu_actor);
1740 lacp_sm_rx_update_default_selected(struct lacp_port *lp)
1743 LACP_TRACE(lp);
1745 if (lp->lp_lsc->lsc_strict_mode)
1746 lacp_sm_rx_update_selected_from_peerinfo(lp,
1749 lacp_sm_rx_update_selected_from_peerinfo(lp,
1756 lacp_sm_tx(struct lacp_port *lp)
1760 if (!(lp->lp_state & LACP_STATE_AGGREGATION)
1762 || (!(lp->lp_state & LACP_STATE_ACTIVITY)
1763 && !(lp->lp_partner.lip_state & LACP_STATE_ACTIVITY))
1766 lp->lp_flags &= ~LACP_PORT_NTT;
1769 if (!(lp->lp_flags & LACP_PORT_NTT)) {
1774 if (ppsratecheck(&lp->lp_last_lacpdu, &lp->lp_lacpdu_sent,
1776 LACP_DPRINTF((lp, "rate limited pdu\n"));
1780 if (((1 << lp->lp_ifp->if_dunit) & lp->lp_lsc->lsc_debug.lsc_tx_test) == 0) {
1781 error = lacp_xmit_lacpdu(lp);
1783 LACP_TPRINTF((lp, "Dropping TX PDU\n"));
1787 lp->lp_flags &= ~LACP_PORT_NTT;
1789 LACP_DPRINTF((lp, "lacpdu transmit failure, error %d\n",
1795 lacp_sm_assert_ntt(struct lacp_port *lp)
1798 lp->lp_flags |= LACP_PORT_NTT;
1802 lacp_run_timers(struct lacp_port *lp)
1807 KASSERT(lp->lp_timer[i] >= 0,
1808 ("invalid timer value %d", lp->lp_timer[i]));
1809 if (lp->lp_timer[i] == 0) {
1811 } else if (--lp->lp_timer[i] <= 0) {
1813 (*lacp_timer_funcs[i])(lp);
1820 lacp_marker_input(struct lacp_port *lp, struct mbuf *m)
1822 struct lacp_softc *lsc = lp->lp_lsc;
1823 struct lagg_port *lgp = lp->lp_lagg;
1866 error = lagg_enqueue(lp->lp_ifp, m);
1874 LACP_DPRINTF((lp, "marker response, port=%u, sys=%6D, id=%u\n",
1879 if (memcmp(&mdu->mdu_info, &lp->lp_marker,
1884 lp->lp_flags &= ~LACP_PORT_MARK;
1912 LACP_DPRINTF((lp, "bad marker frame\n"));
2058 lacp_dprintf(const struct lacp_port *lp, const char *fmt, ...)
2062 if (lp) {
2063 printf("%s: ", lp->lp_ifp->if_xname);