The branch main has been updated by kbowling: URL: https://cgit.FreeBSD.org/src/commit/?id=2b763a82f9f21b722b50830bc22af2b2acf36746
commit 2b763a82f9f21b722b50830bc22af2b2acf36746 Author: Kevin Bowling <[email protected]> AuthorDate: 2026-08-06 08:22:21 +0000 Commit: Kevin Bowling <[email protected]> CommitDate: 2026-08-08 07:07:31 +0000 ixgbe: Handle deferred link-status requests The iflib conversion records link-status interrupts in the administrative request mask, but the administrative task did not consume them. Timer polling usually hid the omission; frequent mailbox interrupts could continually rearm that timer and leave cached link state down after hardware recovered. Claim request batches atomically, process link-setup dependencies, and sample hardware before publishing link state. Bound each invocation to eight batches and requeue residual work so a continuous producer cannot monopolize the admin taskqueue. Queue every link-related request from the legacy interrupt path. Unlike MSI-X, its threaded continuation services RX and does not enqueue the admin task. This restores the event-driven behavior of ix-3.4.39. Fixes: b2c1e8e62049 ("ix(4): Run {mod,msf,mbx,fdir,phy}_task in if_update_admin_status") MFC after: 2 weeks --- sys/dev/ixgbe/if_ix.c | 133 +++++++++++++++++++++++++++++++------------------- 1 file changed, 83 insertions(+), 50 deletions(-) diff --git a/sys/dev/ixgbe/if_ix.c b/sys/dev/ixgbe/if_ix.c index e0e627b915d9..0c40feed48c9 100644 --- a/sys/dev/ixgbe/if_ix.c +++ b/sys/dev/ixgbe/if_ix.c @@ -51,6 +51,9 @@ ************************************************************************/ static const char ixgbe_driver_version[] = "5.0.1-k"; +/* Bound one admin-task invocation while still coalescing new requests. */ +#define IXGBE_ADMIN_TASK_BUDGET 8 + /************************************************************************ * PCI Device ID Table * @@ -280,9 +283,9 @@ static int ixgbe_sysctl_dump_debug_dump(SYSCTL_HANDLER_ARGS); /* Deferred interrupt tasklets */ static void ixgbe_handle_msf(void *); -static void ixgbe_handle_mod(void *); +static bool ixgbe_handle_mod(void *); static void ixgbe_handle_phy(void *); -static void ixgbe_handle_fw_event(void *); +static u32 ixgbe_handle_fw_event(void *); static int ixgbe_enable_lse(struct ixgbe_softc *sc); static int ixgbe_disable_lse(struct ixgbe_softc *sc); @@ -1838,7 +1841,7 @@ ixgbe_config_link(if_ctx_t ctx) if (sfp) { /* ixgbe_if_stop() disables it on every 82599 SFP port. */ ixgbe_enable_tx_laser(hw); - sc->task_requests |= IXGBE_REQUEST_TASK_MOD; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_MOD); iflib_admin_intr_deferred(ctx); } else { if (hw->mac.ops.check_link) @@ -3123,12 +3126,12 @@ ixgbe_msix_link(void *arg) /* Link status change */ if (eicr & IXGBE_EICR_LSC) { IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC); - sc->task_requests |= IXGBE_REQUEST_TASK_LSC; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_LSC); } if (eicr & IXGBE_EICR_FW_EVENT) { IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EICR_FW_EVENT); - sc->task_requests |= IXGBE_REQUEST_TASK_FWEVENT; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_FWEVENT); } if (sc->hw.mac.type != ixgbe_mac_82598EB) { @@ -3139,7 +3142,7 @@ ixgbe_msix_link(void *arg) return (FILTER_HANDLED); /* Disable the interrupt */ IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EICR_FLOW_DIR); - sc->task_requests |= IXGBE_REQUEST_TASK_FDIR; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_FDIR); } else if (eicr & IXGBE_EICR_ECC) { device_printf(iflib_get_dev(sc->ctx), @@ -3190,7 +3193,7 @@ ixgbe_msix_link(void *arg) /* Check for VF message */ if ((sc->feat_en & IXGBE_FEATURE_SRIOV) && (eicr & IXGBE_EICR_MAILBOX)) { - sc->task_requests |= IXGBE_REQUEST_TASK_MBX; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_MBX); } } @@ -3207,14 +3210,14 @@ ixgbe_msix_link(void *arg) if (eicr & eicr_mask) { IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); - sc->task_requests |= IXGBE_REQUEST_TASK_MOD; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_MOD); } if ((hw->mac.type == ixgbe_mac_82599EB) && (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); - sc->task_requests |= IXGBE_REQUEST_TASK_MSF; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_MSF); } } @@ -3229,10 +3232,10 @@ ixgbe_msix_link(void *arg) if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && (eicr & IXGBE_EICR_GPI_SDP0_X540)) { IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP0_X540); - sc->task_requests |= IXGBE_REQUEST_TASK_PHY; + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_PHY); } - return (sc->task_requests != 0) ? + return (atomic_load_acq_32(&sc->task_requests) != 0) ? FILTER_SCHEDULE_THREAD : FILTER_HANDLED; } /* ixgbe_msix_link */ @@ -3986,10 +3989,9 @@ ixgbe_if_init(if_ctx_t ctx) ixgbe_initialize_receive_units(ctx); /* - * Initialize variable holding task enqueue requests - * from MSI-X interrupts + * Initialize the deferred administrative request mask. */ - sc->task_requests = 0; + atomic_store_rel_32(&sc->task_requests, 0); /* Enable SDP & MSI-X interrupts based on adapter */ ixgbe_config_gpie(sc); @@ -4548,7 +4550,7 @@ out: /************************************************************************ * ixgbe_handle_mod - Tasklet for SFP module interrupts ************************************************************************/ -static void +static bool ixgbe_handle_mod(void *context) { if_ctx_t ctx = context; @@ -4593,11 +4595,10 @@ ixgbe_handle_mod(void *context) "Setup failure - unsupported SFP+ module type.\n"); goto handle_mod_out; } - sc->task_requests |= IXGBE_REQUEST_TASK_MSF; - return; + return (true); handle_mod_out: - sc->task_requests &= ~(IXGBE_REQUEST_TASK_MSF); + return (false); } /* ixgbe_handle_mod */ @@ -4689,7 +4690,7 @@ s32 ixgbe_disable_lse(struct ixgbe_softc *sc) /************************************************************************ * ixgbe_handle_fw_event - Tasklet for MSI-X Link Status Event interrupts ************************************************************************/ -static void +static u32 ixgbe_handle_fw_event(void *context) { if_ctx_t ctx = context; @@ -4698,13 +4699,14 @@ ixgbe_handle_fw_event(void *context) struct ixgbe_aci_event event; bool pending = false; s32 error; + u32 requests = 0; event.buf_len = IXGBE_ACI_MAX_BUFFER_SIZE; event.msg_buf = malloc(event.buf_len, M_IXGBE, M_ZERO | M_NOWAIT); if (!event.msg_buf) { device_printf(sc->dev, "Can not allocate buffer for " "event message\n"); - return; + return (0); } do { @@ -4717,7 +4719,7 @@ ixgbe_handle_fw_event(void *context) switch (le16toh(event.desc.opcode)) { case ixgbe_aci_opc_get_link_status: - sc->task_requests |= IXGBE_REQUEST_TASK_LSC; + requests |= IXGBE_REQUEST_TASK_LSC; break; case ixgbe_aci_opc_fw_logs_event: @@ -4741,6 +4743,7 @@ ixgbe_handle_fw_event(void *context) } while (pending); free(event.msg_buf, M_IXGBE); + return (requests); } /* ixgbe_handle_fw_event */ /************************************************************************ @@ -4812,15 +4815,61 @@ ixgbe_link_speed_to_str(u32 link_speed) /************************************************************************ * ixgbe_update_link_status - Update OS on link state * - * Note: Only updates the OS on the cached link state. - * The real check of the hardware only happens with - * a link interrupt. + * Process deferred administrative requests and update the OS link state. ************************************************************************/ static void ixgbe_if_update_admin_status(if_ctx_t ctx) { struct ixgbe_softc *sc = iflib_get_softc(ctx); device_t dev = iflib_get_dev(ctx); + u32 requests; + u_int pass; + bool check_link = false; + + /* + * The interrupt filter and other producers can run concurrently with + * this task. Claim each batch atomically so a request posted while the + * task is running remains pending for this or the next invocation. + * + * MOD and firmware events can produce dependent requests. Fold those + * into the claimed batch so link state is sampled after any link setup. + */ + if ((if_getdrvflags(iflib_get_ifp(ctx)) & IFF_DRV_RUNNING) != 0 && + (sc->iov_mbx_cleanup_pending || ixgbe_mbx_pending(sc))) + atomic_set_32(&sc->task_requests, IXGBE_REQUEST_TASK_MBX); + for (pass = 0; pass < IXGBE_ADMIN_TASK_BUDGET; pass++) { + requests = atomic_readandclear_32(&sc->task_requests); + if (requests == 0) + break; + if (requests & IXGBE_REQUEST_TASK_FWEVENT) + requests |= ixgbe_handle_fw_event(ctx); + if (requests & IXGBE_REQUEST_TASK_MOD) { + if (ixgbe_handle_mod(ctx)) + requests |= IXGBE_REQUEST_TASK_MSF; + else + requests &= ~IXGBE_REQUEST_TASK_MSF; + } + if (requests & IXGBE_REQUEST_TASK_MSF) + ixgbe_handle_msf(ctx); + /* A reset request can re-enable VF traffic; skip it while stopped. */ + if ((requests & IXGBE_REQUEST_TASK_MBX) != 0 && + (if_getdrvflags(iflib_get_ifp(ctx)) & IFF_DRV_RUNNING) != 0) + ixgbe_handle_mbx(ctx); + if (requests & IXGBE_REQUEST_TASK_FDIR) + ixgbe_reinit_fdir(ctx); + if (requests & IXGBE_REQUEST_TASK_PHY) + ixgbe_handle_phy(ctx); + if (requests & IXGBE_REQUEST_TASK_LSC) + check_link = true; + } + + /* Do not let a continuous producer monopolize the admin taskqueue. */ + if (atomic_load_acq_32(&sc->task_requests) != 0) + iflib_admin_intr_deferred(ctx); + + if (check_link) + ixgbe_check_link(&sc->hw, &sc->link_speed, &sc->link_up, + false); if (sc->link_up) { if (sc->link_active == false) { @@ -4864,27 +4913,6 @@ ixgbe_if_update_admin_status(if_ctx_t ctx) } } - /* Handle task requests from msix_link() */ - if (sc->task_requests & IXGBE_REQUEST_TASK_FWEVENT) - ixgbe_handle_fw_event(ctx); - if (sc->task_requests & IXGBE_REQUEST_TASK_MOD) - ixgbe_handle_mod(ctx); - if (sc->task_requests & IXGBE_REQUEST_TASK_MSF) - ixgbe_handle_msf(ctx); - /* - * A reset request re-enables VF traffic, so do not service mailboxes - * while the PF is stopped. VFREQ, VFACK, and VFLR are hardware-latched - * and ixgbe_mbx_pending() resamples them after the PF is running again. - */ - if ((if_getdrvflags(iflib_get_ifp(ctx)) & IFF_DRV_RUNNING) != 0 && - ((sc->task_requests & IXGBE_REQUEST_TASK_MBX) != 0 || - sc->iov_mbx_cleanup_pending || ixgbe_mbx_pending(sc))) - ixgbe_handle_mbx(ctx); - if (sc->task_requests & IXGBE_REQUEST_TASK_FDIR) - ixgbe_reinit_fdir(ctx); - if (sc->task_requests & IXGBE_REQUEST_TASK_PHY) - ixgbe_handle_phy(ctx); - sc->task_requests = 0; ixgbe_schedule_iov_recovery(sc); ixgbe_update_stats_counters(sc); @@ -5109,9 +5137,10 @@ ixgbe_intr(void *arg) struct ix_rx_queue *que = sc->rx_queues; struct ixgbe_hw *hw = &sc->hw; if_ctx_t ctx = sc->ctx; - u32 eicr, eicr_mask; + u32 eicr, eicr_mask, requests; eicr = IXGBE_READ_REG(hw, IXGBE_EICR); + requests = 0; ++que->irqs; if (eicr == 0) { @@ -5131,7 +5160,7 @@ ixgbe_intr(void *arg) /* Link status change */ if (eicr & IXGBE_EICR_LSC) { IXGBE_WRITE_REG(hw, IXGBE_EIMC, IXGBE_EIMC_LSC); - iflib_admin_intr_deferred(ctx); + requests |= IXGBE_REQUEST_TASK_LSC; } if (ixgbe_is_sfp(hw)) { @@ -5143,21 +5172,25 @@ ixgbe_intr(void *arg) if (eicr & eicr_mask) { IXGBE_WRITE_REG(hw, IXGBE_EICR, eicr_mask); - sc->task_requests |= IXGBE_REQUEST_TASK_MOD; + requests |= IXGBE_REQUEST_TASK_MOD; } if ((hw->mac.type == ixgbe_mac_82599EB) && (eicr & IXGBE_EICR_GPI_SDP1_BY_MAC(hw))) { IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP1_BY_MAC(hw)); - sc->task_requests |= IXGBE_REQUEST_TASK_MSF; + requests |= IXGBE_REQUEST_TASK_MSF; } } /* External PHY interrupt */ if ((hw->phy.type == ixgbe_phy_x550em_ext_t) && (eicr & IXGBE_EICR_GPI_SDP0_X540)) { - sc->task_requests |= IXGBE_REQUEST_TASK_PHY; + requests |= IXGBE_REQUEST_TASK_PHY; + } + if (requests != 0) { + atomic_set_32(&sc->task_requests, requests); + iflib_admin_intr_deferred(ctx); } return (FILTER_SCHEDULE_THREAD);
