Lines Matching refs:lp
241 struct lacp_port *lp = LACP_PORT(lgp);
252 lacp_pdu_input(lp, m);
256 lacp_marker_input(lp, m);
268 lacp_pdu_input(struct lacp_port *lp, struct mbuf *m)
270 struct lacp_softc *lsc = lp->lp_lsc;
316 lacp_dprintf(lp, "lacpdu receive\n");
320 if ((1 << lp->lp_ifp->if_dunit) & lp->lp_lsc->lsc_debug.lsc_rx_test) {
321 LACP_TPRINTF((lp, "Dropping RX PDU\n"));
326 lacp_sm_rx(lp, du);
338 lacp_fill_actorinfo(struct lacp_port *lp, struct lacp_peerinfo *info)
340 struct lagg_port *lgp = lp->lp_lagg;
347 info->lip_portid.lpi_portno = htons(lp->lp_ifp->if_index);
348 info->lip_state = lp->lp_state;
352 lacp_fill_markerinfo(struct lacp_port *lp, struct lacp_markerinfo *info)
354 struct ifnet *ifp = lp->lp_ifp;
358 memcpy(&info->mi_rq_system, lp->lp_systemid.lsi_mac, ETHER_ADDR_LEN);
363 lacp_xmit_lacpdu(struct lacp_port *lp)
365 struct lagg_port *lgp = lp->lp_lagg;
370 LACP_LOCK_ASSERT(lp->lp_lsc);
390 du->ldu_actor = lp->lp_actor;
394 du->ldu_partner = lp->lp_partner;
401 lacp_dprintf(lp, "lacpdu transmit\n");
412 error = lagg_enqueue(lp->lp_ifp, m);
417 lacp_xmit_marker(struct lacp_port *lp)
419 struct lagg_port *lgp = lp->lp_lagg;
424 LACP_LOCK_ASSERT(lp->lp_lsc);
444 lp->lp_marker.mi_rq_xid = htonl(ntohl(lp->lp_marker.mi_rq_xid) + 1);
446 mdu->mdu_info = lp->lp_marker;
448 LACP_DPRINTF((lp, "marker transmit, port=%u, sys=%6D, id=%u\n",
453 error = lagg_enqueue(lp->lp_ifp, m);
460 struct lacp_port *lp = LACP_PORT(lgp);
461 struct lacp_softc *lsc = lp->lp_lsc;
480 LACP_DPRINTF((lp, "media changed 0x%x -> 0x%x, ether = %d, fdx = %d, "
481 "link = %d\n", lp->lp_media, media, IFM_TYPE(media) == IFM_ETHER,
483 old_state = lp->lp_state;
484 old_key = lp->lp_key;
486 lp->lp_media = media;
493 lacp_port_disable(lp);
495 lacp_port_enable(lp);
497 lp->lp_key = lacp_compose_key(lp);
499 if (old_state != lp->lp_state || old_key != lp->lp_key) {
500 LACP_DPRINTF((lp, "-> UNSELECTED\n"));
501 lp->lp_selected = LACP_UNSELECTED;
510 struct lacp_port *lp;
512 LIST_FOREACH(lp, &lsc->lsc_ports, lp_next) {
513 if ((lp->lp_state & LACP_STATE_AGGREGATION) == 0)
516 CURVNET_SET(lp->lp_ifp->if_vnet);
517 lacp_run_timers(lp);
519 lacp_select(lp);
520 lacp_sm_mux(lp);
521 lacp_sm_tx(lp);
522 lacp_sm_ptx_tx_schedule(lp);
533 struct lacp_port *lp;
551 lp = malloc(sizeof(struct lacp_port),
553 if (lp == NULL)
557 lgp->lp_psc = lp;
558 lp->lp_ifp = ifp;
559 lp->lp_lagg = lgp;
560 lp->lp_lsc = lsc;
561 lp->lp_ifma = rifma;
563 LIST_INSERT_HEAD(&lsc->lsc_ports, lp, lp_next);
565 lacp_fill_actorinfo(lp, &lp->lp_actor);
566 lacp_fill_markerinfo(lp, &lp->lp_marker);
567 lp->lp_state = LACP_STATE_ACTIVITY;
568 lp->lp_aggregator = NULL;
569 lacp_sm_rx_set_expired(lp);
579 struct lacp_port *lp = LACP_PORT(lgp);
580 struct lacp_softc *lsc = lp->lp_lsc;
585 LACP_TIMER_DISARM(lp, i);
588 lacp_disable_collecting(lp);
589 lacp_disable_distributing(lp);
590 lacp_unselect(lp);
592 LIST_REMOVE(lp, lp_next);
597 if_delmulti_ifma(lp->lp_ifma);
599 free(lp, M_DEVBUF);
645 struct lacp_port *lp = LACP_PORT(lgp);
646 struct lacp_softc *lsc = lp->lp_lsc;
649 req->actor_prio = ntohs(lp->lp_actor.lip_systemid.lsi_prio);
650 memcpy(&req->actor_mac, &lp->lp_actor.lip_systemid.lsi_mac,
652 req->actor_key = ntohs(lp->lp_actor.lip_key);
653 req->actor_portprio = ntohs(lp->lp_actor.lip_portid.lpi_prio);
654 req->actor_portno = ntohs(lp->lp_actor.lip_portid.lpi_portno);
655 req->actor_state = lp->lp_actor.lip_state;
657 req->partner_prio = ntohs(lp->lp_partner.lip_systemid.lsi_prio);
658 memcpy(&req->partner_mac, &lp->lp_partner.lip_systemid.lsi_mac,
660 req->partner_key = ntohs(lp->lp_partner.lip_key);
661 req->partner_portprio = ntohs(lp->lp_partner.lip_portid.lpi_prio);
662 req->partner_portno = ntohs(lp->lp_partner.lip_portid.lpi_portno);
663 req->partner_state = lp->lp_partner.lip_state;
668 lacp_disable_collecting(struct lacp_port *lp)
670 LACP_DPRINTF((lp, "collecting disabled\n"));
671 lp->lp_state &= ~LACP_STATE_COLLECTING;
675 lacp_enable_collecting(struct lacp_port *lp)
677 LACP_DPRINTF((lp, "collecting enabled\n"));
678 lp->lp_state |= LACP_STATE_COLLECTING;
682 lacp_disable_distributing(struct lacp_port *lp)
684 struct lacp_aggregator *la = lp->lp_aggregator;
685 struct lacp_softc *lsc = lp->lp_lsc;
691 if (la == NULL || (lp->lp_state & LACP_STATE_DISTRIBUTING) == 0) {
699 LACP_DPRINTF((lp, "disable distributing on aggregator %s, "
704 TAILQ_REMOVE(&la->la_ports, lp, lp_dist_q);
715 lp->lp_state &= ~LACP_STATE_DISTRIBUTING;
721 lacp_enable_distributing(struct lacp_port *lp)
723 struct lacp_aggregator *la = lp->lp_aggregator;
724 struct lacp_softc *lsc = lp->lp_lsc;
730 if ((lp->lp_state & LACP_STATE_DISTRIBUTING) != 0) {
734 LACP_DPRINTF((lp, "enable distributing on aggregator %s, "
740 TAILQ_INSERT_HEAD(&la->la_ports, lp, lp_dist_q);
744 lp->lp_state |= LACP_STATE_DISTRIBUTING;
840 struct lacp_port *lp;
876 lp = map[hash];
878 return (lp->lp_lagg);
906 struct lacp_port *lp;
917 LIST_FOREACH(lp, &lsc->lsc_ports, lp_next) {
918 lp->lp_flags |= LACP_PORT_MARK;
919 if (lacp_xmit_marker(lp) != 0)
920 lp->lp_flags &= ~LACP_PORT_MARK;
954 struct lacp_port *lp;
957 lp = TAILQ_FIRST(&la->la_ports);
958 if (lp == NULL) {
962 speed = ifmedia_baudrate(lp->lp_media);
965 LACP_DPRINTF((lp, "speed 0? media=0x%x nports=%d\n",
966 lp->lp_media, la->la_nports));
1049 struct lacp_port *lp;
1067 TAILQ_FOREACH(lp, &la->la_ports, lp_dist_q) {
1068 p->pm_map[i++] = lp;
1070 domain = lp->lp_ifp->if_numa_domain;
1074 p->pm_numa[domain].map[count] = lp;
1100 lacp_compose_key(struct lacp_port *lp)
1102 struct lagg_port *lgp = lp->lp_lagg;
1104 u_int media = lp->lp_media;
1107 if ((lp->lp_state & LACP_STATE_AGGREGATION) == 0) {
1115 key = lp->lp_ifp->if_index;
1324 lacp_aggregator_get(struct lacp_softc *lsc, struct lacp_port *lp)
1345 lacp_fill_aggregator_id(struct lacp_aggregator *la, const struct lacp_port *lp)
1347 lacp_fill_aggregator_id_peer(&la->la_partner, &lp->lp_partner);
1348 lacp_fill_aggregator_id_peer(&la->la_actor, &lp->lp_actor);
1350 la->la_actor.lip_state = lp->lp_state & LACP_STATE_AGGREGATION;
1368 const struct lacp_port *lp)
1370 if (!(lp->lp_state & LACP_STATE_AGGREGATION) ||
1371 !(lp->lp_partner.lip_state & LACP_STATE_AGGREGATION)) {
1378 if (!lacp_peerinfo_is_compatible(&la->la_partner, &lp->lp_partner))
1381 if (!lacp_peerinfo_is_compatible(&la->la_actor, &lp->lp_actor))
1403 lacp_port_enable(struct lacp_port *lp)
1405 lp->lp_state |= LACP_STATE_AGGREGATION;
1409 lacp_port_disable(struct lacp_port *lp)
1411 lacp_set_mux(lp, LACP_MUX_DETACHED);
1413 lp->lp_state &= ~LACP_STATE_AGGREGATION;
1414 lp->lp_selected = LACP_UNSELECTED;
1415 lacp_sm_rx_record_default(lp);
1416 lp->lp_partner.lip_state &= ~LACP_STATE_AGGREGATION;
1417 lp->lp_state &= ~LACP_STATE_EXPIRED;
1424 lacp_select(struct lacp_port *lp)
1426 struct lacp_softc *lsc = lp->lp_lsc;
1430 if (lp->lp_aggregator) {
1435 if (lp->lp_state & LACP_STATE_DEFAULTED)
1438 KASSERT(!LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE),
1441 LACP_DPRINTF((lp, "port lagid=%s\n",
1442 lacp_format_lagid(&lp->lp_actor, &lp->lp_partner,
1446 if (lacp_aggregator_is_compatible(la, lp)) {
1452 la = lacp_aggregator_get(lsc, lp);
1454 LACP_DPRINTF((lp, "aggregator creation failed\n"));
1462 lacp_fill_aggregator_id(la, lp);
1463 LACP_DPRINTF((lp, "aggregator created\n"));
1465 LACP_DPRINTF((lp, "compatible aggregator found\n"));
1471 LACP_DPRINTF((lp, "aggregator lagid=%s\n",
1475 lp->lp_aggregator = la;
1476 lp->lp_selected = LACP_SELECTED;
1484 lacp_unselect(struct lacp_port *lp)
1486 struct lacp_softc *lsc = lp->lp_lsc;
1487 struct lacp_aggregator *la = lp->lp_aggregator;
1489 KASSERT(!LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE),
1496 lp->lp_aggregator = NULL;
1503 lacp_sm_mux(struct lacp_port *lp)
1505 struct lagg_port *lgp = lp->lp_lagg;
1509 (lp->lp_partner.lip_state & LACP_STATE_SYNC) != 0;
1511 (lp->lp_partner.lip_state & LACP_STATE_COLLECTING) != 0;
1512 enum lacp_selected selected = lp->lp_selected;
1516 lacp_dprintf(lp, "%s: state= 0x%x, selected= 0x%x, "
1518 lp->lp_mux_state, selected, p_sync, p_collecting);
1521 la = lp->lp_aggregator;
1522 KASSERT(lp->lp_mux_state == LACP_MUX_DETACHED || la != NULL,
1524 new_state = lp->lp_mux_state;
1525 switch (lp->lp_mux_state) {
1533 !LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE),
1558 lacp_dprintf(lp, "Interface stopped DISTRIBUTING, possible flapping\n");
1566 if (lp->lp_mux_state == new_state) {
1570 lacp_set_mux(lp, new_state);
1575 lacp_set_mux(struct lacp_port *lp, enum lacp_mux_state new_state)
1577 struct lacp_aggregator *la = lp->lp_aggregator;
1579 if (lp->lp_mux_state == new_state) {
1585 lp->lp_state &= ~LACP_STATE_SYNC;
1586 lacp_disable_distributing(lp);
1587 lacp_disable_collecting(lp);
1588 lacp_sm_assert_ntt(lp);
1590 if (LACP_TIMER_ISARMED(lp, LACP_TIMER_WAIT_WHILE)) {
1595 LACP_TIMER_DISARM(lp, LACP_TIMER_WAIT_WHILE);
1596 lacp_unselect(lp);
1599 LACP_TIMER_ARM(lp, LACP_TIMER_WAIT_WHILE,
1604 lp->lp_state |= LACP_STATE_SYNC;
1605 lacp_disable_collecting(lp);
1606 lacp_sm_assert_ntt(lp);
1609 lacp_enable_collecting(lp);
1610 lacp_disable_distributing(lp);
1611 lacp_sm_assert_ntt(lp);
1614 lacp_enable_distributing(lp);
1620 LACP_DPRINTF((lp, "mux_state %d -> %d\n", lp->lp_mux_state, new_state));
1622 lp->lp_mux_state = new_state;
1626 lacp_sm_mux_timer(struct lacp_port *lp)
1628 struct lacp_aggregator *la = lp->lp_aggregator;
1633 LACP_DPRINTF((lp, "%s: aggregator %s, pending %d -> %d\n", __func__,
1644 lacp_sm_ptx_update_timeout(struct lacp_port *lp, uint8_t oldpstate)
1646 if (LACP_STATE_EQ(oldpstate, lp->lp_partner.lip_state,
1651 LACP_DPRINTF((lp, "partner timeout changed\n"));
1661 LACP_TIMER_DISARM(lp, LACP_TIMER_PERIODIC);
1667 if ((lp->lp_partner.lip_state & LACP_STATE_TIMEOUT)) {
1668 lacp_sm_assert_ntt(lp);
1673 lacp_sm_ptx_tx_schedule(struct lacp_port *lp)
1677 if (!(lp->lp_state & LACP_STATE_ACTIVITY) &&
1678 !(lp->lp_partner.lip_state & LACP_STATE_ACTIVITY)) {
1683 LACP_TIMER_DISARM(lp, LACP_TIMER_PERIODIC);
1687 if (LACP_TIMER_ISARMED(lp, LACP_TIMER_PERIODIC)) {
1691 timeout = (lp->lp_partner.lip_state & LACP_STATE_TIMEOUT) ?
1694 LACP_TIMER_ARM(lp, LACP_TIMER_PERIODIC, timeout);
1698 lacp_sm_ptx_timer(struct lacp_port *lp)
1700 lacp_sm_assert_ntt(lp);
1704 lacp_sm_rx(struct lacp_port *lp, const struct lacpdu *du)
1712 if (!(lp->lp_state & LACP_STATE_AGGREGATION)) {
1721 &lp->lp_actor.lip_systemid)) {
1729 microuptime(&lp->lp_last_lacpdu_rx);
1730 lacp_sm_rx_update_selected(lp, du);
1731 lacp_sm_rx_update_ntt(lp, du);
1732 lacp_sm_rx_record_pdu(lp, du);
1734 timeout = (lp->lp_state & LACP_STATE_TIMEOUT) ?
1736 LACP_TIMER_ARM(lp, LACP_TIMER_CURRENT_WHILE, timeout);
1738 lp->lp_state &= ~LACP_STATE_EXPIRED;
1744 lacp_sm_tx(lp);
1748 lacp_sm_rx_set_expired(struct lacp_port *lp)
1750 lp->lp_partner.lip_state &= ~LACP_STATE_SYNC;
1751 lp->lp_partner.lip_state |= LACP_STATE_TIMEOUT;
1752 LACP_TIMER_ARM(lp, LACP_TIMER_CURRENT_WHILE, LACP_SHORT_TIMEOUT_TIME);
1753 lp->lp_state |= LACP_STATE_EXPIRED;
1757 lacp_sm_rx_timer(struct lacp_port *lp)
1759 if ((lp->lp_state & LACP_STATE_EXPIRED) == 0) {
1761 LACP_DPRINTF((lp, "%s: CURRENT -> EXPIRED\n", __func__));
1762 lacp_sm_rx_set_expired(lp);
1765 LACP_DPRINTF((lp, "%s: EXPIRED -> DEFAULTED\n", __func__));
1766 lacp_sm_rx_update_default_selected(lp);
1767 lacp_sm_rx_record_default(lp);
1768 lp->lp_state &= ~LACP_STATE_EXPIRED;
1773 lacp_sm_rx_record_pdu(struct lacp_port *lp, const struct lacpdu *du)
1779 LACP_TRACE(lp);
1781 oldpstate = lp->lp_partner.lip_state;
1784 || ((lp->lp_state & LACP_STATE_ACTIVITY) &&
1787 lp->lp_partner = du->ldu_actor;
1789 ((LACP_STATE_EQ(lp->lp_state, du->ldu_partner.lip_state,
1791 !lacp_compare_peerinfo(&lp->lp_actor, &du->ldu_partner))
1800 if (lp->lp_lsc->lsc_strict_mode)
1801 lp->lp_partner.lip_state |= LACP_STATE_SYNC;
1803 lp->lp_partner.lip_state &= ~LACP_STATE_SYNC;
1806 lp->lp_state &= ~LACP_STATE_DEFAULTED;
1808 if (oldpstate != lp->lp_partner.lip_state) {
1809 LACP_DPRINTF((lp, "old pstate %s\n",
1811 LACP_DPRINTF((lp, "new pstate %s\n",
1812 lacp_format_state(lp->lp_partner.lip_state, buf,
1816 lacp_sm_ptx_update_timeout(lp, oldpstate);
1820 lacp_sm_rx_update_ntt(struct lacp_port *lp, const struct lacpdu *du)
1823 LACP_TRACE(lp);
1825 if (lacp_compare_peerinfo(&lp->lp_actor, &du->ldu_partner) ||
1826 !LACP_STATE_EQ(lp->lp_state, du->ldu_partner.lip_state,
1828 LACP_DPRINTF((lp, "%s: assert ntt\n", __func__));
1829 lacp_sm_assert_ntt(lp);
1834 lacp_sm_rx_record_default(struct lacp_port *lp)
1838 LACP_TRACE(lp);
1840 oldpstate = lp->lp_partner.lip_state;
1841 if (lp->lp_lsc->lsc_strict_mode)
1842 lp->lp_partner = lacp_partner_admin_strict;
1844 lp->lp_partner = lacp_partner_admin_optimistic;
1845 lp->lp_state |= LACP_STATE_DEFAULTED;
1846 lacp_sm_ptx_update_timeout(lp, oldpstate);
1850 lacp_sm_rx_update_selected_from_peerinfo(struct lacp_port *lp,
1854 LACP_TRACE(lp);
1856 if (lacp_compare_peerinfo(&lp->lp_partner, info) ||
1857 !LACP_STATE_EQ(lp->lp_partner.lip_state, info->lip_state,
1859 lp->lp_selected = LACP_UNSELECTED;
1860 /* mux machine will clean up lp->lp_aggregator */
1865 lacp_sm_rx_update_selected(struct lacp_port *lp, const struct lacpdu *du)
1868 LACP_TRACE(lp);
1870 lacp_sm_rx_update_selected_from_peerinfo(lp, &du->ldu_actor);
1874 lacp_sm_rx_update_default_selected(struct lacp_port *lp)
1877 LACP_TRACE(lp);
1879 if (lp->lp_lsc->lsc_strict_mode)
1880 lacp_sm_rx_update_selected_from_peerinfo(lp,
1883 lacp_sm_rx_update_selected_from_peerinfo(lp,
1890 lacp_sm_tx(struct lacp_port *lp)
1894 if (!(lp->lp_state & LACP_STATE_AGGREGATION)
1896 || (!(lp->lp_state & LACP_STATE_ACTIVITY)
1897 && !(lp->lp_partner.lip_state & LACP_STATE_ACTIVITY))
1900 lp->lp_flags &= ~LACP_PORT_NTT;
1903 if (!(lp->lp_flags & LACP_PORT_NTT)) {
1908 if (ppsratecheck(&lp->lp_last_lacpdu, &lp->lp_lacpdu_sent,
1910 LACP_DPRINTF((lp, "rate limited pdu\n"));
1914 if (((1 << lp->lp_ifp->if_dunit) & lp->lp_lsc->lsc_debug.lsc_tx_test) == 0) {
1915 error = lacp_xmit_lacpdu(lp);
1917 LACP_TPRINTF((lp, "Dropping TX PDU\n"));
1921 lp->lp_flags &= ~LACP_PORT_NTT;
1923 LACP_DPRINTF((lp, "lacpdu transmit failure, error %d\n",
1929 lacp_sm_assert_ntt(struct lacp_port *lp)
1932 lp->lp_flags |= LACP_PORT_NTT;
1936 lacp_run_timers(struct lacp_port *lp)
1942 KASSERT(lp->lp_timer[i] >= 0,
1943 ("invalid timer value %d", lp->lp_timer[i]));
1944 if (lp->lp_timer[i] == 0) {
1949 timevalsub(&time_diff, &lp->lp_last_lacpdu_rx);
1952 --lp->lp_timer[i];
1955 --lp->lp_timer[i];
1958 if ((lp->lp_timer[i] <= 0) && (lacp_timer_funcs[i])) {
1959 (*lacp_timer_funcs[i])(lp);
1966 lacp_marker_input(struct lacp_port *lp, struct mbuf *m)
1968 struct lacp_softc *lsc = lp->lp_lsc;
1969 struct lagg_port *lgp = lp->lp_lagg;
2012 error = lagg_enqueue(lp->lp_ifp, m);
2020 LACP_DPRINTF((lp, "marker response, port=%u, sys=%6D, id=%u\n",
2025 if (memcmp(&mdu->mdu_info, &lp->lp_marker,
2030 lp->lp_flags &= ~LACP_PORT_MARK;
2058 LACP_DPRINTF((lp, "bad marker frame\n"));
2204 lacp_dprintf(const struct lacp_port *lp, const char *fmt, ...)
2208 if (lp) {
2209 printf("%s: ", lp->lp_ifp->if_xname);