Lines Matching refs:ctx
162 static void iflib_tqg_detach(if_ctx_t ctx);
237 iflib_get_softc(if_ctx_t ctx)
240 return (ctx->ifc_softc);
244 iflib_get_dev(if_ctx_t ctx)
247 return (ctx->ifc_dev);
251 iflib_get_ifp(if_ctx_t ctx)
254 return (ctx->ifc_ifp);
258 iflib_get_media(if_ctx_t ctx)
261 return (ctx->ifc_mediap);
265 iflib_get_flags(if_ctx_t ctx)
267 return (ctx->ifc_flags);
271 iflib_set_mac(if_ctx_t ctx, uint8_t mac[ETHER_ADDR_LEN])
274 bcopy(mac, ctx->ifc_mac.octet, ETHER_ADDR_LEN);
278 iflib_get_softc_ctx(if_ctx_t ctx)
281 return (&ctx->ifc_softc_ctx);
285 iflib_get_sctx(if_ctx_t ctx)
288 return (ctx->ifc_sctx);
295 #define LINK_ACTIVE(ctx) ((ctx)->ifc_link_state == LINK_STATE_UP)
296 #define CTX_IS_VF(ctx) ((ctx)->ifc_sctx->isc_flags & IFLIB_IS_VF)
558 #define CTX_ACTIVE(ctx) ((if_getdrvflags((ctx)->ifc_ifp) & IFF_DRV_RUNNING))
560 #define CTX_LOCK_INIT(_sc) sx_init(&(_sc)->ifc_ctx_sx, "iflib ctx lock")
561 #define CTX_LOCK(ctx) sx_xlock(&(ctx)->ifc_ctx_sx)
562 #define CTX_UNLOCK(ctx) sx_xunlock(&(ctx)->ifc_ctx_sx)
563 #define CTX_LOCK_DESTROY(ctx) sx_destroy(&(ctx)->ifc_ctx_sx)
566 #define STATE_LOCK(ctx) mtx_lock(&(ctx)->ifc_state_mtx)
567 #define STATE_UNLOCK(ctx) mtx_unlock(&(ctx)->ifc_state_mtx)
568 #define STATE_LOCK_DESTROY(ctx) mtx_destroy(&(ctx)->ifc_state_mtx)
574 iflib_set_detach(if_ctx_t ctx)
576 STATE_LOCK(ctx);
577 ctx->ifc_flags |= IFC_IN_DETACH;
578 STATE_UNLOCK(ctx);
726 static void iflib_tx_structures_free(if_ctx_t ctx);
727 static void iflib_rx_structures_free(if_ctx_t ctx);
728 static int iflib_queues_alloc(if_ctx_t ctx);
729 static int iflib_tx_credits_update(if_ctx_t ctx, iflib_txq_t txq);
730 static int iflib_rxd_avail(if_ctx_t ctx, iflib_rxq_t rxq, qidx_t cidx, qidx_t budget);
731 static int iflib_qset_structures_setup(if_ctx_t ctx);
732 static int iflib_msix_init(if_ctx_t ctx);
733 static int iflib_legacy_setup(if_ctx_t ctx, driver_filter_t filter, void *filterarg, int *rid, const char *str);
742 static void iflib_unregister_vlan_handlers(if_ctx_t ctx);
744 static void iflib_init_locked(if_ctx_t ctx);
745 static void iflib_add_device_sysctl_pre(if_ctx_t ctx);
746 static void iflib_add_device_sysctl_post(if_ctx_t ctx);
749 static void iflib_if_init_locked(if_ctx_t ctx);
750 static void iflib_free_intr_mem(if_ctx_t ctx);
772 iflib_num_rx_descs(if_ctx_t ctx)
774 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
775 if_shared_ctx_t sctx = ctx->ifc_sctx;
782 iflib_num_tx_descs(if_ctx_t ctx)
784 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
785 if_shared_ctx_t sctx = ctx->ifc_sctx;
835 if_ctx_t ctx = ifp->if_softc;
838 CTX_LOCK(ctx);
839 if (!CTX_IS_VF(ctx))
840 IFDI_CRCSTRIP_SET(ctx, onoff, iflib_crcstrip);
842 iflib_stop(ctx);
858 iflib_init_locked(ctx);
859 IFDI_CRCSTRIP_SET(ctx, onoff, iflib_crcstrip); // XXX why twice ?
863 CTX_UNLOCK(ctx);
871 if_ctx_t ctx = ifp->if_softc;
872 iflib_rxq_t rxq = &ctx->ifc_rxqs[0];
875 info->num_tx_rings = ctx->ifc_softc_ctx.isc_ntxqsets;
876 info->num_rx_rings = ctx->ifc_softc_ctx.isc_nrxqsets;
877 info->num_tx_descs = iflib_num_tx_descs(ctx);
878 info->num_rx_descs = iflib_num_rx_descs(ctx);
895 if_ctx_t ctx = rxq->ifr_ctx;
979 ctx->isc_rxd_refill(ctx->ifc_softc, &iru);
991 ctx->isc_rxd_flush(ctx->ifc_softc, rxq->ifr_id, fl->ifl_id,
1034 if_ctx_t ctx = ifp->if_softc;
1035 iflib_txq_t txq = &ctx->ifc_txqs[kring->ring_id];
1107 ctx->isc_txd_encap(ctx->ifc_softc, &pi);
1147 ctx->isc_txd_flush(ctx->ifc_softc, txq->ift_id, nic_i);
1158 if (iflib_tx_credits_update(ctx, txq)) {
1165 if (!(ctx->ifc_flags & IFC_NETMAP_TX_IRQ))
1205 if_ctx_t ctx = ifp->if_softc;
1206 if_shared_ctx_t sctx = ctx->ifc_sctx;
1207 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
1208 iflib_rxq_t rxq = &ctx->ifc_rxqs[kring->ring_id];
1251 avail = ctx->isc_rxd_available(ctx->ifc_softc,
1261 ri.iri_ifp = ctx->ifc_ifp;
1264 error = ctx->isc_rxd_pkt_get(ctx->ifc_softc, &ri);
1324 if_ctx_t ctx = na->ifp->if_softc;
1326 CTX_LOCK(ctx);
1328 IFDI_INTR_ENABLE(ctx);
1330 IFDI_INTR_DISABLE(ctx);
1332 CTX_UNLOCK(ctx);
1336 iflib_netmap_attach(if_ctx_t ctx)
1342 na.ifp = ctx->ifc_ifp;
1344 MPASS(ctx->ifc_softc_ctx.isc_ntxqsets);
1345 MPASS(ctx->ifc_softc_ctx.isc_nrxqsets);
1347 na.num_tx_desc = iflib_num_tx_descs(ctx);
1348 na.num_rx_desc = iflib_num_rx_descs(ctx);
1354 na.num_tx_rings = ctx->ifc_softc_ctx.isc_ntxqsets;
1355 na.num_rx_rings = ctx->ifc_softc_ctx.isc_nrxqsets;
1360 iflib_netmap_txq_init(if_ctx_t ctx, iflib_txq_t txq)
1362 struct netmap_adapter *na = NA(ctx->ifc_ifp);
1368 for (int i = 0; i < ctx->ifc_softc_ctx.isc_ntxd[0]; i++) {
1384 iflib_netmap_rxq_init(if_ctx_t ctx, iflib_rxq_t rxq)
1386 struct netmap_adapter *na = NA(ctx->ifc_ifp);
1402 if_ctx_t ctx = txq->ift_ctx;
1408 netmap_tx_irq(ctx->ifc_ifp, txq->ift_id);
1414 #define iflib_netmap_txq_init(ctx, txq) (0)
1415 #define iflib_netmap_rxq_init(ctx, rxq) (0)
1420 #define iflib_netmap_attach(ctx) (0)
1465 iflib_dma_alloc_align(if_ctx_t ctx, int size, int align, iflib_dma_info_t dma, int mapflags)
1468 device_t dev = ctx->ifc_dev;
1522 iflib_dma_alloc(if_ctx_t ctx, int size, iflib_dma_info_t dma, int mapflags)
1524 if_shared_ctx_t sctx = ctx->ifc_sctx;
1528 return (iflib_dma_alloc_align(ctx, size, sctx->isc_q_align, dma, mapflags));
1532 iflib_dma_alloc_multi(if_ctx_t ctx, int *sizes, iflib_dma_info_t *dmalist, int mapflags, int count)
1539 if ((err = iflib_dma_alloc(ctx, sizes[i], *dmaiter, mapflags)) != 0)
1599 if_ctx_t ctx;
1614 ctx = rxq->ifr_ctx;
1615 sc = ctx->ifc_softc;
1617 intr_legacy = !!(ctx->ifc_flags & IFC_LEGACY);
1621 txq = &ctx->ifc_txqs[txqid];
1624 if (!ctx->isc_txd_credits_update(sc, txqid, false)) {
1628 IFDI_TX_QUEUE_INTR_ENABLE(ctx, txqid);
1633 if (ctx->ifc_sctx->isc_flags & IFLIB_HAS_RXCQ)
1637 if (iflib_rxd_avail(ctx, rxq, cidx, 1))
1643 IFDI_RX_QUEUE_INTR_ENABLE(ctx, rxq->ifr_id);
1647 IFDI_INTR_ENABLE(ctx);
1670 _iflib_irq_alloc(if_ctx_t ctx, if_irq_t irq, int rid,
1676 device_t dev = ctx->ifc_dev;
1680 if (ctx->ifc_flags & IFC_LEGACY)
1718 if_ctx_t ctx = txq->ift_ctx;
1719 if_shared_ctx_t sctx = ctx->ifc_sctx;
1720 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
1721 device_t dev = ctx->ifc_dev;
1729 if (if_getcapabilities(ctx->ifc_ifp) & IFCAP_VLAN_MTU)
1734 if (if_getcapabilities(ctx->ifc_ifp) & IFCAP_TSO) {
1759 tso = (if_getcapabilities(ctx->ifc_ifp) & IFCAP_TSO) != 0;
1824 iflib_tx_structures_free(ctx);
1829 iflib_txsd_destroy(if_ctx_t ctx, iflib_txq_t txq, int i)
1854 if_ctx_t ctx = txq->ift_ctx;
1857 iflib_txsd_destroy(ctx, txq, i);
1892 iflib_txsd_free(if_ctx_t ctx, iflib_txq_t txq, int i)
1919 if_ctx_t ctx = txq->ift_ctx;
1920 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
1921 if_shared_ctx_t sctx = ctx->ifc_sctx;
1938 IFDI_TXQ_SETUP(ctx, txq->ift_id);
1959 if_ctx_t ctx = rxq->ifr_ctx;
1960 if_shared_ctx_t sctx = ctx->ifc_sctx;
1961 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
1962 device_t dev = ctx->ifc_dev;
2043 iflib_rx_structures_free(ctx);
2069 * @ctx: the iflib context
2078 iflib_fl_refill(if_ctx_t ctx, iflib_fl_t fl, int count)
2190 ctx->isc_rxd_refill(ctx->ifc_softc, &iru);
2202 ctx->isc_rxd_refill(ctx->ifc_softc, &iru);
2209 ctx->isc_rxd_flush(ctx->ifc_softc, fl->ifl_rxq->ifr_id,
2224 iflib_fl_refill_all(if_ctx_t ctx, iflib_fl_t fl)
2246 return (iflib_fl_refill(ctx, fl, reclaimable));
2251 iflib_in_detach(if_ctx_t ctx)
2255 STATE_LOCK(ctx);
2256 in_detach = !!(ctx->ifc_flags & IFC_IN_DETACH);
2257 STATE_UNLOCK(ctx);
2324 if_ctx_t ctx = rxq->ifr_ctx;
2325 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
2339 fl->ifl_buf_size = ctx->ifc_rx_mbuf_sz;
2345 if (fl->ifl_buf_size > ctx->ifc_max_fl_buf_size)
2346 ctx->ifc_max_fl_buf_size = fl->ifl_buf_size;
2359 (void)iflib_fl_refill(ctx, fl, min(128, fl->ifl_size - 1));
2430 if_ctx_t ctx = txq->ift_ctx;
2431 if_softc_ctx_t sctx = &ctx->ifc_softc_ctx;
2434 if (!(if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_RUNNING))
2444 IFDI_TIMER(ctx, txq->ift_id);
2452 KASSERT(ctx->ifc_link_state == LINK_STATE_UP,
2463 if (if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_RUNNING)
2469 device_printf(ctx->ifc_dev,
2472 STATE_LOCK(ctx);
2473 if_setdrvflagbits(ctx->ifc_ifp, IFF_DRV_OACTIVE, IFF_DRV_RUNNING);
2474 ctx->ifc_flags |= (IFC_DO_WATCHDOG|IFC_DO_RESET);
2475 iflib_admin_intr_deferred(ctx);
2476 STATE_UNLOCK(ctx);
2490 iflib_calc_rx_mbuf_sz(if_ctx_t ctx)
2492 if_softc_ctx_t sctx = &ctx->ifc_softc_ctx;
2498 ctx->ifc_rx_mbuf_sz =
2503 iflib_get_rx_mbuf_sz(if_ctx_t ctx)
2506 return (ctx->ifc_rx_mbuf_sz);
2510 iflib_init_locked(if_ctx_t ctx)
2512 if_softc_ctx_t sctx = &ctx->ifc_softc_ctx;
2513 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
2514 if_t ifp = ctx->ifc_ifp;
2521 IFDI_INTR_DISABLE(ctx);
2542 for (i = 0, txq = ctx->ifc_txqs; i < sctx->isc_ntxqsets; i++, txq++) {
2549 iflib_netmap_txq_init(ctx, txq);
2557 iflib_calc_rx_mbuf_sz(ctx);
2562 IFDI_INIT(ctx);
2564 for (i = 0, rxq = ctx->ifc_rxqs; i < sctx->isc_nrxqsets; i++, rxq++) {
2565 if (iflib_netmap_rxq_init(ctx, rxq) > 0) {
2571 device_printf(ctx->ifc_dev,
2579 if_setdrvflagbits(ctx->ifc_ifp, IFF_DRV_RUNNING, IFF_DRV_OACTIVE);
2580 IFDI_INTR_ENABLE(ctx);
2581 txq = ctx->ifc_txqs;
2593 if_ctx_t ctx = if_getsoftc(ifp);
2596 CTX_LOCK(ctx);
2597 if ((err = IFDI_MEDIA_CHANGE(ctx)) == 0)
2598 iflib_if_init_locked(ctx);
2599 CTX_UNLOCK(ctx);
2606 if_ctx_t ctx = if_getsoftc(ifp);
2608 CTX_LOCK(ctx);
2609 IFDI_UPDATE_ADMIN_STATUS(ctx);
2610 IFDI_MEDIA_STATUS(ctx, ifmr);
2611 CTX_UNLOCK(ctx);
2615 iflib_stop(if_ctx_t ctx)
2617 iflib_txq_t txq = ctx->ifc_txqs;
2618 iflib_rxq_t rxq = ctx->ifc_rxqs;
2619 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
2620 if_shared_ctx_t sctx = ctx->ifc_sctx;
2626 if_setdrvflagbits(ctx->ifc_ifp, IFF_DRV_OACTIVE, IFF_DRV_RUNNING);
2628 IFDI_INTR_DISABLE(ctx);
2630 IFDI_STOP(ctx);
2638 netmap_disable_all_rings(ctx->ifc_ifp);
2656 iflib_txsd_free(ctx, txq, j);
2981 if_ctx_t ctx = rxq->ifr_ctx;
2982 if_shared_ctx_t sctx = ctx->ifc_sctx;
2983 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
3004 ifp = ctx->ifc_ifp;
3012 if ((avail = iflib_rxd_avail(ctx, rxq, *cidxp, budget)) == 0) {
3014 retval |= iflib_fl_refill_all(ctx, fl);
3022 if (__predict_false(!CTX_ACTIVE(ctx))) {
3034 err = ctx->isc_rxd_pkt_get(ctx->ifc_softc, &ri);
3058 avail = iflib_rxd_avail(ctx, rxq, *cidxp, budget_left);
3074 retval |= iflib_fl_refill_all(ctx, fl);
3137 if (avail != 0 || iflib_rxd_avail(ctx, rxq, *cidxp, 1) != 0)
3141 STATE_LOCK(ctx);
3142 ctx->ifc_flags |= IFC_DO_RESET;
3143 iflib_admin_intr_deferred(ctx);
3144 STATE_UNLOCK(ctx);
3185 #define FIRST_QSET(ctx) 0
3186 #define NTXQSETS(ctx) ((ctx)->ifc_softc_ctx.isc_ntxqsets)
3187 #define NRXQSETS(ctx) ((ctx)->ifc_softc_ctx.isc_nrxqsets)
3188 #define QIDX(ctx, m) ((((m)->m_pkthdr.flowid & ctx->ifc_softc_ctx.isc_rss_table_mask) % NTXQSETS(ctx)) + FIRST_QSET(ctx))
3192 #define RECLAIM_THRESH(ctx) ((ctx)->ifc_sctx->isc_tx_reclaim_thresh)
3193 #define MAX_TX_DESC(ctx) MAX((ctx)->ifc_softc_ctx.isc_tx_tso_segments_max, \
3194 (ctx)->ifc_softc_ctx.isc_tx_nsegments)
3199 if_ctx_t ctx = txq->ift_ctx;
3205 if (ring || (txq->ift_db_pending >= max) || (TXQ_AVAIL(txq) <= MAX_TX_DESC(ctx) + 2)) {
3215 ctx->isc_txd_flush(ctx->ifc_softc, txq->ift_id, dbval);
3509 if_ctx_t ctx;
3521 ctx = txq->ift_ctx;
3522 sctx = ctx->ifc_sctx;
3523 scctx = &ctx->ifc_softc_ctx;
3534 if (ctx->ifc_flags & IFC_PREFETCH) {
3536 if (!(ctx->ifc_flags & IFLIB_HAS_TXCQ)) {
3562 err = iflib_ether_pad(ctx->ifc_dev, m_headp, scctx->isc_min_frame_size);
3654 iflib_no_tx_batch || (TXQ_AVAIL(txq) - nsegs) <= MAX_TX_DESC(ctx) + 2) {
3666 if ((err = ctx->isc_txd_encap(ctx->ifc_softc, &pi)) == 0) {
3775 if_ctx_t ctx = txq->ift_ctx;
3783 iflib_tx_credits_update(ctx, txq);
3834 if_ctx_t ctx = txq->ift_ctx;
3836 if (TXQ_AVAIL(txq) > MAX_TX_DESC(ctx) + 2)
3840 return (ctx->isc_txd_credits_update(ctx->ifc_softc, txq->ift_id,
3848 if_ctx_t ctx = txq->ift_ctx;
3849 if_t ifp = ctx->ifc_ifp;
3856 !LINK_ACTIVE(ctx))) {
3860 reclaimed = iflib_completed_tx_reclaim(txq, RECLAIM_THRESH(ctx));
3864 if (__predict_false(ctx->ifc_flags & IFC_QFLUSH)) {
3877 if (__predict_false(if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_OACTIVE)) {
3896 avail, ctx->ifc_flags, TXQ_AVAIL(txq));
3898 do_prefetch = (ctx->ifc_flags & IFC_PREFETCH);
3900 for (i = 0; i < count && TXQ_AVAIL(txq) >= MAX_TX_DESC(ctx) + 2; i++) {
4003 if_ctx_t ctx = txq->ift_ctx;
4004 if_t ifp = ctx->ifc_ifp;
4005 int abdicate = ctx->ifc_sysctl_tx_abdicate;
4033 if (ctx->ifc_flags & IFC_LEGACY)
4034 IFDI_INTR_ENABLE(ctx);
4036 IFDI_TX_QUEUE_INTR_ENABLE(ctx, txq->ift_id);
4043 if_ctx_t ctx = rxq->ifr_ctx;
4055 if (__predict_false(!(if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_RUNNING)))
4058 nmirq = netmap_rx_irq(ctx->ifc_ifp, rxq->ifr_id, &work);
4064 budget = ctx->ifc_sysctl_rx_budget;
4072 if (ctx->ifc_flags & IFC_LEGACY)
4073 IFDI_INTR_ENABLE(ctx);
4075 IFDI_RX_QUEUE_INTR_ENABLE(ctx, rxq->ifr_id);
4078 if (__predict_false(!(if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_RUNNING)))
4094 if_ctx_t ctx = context;
4095 if_softc_ctx_t sctx = &ctx->ifc_softc_ctx;
4100 STATE_LOCK(ctx);
4101 running = (if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_RUNNING);
4102 oactive = (if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_OACTIVE);
4103 do_reset = (ctx->ifc_flags & IFC_DO_RESET);
4104 do_watchdog = (ctx->ifc_flags & IFC_DO_WATCHDOG);
4105 in_detach = (ctx->ifc_flags & IFC_IN_DETACH);
4106 ctx->ifc_flags &= ~(IFC_DO_RESET|IFC_DO_WATCHDOG);
4107 STATE_UNLOCK(ctx);
4109 if ((!running && !oactive) && !(ctx->ifc_sctx->isc_flags & IFLIB_ADMIN_ALWAYS_RUN))
4114 CTX_LOCK(ctx);
4115 for (txq = ctx->ifc_txqs, i = 0; i < sctx->isc_ntxqsets; i++, txq++) {
4121 ctx->ifc_watchdog_events++;
4122 IFDI_WATCHDOG_RESET(ctx);
4124 IFDI_UPDATE_ADMIN_STATUS(ctx);
4125 for (txq = ctx->ifc_txqs, i = 0; i < sctx->isc_ntxqsets; i++, txq++) {
4129 IFDI_LINK_INTR_ENABLE(ctx);
4131 iflib_if_init_locked(ctx);
4132 CTX_UNLOCK(ctx);
4134 if (LINK_ACTIVE(ctx) == 0)
4136 for (txq = ctx->ifc_txqs, i = 0; i < sctx->isc_ntxqsets; i++, txq++)
4143 if_ctx_t ctx = context;
4145 if (!(if_getdrvflags(ctx->ifc_ifp) & IFF_DRV_RUNNING) &&
4146 !(ctx->ifc_sctx->isc_flags & IFLIB_ADMIN_ALWAYS_RUN))
4149 CTX_LOCK(ctx);
4150 IFDI_VFLR_HANDLE(ctx);
4151 CTX_UNLOCK(ctx);
4159 if_ctx_t ctx;
4162 ctx = info->iidi_ctx;
4165 CTX_LOCK(ctx);
4166 err = IFDI_SYSCTL_INT_DELAY(ctx, info);
4167 CTX_UNLOCK(ctx);
4178 iflib_if_init_locked(if_ctx_t ctx)
4180 iflib_stop(ctx);
4181 iflib_init_locked(ctx);
4187 if_ctx_t ctx = arg;
4189 CTX_LOCK(ctx);
4190 iflib_if_init_locked(ctx);
4191 CTX_UNLOCK(ctx);
4197 if_ctx_t ctx = if_getsoftc(ifp);
4201 int abdicate = ctx->ifc_sysctl_tx_abdicate;
4203 if (__predict_false((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || !LINK_ACTIVE(ctx))) {
4212 if ((NTXQSETS(ctx) > 1) && M_HASHTYPE_GET(m) && !ALTQ_IS_ENABLED(&ifp->if_snd))
4213 qidx = QIDX(ctx, m);
4217 txq = &ctx->ifc_txqs[qidx];
4330 if_ctx_t ctx = if_getsoftc(ifp);
4331 iflib_txq_t txq = ctx->ifc_txqs;
4334 STATE_LOCK(ctx);
4335 ctx->ifc_flags |= IFC_QFLUSH;
4336 STATE_UNLOCK(ctx);
4337 for (i = 0; i < NTXQSETS(ctx); i++, txq++)
4340 STATE_LOCK(ctx);
4341 ctx->ifc_flags &= ~IFC_QFLUSH;
4342 STATE_UNLOCK(ctx);
4359 if_ctx_t ctx = if_getsoftc(ifp);
4393 CTX_LOCK(ctx);
4395 CTX_UNLOCK(ctx);
4400 iflib_stop(ctx);
4402 if ((err = IFDI_MTU_SET(ctx, ifr->ifr_mtu)) == 0) {
4403 STATE_LOCK(ctx);
4404 if (ifr->ifr_mtu > ctx->ifc_max_fl_buf_size)
4405 ctx->ifc_flags |= IFC_MULTISEG;
4407 ctx->ifc_flags &= ~IFC_MULTISEG;
4408 STATE_UNLOCK(ctx);
4411 iflib_init_locked(ctx);
4412 STATE_LOCK(ctx);
4414 STATE_UNLOCK(ctx);
4415 CTX_UNLOCK(ctx);
4418 CTX_LOCK(ctx);
4421 if ((if_getflags(ifp) ^ ctx->ifc_if_flags) &
4423 CTX_UNLOCK(ctx);
4424 err = IFDI_PROMISC_SET(ctx, if_getflags(ifp));
4425 CTX_LOCK(ctx);
4430 iflib_stop(ctx);
4432 ctx->ifc_if_flags = if_getflags(ifp);
4433 CTX_UNLOCK(ctx);
4438 CTX_LOCK(ctx);
4439 IFDI_INTR_DISABLE(ctx);
4440 IFDI_MULTI_SET(ctx);
4441 IFDI_INTR_ENABLE(ctx);
4442 CTX_UNLOCK(ctx);
4446 CTX_LOCK(ctx);
4447 IFDI_MEDIA_SET(ctx);
4448 CTX_UNLOCK(ctx);
4454 err = ifmedia_ioctl(ifp, ifr, ctx->ifc_mediap, command);
4473 if ((err = IFDI_I2C_REQ(ctx, &i2c)) == 0)
4485 mask &= ctx->ifc_softc_ctx.isc_capabilities | IFCAP_MEXTPG;
4498 setmask |= ctx->ifc_softc_ctx.isc_capabilities &
4506 CTX_LOCK(ctx);
4509 iflib_stop(ctx);
4510 STATE_LOCK(ctx);
4512 STATE_UNLOCK(ctx);
4514 iflib_init_locked(ctx);
4515 STATE_LOCK(ctx);
4517 STATE_UNLOCK(ctx);
4518 CTX_UNLOCK(ctx);
4526 CTX_LOCK(ctx);
4527 err = IFDI_PRIV_IOCTL(ctx, command, data);
4528 CTX_UNLOCK(ctx);
4535 iflib_if_init(ctx);
4542 if_ctx_t ctx = if_getsoftc(ifp);
4544 return (IFDI_GET_COUNTER(ctx, cnt));
4556 if_ctx_t ctx = if_getsoftc(ifp);
4558 if ((void *)ctx != arg)
4564 if (iflib_in_detach(ctx))
4567 CTX_LOCK(ctx);
4569 if (IFDI_NEEDS_RESTART(ctx, IFLIB_RESTART_VLAN_CONFIG))
4570 iflib_stop(ctx);
4571 IFDI_VLAN_REGISTER(ctx, vtag);
4573 if (IFDI_NEEDS_RESTART(ctx, IFLIB_RESTART_VLAN_CONFIG))
4574 iflib_init_locked(ctx);
4575 CTX_UNLOCK(ctx);
4581 if_ctx_t ctx = if_getsoftc(ifp);
4583 if ((void *)ctx != arg)
4589 CTX_LOCK(ctx);
4591 if (IFDI_NEEDS_RESTART(ctx, IFLIB_RESTART_VLAN_CONFIG))
4592 iflib_stop(ctx);
4593 IFDI_VLAN_UNREGISTER(ctx, vtag);
4595 if (IFDI_NEEDS_RESTART(ctx, IFLIB_RESTART_VLAN_CONFIG))
4596 iflib_init_locked(ctx);
4597 CTX_UNLOCK(ctx);
4603 if_ctx_t ctx = arg;
4605 CTX_LOCK(ctx);
4606 IFDI_LED_FUNC(ctx, onoff);
4607 CTX_UNLOCK(ctx);
4676 iflib_reset_qvalues(if_ctx_t ctx)
4678 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
4679 if_shared_ctx_t sctx = ctx->ifc_sctx;
4680 device_t dev = ctx->ifc_dev;
4683 if (ctx->ifc_sysctl_ntxqs != 0)
4684 scctx->isc_ntxqsets = ctx->ifc_sysctl_ntxqs;
4685 if (ctx->ifc_sysctl_nrxqs != 0)
4686 scctx->isc_nrxqsets = ctx->ifc_sysctl_nrxqs;
4689 if (ctx->ifc_sysctl_ntxds[i] != 0)
4690 scctx->isc_ntxd[i] = ctx->ifc_sysctl_ntxds[i];
4696 if (ctx->ifc_sysctl_nrxds[i] != 0)
4697 scctx->isc_nrxd[i] = ctx->ifc_sysctl_nrxds[i];
4740 iflib_add_pfil(if_ctx_t ctx)
4751 pa.pa_headname = ctx->ifc_ifp->if_xname;
4754 for (i = 0, rxq = ctx->ifc_rxqs; i < NRXQSETS(ctx); i++, rxq++) {
4761 iflib_rem_pfil(if_ctx_t ctx)
4768 rxq = ctx->ifc_rxqs;
4770 for (i = 0; i < NRXQSETS(ctx); i++, rxq++) {
4780 * Advance forward by n members of the cpuset ctx->ifc_cpus starting from
4784 cpuid_advance(if_ctx_t ctx, unsigned int cpuid, unsigned int n)
4790 MPASS(CPU_ISSET(cpuid, &ctx->ifc_cpus));
4793 MPASS(!CPU_EMPTY(&ctx->ifc_cpus));
4795 first_valid = CPU_FFS(&ctx->ifc_cpus) - 1;
4796 last_valid = CPU_FLS(&ctx->ifc_cpus) - 1;
4797 n = n % CPU_COUNT(&ctx->ifc_cpus);
4803 } while (!CPU_ISSET(cpuid, &ctx->ifc_cpus));
4918 get_cpuid_for_queue(if_ctx_t ctx, unsigned int base_cpuid, unsigned int qid,
4921 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
4924 if (ctx->ifc_sysctl_separate_txrx) {
4934 if (ctx->ifc_sysctl_use_logical_cores &&
4935 ctx->ifc_cpus_are_physical_cores &&
4940 rx_cpuid = cpuid_advance(ctx, base_cpuid, qid);
4964 return (cpuid_advance(ctx, base_cpuid, core_index));
4971 get_ctx_core_offset(if_ctx_t ctx)
4974 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
4978 unsigned int base_cpuid = ctx->ifc_sysctl_core_offset;
4983 first_valid = CPU_FFS(&ctx->ifc_cpus) - 1;
4984 last_valid = CPU_FLS(&ctx->ifc_cpus) - 1;
5007 if (!CPU_ISSET(base_cpuid, &ctx->ifc_cpus)) {
5015 while (!CPU_ISSET(base_cpuid, &ctx->ifc_cpus))
5040 CPU_SET(get_cpuid_for_queue(ctx, first_valid, i, true),
5043 CPU_SET(get_cpuid_for_queue(ctx, first_valid, i, false),
5045 CPU_AND(&assigned_cpus, &ctx->ifc_cpus);
5050 if (CPU_CMP(&ctx->ifc_cpus, &op->set) == 0) {
5052 op->next_cpuid = cpuid_advance(ctx, op->next_cpuid,
5064 device_printf(ctx->ifc_dev,
5067 op->next_cpuid = cpuid_advance(ctx, base_cpuid,
5070 CPU_COPY(&ctx->ifc_cpus, &op->set);
5083 unref_ctx_core_offset(if_ctx_t ctx)
5090 if (CPU_CMP(&ctx->ifc_cpus, &op->set) == 0) {
5107 if_ctx_t ctx;
5115 ctx = malloc(sizeof(* ctx), M_IFLIB, M_WAITOK|M_ZERO);
5119 device_set_softc(dev, ctx);
5120 ctx->ifc_flags |= IFC_SC_ALLOCATED;
5123 ctx->ifc_sctx = sctx;
5124 ctx->ifc_dev = dev;
5125 ctx->ifc_softc = sc;
5127 if ((err = iflib_register(ctx)) != 0) {
5131 iflib_add_device_sysctl_pre(ctx);
5133 scctx = &ctx->ifc_softc_ctx;
5134 ifp = ctx->ifc_ifp;
5136 iflib_reset_qvalues(ctx);
5137 CTX_LOCK(ctx);
5138 if ((err = IFDI_ATTACH_PRE(ctx)) != 0) {
5143 ctx->ifc_txrx = *scctx->isc_txrx;
5146 ctx->ifc_mediap = scctx->isc_media;
5163 num_txd = iflib_num_tx_descs(ctx);
5164 num_rxd = iflib_num_rx_descs(ctx);
5203 GROUPTASK_INIT(&ctx->ifc_admin_task, 0, _task_fn_admin, ctx);
5205 taskqgroup_attach(qgroup_if_config_tqg, &ctx->ifc_admin_task, ctx,
5210 if (bus_get_cpus(dev, INTR_CPUS, sizeof(ctx->ifc_cpus), &ctx->ifc_cpus) != 0) {
5212 CPU_COPY(&all_cpus, &ctx->ifc_cpus);
5213 ctx->ifc_cpus_are_physical_cores = false;
5215 ctx->ifc_cpus_are_physical_cores = true;
5216 MPASS(CPU_COUNT(&ctx->ifc_cpus) > 0);
5230 msix = iflib_msix_init(ctx);
5239 if ((err = iflib_queues_alloc(ctx))) {
5244 if ((err = iflib_qset_structures_setup(ctx)))
5250 ctx->ifc_sysctl_core_offset = get_ctx_core_offset(ctx);
5259 kobj_method = kobj_lookup_method(ctx->ops.cls, NULL,
5261 kobj_method = kobj_lookup_method(((kobj_t)ctx)->ops->cls, NULL,
5272 kobj_method = kobj_lookup_method(ctx->ops.cls, NULL,
5274 kobj_method = kobj_lookup_method(((kobj_t)ctx)->ops->cls, NULL,
5289 err = IFDI_MSIX_INTR_ASSIGN(ctx, msix);
5301 if ((err = iflib_legacy_setup(ctx, ctx->isc_legacy_intr, ctx->ifc_softc, &rid, "irq0")) != 0) {
5312 ether_ifattach(ctx->ifc_ifp, ctx->ifc_mac.octet);
5314 if ((err = IFDI_ATTACH_POST(ctx)) != 0) {
5327 if ((err = iflib_netmap_attach(ctx))) {
5328 device_printf(ctx->ifc_dev, "netmap attach failed: %d\n", err);
5331 *ctxp = ctx;
5333 DEBUGNET_SET(ctx->ifc_ifp, iflib);
5335 if_setgetcounterfn(ctx->ifc_ifp, iflib_if_get_counter);
5336 iflib_add_device_sysctl_post(ctx);
5337 iflib_add_pfil(ctx);
5338 ctx->ifc_flags |= IFC_INIT_DONE;
5339 CTX_UNLOCK(ctx);
5344 ether_ifdetach(ctx->ifc_ifp);
5346 iflib_tqg_detach(ctx);
5347 iflib_tx_structures_free(ctx);
5348 iflib_rx_structures_free(ctx);
5349 IFDI_DETACH(ctx);
5350 IFDI_QUEUES_FREE(ctx);
5352 iflib_free_intr_mem(ctx);
5354 CTX_UNLOCK(ctx);
5355 iflib_deregister(ctx);
5357 device_set_softc(ctx->ifc_dev, NULL);
5358 if (ctx->ifc_flags & IFC_SC_ALLOCATED)
5359 free(ctx->ifc_softc, M_IFLIB);
5360 free(ctx, M_IFLIB);
5370 if_ctx_t ctx;
5376 ctx = malloc(sizeof(*ctx), M_IFLIB, M_WAITOK|M_ZERO);
5378 ctx->ifc_flags |= IFC_SC_ALLOCATED;
5380 ctx->ifc_flags |= IFC_PSEUDO;
5382 ctx->ifc_sctx = sctx;
5383 ctx->ifc_softc = sc;
5384 ctx->ifc_dev = dev;
5386 if ((err = iflib_register(ctx)) != 0) {
5390 iflib_add_device_sysctl_pre(ctx);
5392 scctx = &ctx->ifc_softc_ctx;
5393 ifp = ctx->ifc_ifp;
5395 iflib_reset_qvalues(ctx);
5396 CTX_LOCK(ctx);
5397 if ((err = IFDI_ATTACH_PRE(ctx)) != 0) {
5403 ether_gen_addr(ifp, &ctx->ifc_mac);
5405 if ((err = IFDI_CLONEATTACH(ctx, clctx->cc_ifc, clctx->cc_name,
5420 ifmedia_add(ctx->ifc_mediap, IFM_ETHER | IFM_AUTO, 0, NULL);
5421 ifmedia_set(ctx->ifc_mediap, IFM_ETHER | IFM_AUTO);
5423 ether_ifattach(ctx->ifc_ifp, ctx->ifc_mac.octet);
5425 if_attach(ctx->ifc_ifp);
5426 bpfattach(ctx->ifc_ifp, DLT_NULL, sizeof(u_int32_t));
5429 if ((err = IFDI_ATTACH_POST(ctx)) != 0) {
5433 *ctxp = ctx;
5444 if_setgetcounterfn(ctx->ifc_ifp, iflib_if_get_counter);
5445 iflib_add_device_sysctl_post(ctx);
5446 ctx->ifc_flags |= IFC_INIT_DONE;
5447 CTX_UNLOCK(ctx);
5450 ifmedia_add(ctx->ifc_mediap, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
5451 ifmedia_add(ctx->ifc_mediap, IFM_ETHER | IFM_AUTO, 0, NULL);
5452 ifmedia_set(ctx->ifc_mediap, IFM_ETHER | IFM_AUTO);
5455 ctx->ifc_txrx = *scctx->isc_txrx;
5462 num_txd = iflib_num_tx_descs(ctx);
5463 num_rxd = iflib_num_rx_descs(ctx);
5502 GROUPTASK_INIT(&ctx->ifc_admin_task, 0, _task_fn_admin, ctx);
5504 taskqgroup_attach(qgroup_if_config_tqg, &ctx->ifc_admin_task, ctx,
5511 if ((err = iflib_queues_alloc(ctx))) {
5516 if ((err = iflib_qset_structures_setup(ctx))) {
5524 ether_ifattach(ctx->ifc_ifp, ctx->ifc_mac.octet);
5525 if ((err = IFDI_ATTACH_POST(ctx)) != 0) {
5540 IFDI_RX_CLSET(ctx, 0, i, ctx->ifc_rxqs[i].ifr_fl[0].ifl_sds.ifsd_cl);
5542 *ctxp = ctx;
5544 if_setgetcounterfn(ctx->ifc_ifp, iflib_if_get_counter);
5545 iflib_add_device_sysctl_post(ctx);
5546 ctx->ifc_flags |= IFC_INIT_DONE;
5547 CTX_UNLOCK(ctx);
5551 ether_ifdetach(ctx->ifc_ifp);
5553 iflib_tqg_detach(ctx);
5554 iflib_tx_structures_free(ctx);
5555 iflib_rx_structures_free(ctx);
5557 IFDI_DETACH(ctx);
5558 IFDI_QUEUES_FREE(ctx);
5560 CTX_UNLOCK(ctx);
5561 iflib_deregister(ctx);
5563 free(ctx->ifc_softc, M_IFLIB);
5564 free(ctx, M_IFLIB);
5569 iflib_pseudo_deregister(if_ctx_t ctx)
5571 if_t ifp = ctx->ifc_ifp;
5572 if_shared_ctx_t sctx = ctx->ifc_sctx;
5575 iflib_unregister_vlan_handlers(ctx);
5585 iflib_tqg_detach(ctx);
5586 iflib_tx_structures_free(ctx);
5587 iflib_rx_structures_free(ctx);
5588 IFDI_DETACH(ctx);
5589 IFDI_QUEUES_FREE(ctx);
5591 iflib_deregister(ctx);
5593 if (ctx->ifc_flags & IFC_SC_ALLOCATED)
5594 free(ctx->ifc_softc, M_IFLIB);
5595 free(ctx, M_IFLIB);
5602 if_ctx_t ctx;
5610 return (iflib_device_register(dev, NULL, sctx, &ctx));
5614 iflib_device_deregister(if_ctx_t ctx)
5616 if_t ifp = ctx->ifc_ifp;
5617 device_t dev = ctx->ifc_dev;
5625 if (!CTX_IS_VF(ctx) && pci_iov_detach(dev) != 0) {
5631 STATE_LOCK(ctx);
5632 ctx->ifc_flags |= IFC_IN_DETACH;
5633 STATE_UNLOCK(ctx);
5636 iflib_unregister_vlan_handlers(ctx);
5641 CTX_LOCK(ctx);
5642 iflib_stop(ctx);
5643 CTX_UNLOCK(ctx);
5645 iflib_rem_pfil(ctx);
5646 if (ctx->ifc_led_dev != NULL)
5647 led_destroy(ctx->ifc_led_dev);
5649 iflib_tqg_detach(ctx);
5650 iflib_tx_structures_free(ctx);
5651 iflib_rx_structures_free(ctx);
5653 CTX_LOCK(ctx);
5654 IFDI_DETACH(ctx);
5655 IFDI_QUEUES_FREE(ctx);
5656 CTX_UNLOCK(ctx);
5659 iflib_free_intr_mem(ctx);
5663 iflib_deregister(ctx);
5665 device_set_softc(ctx->ifc_dev, NULL);
5666 if (ctx->ifc_flags & IFC_SC_ALLOCATED)
5667 free(ctx->ifc_softc, M_IFLIB);
5668 unref_ctx_core_offset(ctx);
5669 free(ctx, M_IFLIB);
5674 iflib_tqg_detach(if_ctx_t ctx)
5683 for (txq = ctx->ifc_txqs, i = 0; i < NTXQSETS(ctx); i++, txq++) {
5691 for (i = 0, rxq = ctx->ifc_rxqs; i < NRXQSETS(ctx); i++, rxq++) {
5696 if (ctx->ifc_admin_task.gt_uniq != NULL)
5697 taskqgroup_detach(tqg, &ctx->ifc_admin_task);
5698 if (ctx->ifc_vflr_task.gt_uniq != NULL)
5699 taskqgroup_detach(tqg, &ctx->ifc_vflr_task);
5703 iflib_free_intr_mem(if_ctx_t ctx)
5706 if (ctx->ifc_softc_ctx.isc_intr != IFLIB_INTR_MSIX) {
5707 iflib_irq_free(ctx, &ctx->ifc_legacy_irq);
5709 if (ctx->ifc_softc_ctx.isc_intr != IFLIB_INTR_LEGACY) {
5710 pci_release_msi(ctx->ifc_dev);
5712 if (ctx->ifc_msix_mem != NULL) {
5713 bus_release_resource(ctx->ifc_dev, SYS_RES_MEMORY,
5714 rman_get_rid(ctx->ifc_msix_mem), ctx->ifc_msix_mem);
5715 ctx->ifc_msix_mem = NULL;
5722 if_ctx_t ctx = device_get_softc(dev);
5724 return (iflib_device_deregister(ctx));
5730 if_ctx_t ctx = device_get_softc(dev);
5732 CTX_LOCK(ctx);
5733 IFDI_SUSPEND(ctx);
5734 CTX_UNLOCK(ctx);
5741 if_ctx_t ctx = device_get_softc(dev);
5743 CTX_LOCK(ctx);
5744 IFDI_SHUTDOWN(ctx);
5745 CTX_UNLOCK(ctx);
5753 if_ctx_t ctx = device_get_softc(dev);
5754 iflib_txq_t txq = ctx->ifc_txqs;
5756 CTX_LOCK(ctx);
5757 IFDI_RESUME(ctx);
5758 iflib_if_init_locked(ctx);
5759 CTX_UNLOCK(ctx);
5760 for (int i = 0; i < NTXQSETS(ctx); i++, txq++)
5770 if_ctx_t ctx = device_get_softc(dev);
5772 CTX_LOCK(ctx);
5773 error = IFDI_IOV_INIT(ctx, num_vfs, params);
5774 CTX_UNLOCK(ctx);
5782 if_ctx_t ctx = device_get_softc(dev);
5784 CTX_LOCK(ctx);
5785 IFDI_IOV_UNINIT(ctx);
5786 CTX_UNLOCK(ctx);
5793 if_ctx_t ctx = device_get_softc(dev);
5795 CTX_LOCK(ctx);
5796 error = IFDI_IOV_VF_ADD(ctx, vfnum, params);
5797 CTX_UNLOCK(ctx);
5892 iflib_register(if_ctx_t ctx)
5894 if_shared_ctx_t sctx = ctx->ifc_sctx;
5896 device_t dev = ctx->ifc_dev;
5904 CTX_LOCK_INIT(ctx);
5905 STATE_LOCK_INIT(ctx, device_get_nameunit(ctx->ifc_dev));
5913 ifp = ctx->ifc_ifp = if_alloc(type);
5922 kobj_init((kobj_t) ctx, (kobj_class_t) driver);
5926 if_setsoftc(ifp, ctx);
5950 ctx->ifc_vlan_attach_event =
5951 EVENTHANDLER_REGISTER(vlan_config, iflib_vlan_register, ctx,
5953 ctx->ifc_vlan_detach_event =
5954 EVENTHANDLER_REGISTER(vlan_unconfig, iflib_vlan_unregister, ctx,
5958 ctx->ifc_mediap = &ctx->ifc_media;
5959 ifmedia_init(ctx->ifc_mediap, IFM_IMASK,
5966 iflib_unregister_vlan_handlers(if_ctx_t ctx)
5969 if (ctx->ifc_vlan_attach_event != NULL) {
5970 EVENTHANDLER_DEREGISTER(vlan_config, ctx->ifc_vlan_attach_event);
5971 ctx->ifc_vlan_attach_event = NULL;
5973 if (ctx->ifc_vlan_detach_event != NULL) {
5974 EVENTHANDLER_DEREGISTER(vlan_unconfig, ctx->ifc_vlan_detach_event);
5975 ctx->ifc_vlan_detach_event = NULL;
5981 iflib_deregister(if_ctx_t ctx)
5983 if_t ifp = ctx->ifc_ifp;
5986 ifmedia_removeall(&ctx->ifc_media);
5989 iflib_unregister_vlan_handlers(ctx);
5993 kobj_delete((kobj_t) ctx, NULL);
5999 STATE_LOCK_DESTROY(ctx);
6002 CTX_LOCK_DESTROY(ctx);
6006 iflib_queues_alloc(if_ctx_t ctx)
6008 if_shared_ctx_t sctx = ctx->ifc_sctx;
6009 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
6010 device_t dev = ctx->ifc_dev;
6033 if (!(ctx->ifc_txqs =
6042 if (!(ctx->ifc_rxqs =
6050 txq = ctx->ifc_txqs;
6051 rxq = ctx->ifc_rxqs;
6068 if (iflib_dma_alloc(ctx, txqsizes[j], ifdip, 0)) {
6077 txq->ift_ctx = ctx;
6130 if (iflib_dma_alloc(ctx, rxqsizes[j], ifdip, 0)) {
6138 rxq->ifr_ctx = ctx;
6172 iflib_dma_info_t di = ctx->ifc_txqs[i].ift_ifdi;
6179 if ((err = IFDI_TX_QUEUES_ALLOC(ctx, vaddrs, paddrs, ntxqs, ntxqsets)) != 0) {
6180 device_printf(ctx->ifc_dev,
6182 iflib_tx_structures_free(ctx);
6194 iflib_dma_info_t di = ctx->ifc_rxqs[i].ifr_ifdi;
6201 if ((err = IFDI_RX_QUEUES_ALLOC(ctx, vaddrs, paddrs, nrxqs, nrxqsets)) != 0) {
6202 device_printf(ctx->ifc_dev,
6204 iflib_tx_structures_free(ctx);
6218 if (ctx->ifc_rxqs != NULL)
6219 free(ctx->ifc_rxqs, M_IFLIB);
6220 ctx->ifc_rxqs = NULL;
6221 if (ctx->ifc_txqs != NULL)
6222 free(ctx->ifc_txqs, M_IFLIB);
6223 ctx->ifc_txqs = NULL;
6229 iflib_tx_structures_setup(if_ctx_t ctx)
6231 iflib_txq_t txq = ctx->ifc_txqs;
6234 for (i = 0; i < NTXQSETS(ctx); i++, txq++)
6241 iflib_tx_structures_free(if_ctx_t ctx)
6243 iflib_txq_t txq = ctx->ifc_txqs;
6244 if_shared_ctx_t sctx = ctx->ifc_sctx;
6247 for (i = 0; i < NTXQSETS(ctx); i++, txq++) {
6252 free(ctx->ifc_txqs, M_IFLIB);
6253 ctx->ifc_txqs = NULL;
6262 iflib_rx_structures_setup(if_ctx_t ctx)
6264 iflib_rxq_t rxq = ctx->ifc_rxqs;
6270 for (q = 0; q < ctx->ifc_softc_ctx.isc_nrxqsets; q++, rxq++) {
6272 if (if_getcapabilities(ctx->ifc_ifp) & IFCAP_LRO) {
6273 err = tcp_lro_init_args(&rxq->ifr_lc, ctx->ifc_ifp,
6275 ctx->ifc_softc_ctx.isc_nrxd[rxq->ifr_fl_offset]));
6277 device_printf(ctx->ifc_dev,
6283 IFDI_RXQ_SETUP(ctx, rxq->ifr_id);
6293 rxq = ctx->ifc_rxqs;
6295 if (if_getcapabilities(ctx->ifc_ifp) & IFCAP_LRO)
6308 iflib_rx_structures_free(if_ctx_t ctx)
6310 iflib_rxq_t rxq = ctx->ifc_rxqs;
6311 if_shared_ctx_t sctx = ctx->ifc_sctx;
6314 for (i = 0; i < ctx->ifc_softc_ctx.isc_nrxqsets; i++, rxq++) {
6319 if (if_getcapabilities(ctx->ifc_ifp) & IFCAP_LRO)
6323 free(ctx->ifc_rxqs, M_IFLIB);
6324 ctx->ifc_rxqs = NULL;
6328 iflib_qset_structures_setup(if_ctx_t ctx)
6336 if ((err = iflib_tx_structures_setup(ctx)) != 0) {
6337 device_printf(ctx->ifc_dev, "iflib_tx_structures_setup failed: %d\n", err);
6341 if ((err = iflib_rx_structures_setup(ctx)) != 0)
6342 device_printf(ctx->ifc_dev, "iflib_rx_structures_setup failed: %d\n", err);
6348 iflib_irq_alloc(if_ctx_t ctx, if_irq_t irq, int rid,
6352 return (_iflib_irq_alloc(ctx, irq, rid, filter, handler, arg, name));
6357 iflib_irq_set_affinity(if_ctx_t ctx, if_irq_t irq, iflib_intr_type_t type,
6365 dev = ctx->ifc_dev;
6366 base_cpuid = ctx->ifc_sysctl_core_offset;
6367 cpuid = get_cpuid_for_queue(ctx, base_cpuid, qid, type == IFLIB_INTR_TX);
6375 if (cpuid > ctx->ifc_cpuid_highest)
6376 ctx->ifc_cpuid_highest = cpuid;
6382 iflib_irq_alloc_generic(if_ctx_t ctx, if_irq_t irq, int rid,
6395 info = &ctx->ifc_filter_info;
6401 q = &ctx->ifc_txqs[qid];
6402 info = &ctx->ifc_txqs[qid].ift_filter_info;
6403 gtask = &ctx->ifc_txqs[qid].ift_task;
6408 ctx->ifc_flags |= IFC_NETMAP_TX_IRQ;
6411 q = &ctx->ifc_rxqs[qid];
6412 info = &ctx->ifc_rxqs[qid].ifr_filter_info;
6413 gtask = &ctx->ifc_rxqs[qid].ifr_task;
6420 q = &ctx->ifc_rxqs[qid];
6421 info = &ctx->ifc_rxqs[qid].ifr_filter_info;
6422 gtask = &ctx->ifc_rxqs[qid].ifr_task;
6429 q = ctx;
6431 info = &ctx->ifc_filter_info;
6432 gtask = &ctx->ifc_admin_task;
6438 device_printf(ctx->ifc_dev, "%s: unknown net intr type\n",
6448 dev = ctx->ifc_dev;
6449 err = _iflib_irq_alloc(ctx, irq, rid, intr_fast, NULL, info, name);
6458 err = iflib_irq_set_affinity(ctx, irq, type, qid, gtask, tqg, q,
6470 iflib_softirq_alloc_generic(if_ctx_t ctx, if_irq_t irq, iflib_intr_type_t type, void *arg, int qid, const char *name)
6481 q = &ctx->ifc_txqs[qid];
6482 gtask = &ctx->ifc_txqs[qid].ift_task;
6488 q = &ctx->ifc_rxqs[qid];
6489 gtask = &ctx->ifc_rxqs[qid].ifr_task;
6495 q = ctx;
6496 gtask = &ctx->ifc_vflr_task;
6504 err = iflib_irq_set_affinity(ctx, irq, type, qid, gtask, tqg, q, name);
6506 dev = ctx->ifc_dev;
6513 iflib_irq_free(if_ctx_t ctx, if_irq_t irq)
6516 if (!ctx || !irq)
6521 bus_teardown_intr(ctx->ifc_dev, irq->ii_res, irq->ii_tag);
6524 bus_release_resource(ctx->ifc_dev, SYS_RES_IRQ,
6529 iflib_legacy_setup(if_ctx_t ctx, driver_filter_t filter, void *filter_arg, int *rid, const char *name)
6531 iflib_txq_t txq = ctx->ifc_txqs;
6532 iflib_rxq_t rxq = ctx->ifc_rxqs;
6533 if_irq_t irq = &ctx->ifc_legacy_irq;
6543 q = &ctx->ifc_rxqs[0];
6548 rx_only = (ctx->ifc_sctx->isc_flags & IFLIB_SINGLE_IRQ_RX_ONLY) != 0;
6550 ctx->ifc_flags |= IFC_LEGACY;
6554 info->ifi_ctx = rx_only ? ctx : q;
6556 dev = ctx->ifc_dev;
6558 err = _iflib_irq_alloc(ctx, irq, tqrid, rx_only ? iflib_fast_intr_ctx :
6573 iflib_led_create(if_ctx_t ctx)
6576 ctx->ifc_led_dev = led_create(iflib_led_func, ctx,
6577 device_get_nameunit(ctx->ifc_dev));
6581 iflib_tx_intr_deferred(if_ctx_t ctx, int txqid)
6584 GROUPTASK_ENQUEUE(&ctx->ifc_txqs[txqid].ift_task);
6588 iflib_rx_intr_deferred(if_ctx_t ctx, int rxqid)
6591 GROUPTASK_ENQUEUE(&ctx->ifc_rxqs[rxqid].ifr_task);
6595 iflib_admin_intr_deferred(if_ctx_t ctx)
6598 MPASS(ctx->ifc_admin_task.gt_taskqueue != NULL);
6599 GROUPTASK_ENQUEUE(&ctx->ifc_admin_task);
6603 iflib_iov_intr_deferred(if_ctx_t ctx)
6606 GROUPTASK_ENQUEUE(&ctx->ifc_vflr_task);
6618 iflib_config_gtask_init(void *ctx, struct grouptask *gtask, gtask_fn_t *fn,
6622 GROUPTASK_INIT(gtask, 0, fn, ctx);
6635 iflib_link_state_change(if_ctx_t ctx, int link_state, uint64_t baudrate)
6637 if_t ifp = ctx->ifc_ifp;
6638 iflib_txq_t txq = ctx->ifc_txqs;
6642 STATE_LOCK(ctx);
6643 ctx->ifc_flags |= IFC_PREFETCH;
6644 STATE_UNLOCK(ctx);
6647 if ((ctx->ifc_link_state == LINK_STATE_UP) && (link_state == LINK_STATE_DOWN)) {
6648 for (int i = 0; i < ctx->ifc_softc_ctx.isc_ntxqsets; i++, txq++)
6651 ctx->ifc_link_state = link_state;
6656 iflib_tx_credits_update(if_ctx_t ctx, iflib_txq_t txq)
6665 if ((credits = ctx->isc_txd_credits_update(ctx->ifc_softc, txq->ift_id, true)) == 0)
6678 iflib_rxd_avail(if_ctx_t ctx, iflib_rxq_t rxq, qidx_t cidx, qidx_t budget)
6686 return (ctx->isc_rxd_available(ctx->ifc_softc, rxq->ifr_id, cidx,
6691 iflib_add_int_delay_sysctl(if_ctx_t ctx, const char *name,
6695 info->iidi_ctx = ctx;
6698 SYSCTL_ADD_PROC(device_get_sysctl_ctx(ctx->ifc_dev),
6699 SYSCTL_CHILDREN(device_get_sysctl_tree(ctx->ifc_dev)),
6705 iflib_ctx_lock_get(if_ctx_t ctx)
6708 return (&ctx->ifc_ctx_sx);
6712 iflib_msix_init(if_ctx_t ctx)
6714 device_t dev = ctx->ifc_dev;
6715 if_shared_ctx_t sctx = ctx->ifc_sctx;
6716 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
6720 iflib_num_tx_queues = ctx->ifc_sysctl_ntxqs;
6721 iflib_num_rx_queues = ctx->ifc_sysctl_nrxqs;
6738 bar = ctx->ifc_softc_ctx.isc_msix_bar;
6747 ctx->ifc_msix_mem = bus_alloc_resource_any(dev,
6749 if (ctx->ifc_msix_mem == NULL) {
6768 queues = imin(CPU_COUNT(&ctx->ifc_cpus), queues);
6772 CPU_COUNT(&ctx->ifc_cpus), queuemsgs, admincnt);
6798 if (ctx->ifc_sysctl_qs_eq_override == 0) {
6828 ctx->ifc_msix_mem);
6829 ctx->ifc_msix_mem = NULL;
6847 ctx->ifc_msix_mem);
6848 ctx->ifc_msix_mem = NULL;
6908 if_ctx_t ctx = (void *)arg1;
6918 ndesc = ctx->ifc_sysctl_ntxds;
6919 if (ctx->ifc_sctx)
6920 nqs = ctx->ifc_sctx->isc_ntxqs;
6923 ndesc = ctx->ifc_sysctl_nrxds;
6924 if (ctx->ifc_sctx)
6925 nqs = ctx->ifc_sctx->isc_nrxqs;
6956 iflib_add_device_sysctl_pre(if_ctx_t ctx)
6959 device_t dev = iflib_get_dev(ctx);
6966 ctx->ifc_sysctl_node = node = SYSCTL_ADD_NODE(ctx_list, child, OID_AUTO, "iflib",
6971 CTLFLAG_RD, ctx->ifc_sctx->isc_driver_version,
6975 CTLFLAG_RWTUN, &ctx->ifc_sysctl_ntxqs, 0,
6978 CTLFLAG_RWTUN, &ctx->ifc_sysctl_nrxqs, 0,
6981 CTLFLAG_RWTUN, &ctx->ifc_sysctl_qs_eq_override, 0,
6984 CTLFLAG_RWTUN, &ctx->ifc_softc_ctx.isc_disable_msix, 0,
6987 CTLFLAG_RWTUN, &ctx->ifc_sysctl_rx_budget, 0,
6990 CTLFLAG_RWTUN, &ctx->ifc_sysctl_tx_abdicate, 0,
6992 ctx->ifc_sysctl_core_offset = CORE_OFFSET_UNSPECIFIED;
6994 CTLFLAG_RDTUN, &ctx->ifc_sysctl_core_offset, 0,
6997 CTLFLAG_RDTUN, &ctx->ifc_sysctl_separate_txrx, 0,
7000 CTLFLAG_RDTUN, &ctx->ifc_sysctl_use_logical_cores, 0,
7005 CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, ctx,
7009 CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_NEEDGIANT, ctx,
7016 iflib_add_device_sysctl_post(if_ctx_t ctx)
7019 if_shared_ctx_t sctx = ctx->ifc_sctx;
7020 if_softc_ctx_t scctx = &ctx->ifc_softc_ctx;
7021 device_t dev = iflib_get_dev(ctx);
7034 node = ctx->ifc_sysctl_node;
7043 for (i = 0, txq = ctx->ifc_txqs; i < scctx->isc_ntxqsets; i++, txq++) {
7128 for (i = 0, rxq = ctx->ifc_rxqs; i < scctx->isc_nrxqsets; i++, rxq++) {
7179 iflib_request_reset(if_ctx_t ctx)
7182 STATE_LOCK(ctx);
7183 ctx->ifc_flags |= IFC_DO_RESET;
7184 STATE_UNLOCK(ctx);
7218 if_ctx_t ctx;
7220 ctx = if_getsoftc(ifp);
7221 CTX_LOCK(ctx);
7222 *nrxr = NRXQSETS(ctx);
7223 *ncl = ctx->ifc_rxqs[0].ifr_fl->ifl_size;
7224 *clsize = ctx->ifc_rxqs[0].ifr_fl->ifl_buf_size;
7225 CTX_UNLOCK(ctx);
7231 if_ctx_t ctx;
7237 ctx = if_getsoftc(ifp);
7238 scctx = &ctx->ifc_softc_ctx;
7244 rxq = &ctx->ifc_rxqs[i];
7261 if_ctx_t ctx;
7265 ctx = if_getsoftc(ifp);
7270 txq = &ctx->ifc_txqs[0];
7281 if_ctx_t ctx;
7286 ctx = if_getsoftc(ifp);
7287 scctx = &ctx->ifc_softc_ctx;
7293 txq = &ctx->ifc_txqs[0];
7294 (void)iflib_completed_tx_reclaim(txq, RECLAIM_THRESH(ctx));
7298 (void)iflib_rxeof(&ctx->ifc_rxqs[i], 16 /* XXX */);