tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

drivers: net: turn on XDP features

A summary of the flags being set for various drivers is given below.
Note that XDP_F_REDIRECT_TARGET and XDP_F_FRAG_TARGET are features
that can be turned off and on at runtime. This means that these flags
may be set and unset under RTNL lock protection by the driver. Hence,
READ_ONCE must be used by code loading the flag value.

Also, these flags are not used for synchronization against the availability
of XDP resources on a device. It is merely a hint, and hence the read
may race with the actual teardown of XDP resources on the device. This
may change in the future, e.g. operations taking a reference on the XDP
resources of the driver, and in turn inhibiting turning off this flag.
However, for now, it can only be used as a hint to check whether device
supports becoming a redirection target.

Turn 'hw-offload' feature flag on for:
- netronome (nfp)
- netdevsim.

Turn 'native' and 'zerocopy' features flags on for:
- intel (i40e, ice, ixgbe, igc)
- mellanox (mlx5).
- stmmac
- netronome (nfp)

Turn 'native' features flags on for:
- amazon (ena)
- broadcom (bnxt)
- freescale (dpaa, dpaa2, enetc)
- funeth
- intel (igb)
- marvell (mvneta, mvpp2, octeontx2)
- mellanox (mlx4)
- mtk_eth_soc
- qlogic (qede)
- sfc
- socionext (netsec)
- ti (cpsw)
- tap
- tsnep
- veth
- xen
- virtio_net.

Turn 'basic' (tx, pass, aborted and drop) features flags on for:
- netronome (nfp)
- cavium (thunder)
- hyperv.

Turn 'redirect_target' feature flag on for:
- amanzon (ena)
- broadcom (bnxt)
- freescale (dpaa, dpaa2)
- intel (i40e, ice, igb, ixgbe)
- ti (cpsw)
- marvell (mvneta, mvpp2)
- sfc
- socionext (netsec)
- qlogic (qede)
- mellanox (mlx5)
- tap
- veth
- virtio_net
- xen

Reviewed-by: Gerhard Engleder <gerhard@engleder-embedded.com>
Reviewed-by: Simon Horman <simon.horman@corigine.com>
Acked-by: Stanislav Fomichev <sdf@google.com>
Acked-by: Jakub Kicinski <kuba@kernel.org>
Co-developed-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Co-developed-by: Lorenzo Bianconi <lorenzo@kernel.org>
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
Signed-off-by: Marek Majtyka <alardam@gmail.com>
Link: https://lore.kernel.org/r/3eca9fafb308462f7edb1f58e451d59209aa07eb.1675245258.git.lorenzo@kernel.org
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

authored by

Marek Majtyka and committed by
Alexei Starovoitov 66c0e13a d3d854fd

+184 -5
+4
drivers/net/ethernet/amazon/ena/ena_netdev.c
··· 597 597 if (rc) 598 598 return rc; 599 599 } 600 + xdp_features_set_redirect_target(netdev, false); 600 601 } else if (old_bpf_prog) { 602 + xdp_features_clear_redirect_target(netdev); 601 603 rc = ena_destroy_and_free_all_xdp_queues(adapter); 602 604 if (rc) 603 605 return rc; ··· 4104 4102 4105 4103 /* Set offload features */ 4106 4104 ena_set_dev_offloads(feat, netdev); 4105 + 4106 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 4107 4107 4108 4108 adapter->max_mtu = feat->dev_attr.max_mtu; 4109 4109 netdev->max_mtu = adapter->max_mtu;
+5
drivers/net/ethernet/aquantia/atlantic/aq_nic.c
··· 384 384 self->ndev->mtu = aq_nic_cfg->mtu - ETH_HLEN; 385 385 self->ndev->max_mtu = aq_hw_caps->mtu - ETH_FCS_LEN - ETH_HLEN; 386 386 387 + self->ndev->xdp_features = NETDEV_XDP_ACT_BASIC | 388 + NETDEV_XDP_ACT_REDIRECT | 389 + NETDEV_XDP_ACT_NDO_XMIT | 390 + NETDEV_XDP_ACT_RX_SG | 391 + NETDEV_XDP_ACT_NDO_XMIT_SG; 387 392 } 388 393 389 394 void aq_nic_set_tx_ring(struct aq_nic_s *self, unsigned int idx,
+3
drivers/net/ethernet/broadcom/bnxt/bnxt.c
··· 13686 13686 13687 13687 netif_set_tso_max_size(dev, GSO_MAX_SIZE); 13688 13688 13689 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 13690 + NETDEV_XDP_ACT_RX_SG; 13691 + 13689 13692 #ifdef CONFIG_BNXT_SRIOV 13690 13693 init_waitqueue_head(&bp->sriov_cfg_wait); 13691 13694 #endif
+2
drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c
··· 422 422 423 423 if (prog) { 424 424 bnxt_set_rx_skb_mode(bp, true); 425 + xdp_features_set_redirect_target(dev, true); 425 426 } else { 426 427 int rx, tx; 427 428 429 + xdp_features_clear_redirect_target(dev); 428 430 bnxt_set_rx_skb_mode(bp, false); 429 431 bnxt_get_max_rings(bp, &rx, &tx, true); 430 432 if (rx > 1) {
+2
drivers/net/ethernet/cavium/thunder/nicvf_main.c
··· 2218 2218 netdev->netdev_ops = &nicvf_netdev_ops; 2219 2219 netdev->watchdog_timeo = NICVF_TX_TIMEOUT; 2220 2220 2221 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC; 2222 + 2221 2223 /* MTU range: 64 - 9200 */ 2222 2224 netdev->min_mtu = NIC_HW_MIN_FRS; 2223 2225 netdev->max_mtu = NIC_HW_MAX_FRS;
+4
drivers/net/ethernet/engleder/tsnep_main.c
··· 1926 1926 netdev->features = NETIF_F_SG; 1927 1927 netdev->hw_features = netdev->features | NETIF_F_LOOPBACK; 1928 1928 1929 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 1930 + NETDEV_XDP_ACT_NDO_XMIT | 1931 + NETDEV_XDP_ACT_NDO_XMIT_SG; 1932 + 1929 1933 /* carrier off reporting is important to ethtool even BEFORE open */ 1930 1934 netif_carrier_off(netdev); 1931 1935
+4
drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
··· 244 244 net_dev->features |= net_dev->hw_features; 245 245 net_dev->vlan_features = net_dev->features; 246 246 247 + net_dev->xdp_features = NETDEV_XDP_ACT_BASIC | 248 + NETDEV_XDP_ACT_REDIRECT | 249 + NETDEV_XDP_ACT_NDO_XMIT; 250 + 247 251 if (is_valid_ether_addr(mac_addr)) { 248 252 memcpy(net_dev->perm_addr, mac_addr, net_dev->addr_len); 249 253 eth_hw_addr_set(net_dev, mac_addr);
+4
drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c
··· 4596 4596 NETIF_F_LLTX | NETIF_F_HW_TC | NETIF_F_TSO; 4597 4597 net_dev->gso_max_segs = DPAA2_ETH_ENQUEUE_MAX_FDS; 4598 4598 net_dev->hw_features = net_dev->features; 4599 + net_dev->xdp_features = NETDEV_XDP_ACT_BASIC | 4600 + NETDEV_XDP_ACT_REDIRECT | 4601 + NETDEV_XDP_ACT_XSK_ZEROCOPY | 4602 + NETDEV_XDP_ACT_NDO_XMIT; 4599 4603 4600 4604 if (priv->dpni_attrs.vlan_filter_entries) 4601 4605 net_dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
+3
drivers/net/ethernet/freescale/enetc/enetc_pf.c
··· 807 807 ndev->hw_features |= NETIF_F_RXHASH; 808 808 809 809 ndev->priv_flags |= IFF_UNICAST_FLT; 810 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 811 + NETDEV_XDP_ACT_NDO_XMIT | NETDEV_XDP_ACT_RX_SG | 812 + NETDEV_XDP_ACT_NDO_XMIT_SG; 810 813 811 814 if (si->hw_features & ENETC_SI_F_PSFP && !enetc_psfp_enable(priv)) { 812 815 priv->active_offloads |= ENETC_F_QCI;
+6
drivers/net/ethernet/fungible/funeth/funeth_main.c
··· 1160 1160 WRITE_ONCE(rxqs[i]->xdp_prog, prog); 1161 1161 } 1162 1162 1163 + if (prog) 1164 + xdp_features_set_redirect_target(dev, true); 1165 + else 1166 + xdp_features_clear_redirect_target(dev); 1167 + 1163 1168 dev->max_mtu = prog ? XDP_MAX_MTU : FUN_MAX_MTU; 1164 1169 old_prog = xchg(&fp->xdp_prog, prog); 1165 1170 if (old_prog) ··· 1770 1765 netdev->vlan_features = netdev->features & VLAN_FEAT; 1771 1766 netdev->mpls_features = netdev->vlan_features; 1772 1767 netdev->hw_enc_features = netdev->hw_features; 1768 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 1773 1769 1774 1770 netdev->min_mtu = ETH_MIN_MTU; 1775 1771 netdev->max_mtu = FUN_MAX_MTU;
+8 -2
drivers/net/ethernet/intel/i40e/i40e_main.c
··· 13339 13339 old_prog = xchg(&vsi->xdp_prog, prog); 13340 13340 13341 13341 if (need_reset) { 13342 - if (!prog) 13342 + if (!prog) { 13343 + xdp_features_clear_redirect_target(vsi->netdev); 13343 13344 /* Wait until ndo_xsk_wakeup completes. */ 13344 13345 synchronize_rcu(); 13346 + } 13345 13347 i40e_reset_and_rebuild(pf, true, true); 13346 13348 } 13347 13349 ··· 13364 13362 /* Kick start the NAPI context if there is an AF_XDP socket open 13365 13363 * on that queue id. This so that receiving will start. 13366 13364 */ 13367 - if (need_reset && prog) 13365 + if (need_reset && prog) { 13368 13366 for (i = 0; i < vsi->num_queue_pairs; i++) 13369 13367 if (vsi->xdp_rings[i]->xsk_pool) 13370 13368 (void)i40e_xsk_wakeup(vsi->netdev, i, 13371 13369 XDP_WAKEUP_RX); 13370 + xdp_features_set_redirect_target(vsi->netdev, true); 13371 + } 13372 13372 13373 13373 return 0; 13374 13374 } ··· 13787 13783 netdev->hw_enc_features |= NETIF_F_TSO_MANGLEID; 13788 13784 13789 13785 netdev->features &= ~NETIF_F_HW_TC; 13786 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 13787 + NETDEV_XDP_ACT_XSK_ZEROCOPY; 13790 13788 13791 13789 if (vsi->type == I40E_VSI_MAIN) { 13792 13790 SET_NETDEV_DEV(netdev, &pf->pdev->dev);
+5
drivers/net/ethernet/intel/ice/ice_main.c
··· 22 22 #include "ice_eswitch.h" 23 23 #include "ice_tc_lib.h" 24 24 #include "ice_vsi_vlan_ops.h" 25 + #include <net/xdp_sock_drv.h> 25 26 26 27 #define DRV_SUMMARY "Intel(R) Ethernet Connection E800 Series Linux Driver" 27 28 static const char ice_driver_string[] = DRV_SUMMARY; ··· 2913 2912 if (xdp_ring_err) 2914 2913 NL_SET_ERR_MSG_MOD(extack, "Setting up XDP Tx resources failed"); 2915 2914 } 2915 + xdp_features_set_redirect_target(vsi->netdev, false); 2916 2916 /* reallocate Rx queues that are used for zero-copy */ 2917 2917 xdp_ring_err = ice_realloc_zc_buf(vsi, true); 2918 2918 if (xdp_ring_err) 2919 2919 NL_SET_ERR_MSG_MOD(extack, "Setting up XDP Rx resources failed"); 2920 2920 } else if (ice_is_xdp_ena_vsi(vsi) && !prog) { 2921 + xdp_features_clear_redirect_target(vsi->netdev); 2921 2922 xdp_ring_err = ice_destroy_xdp_rings(vsi); 2922 2923 if (xdp_ring_err) 2923 2924 NL_SET_ERR_MSG_MOD(extack, "Freeing XDP Tx resources failed"); ··· 3462 3459 np->vsi = vsi; 3463 3460 3464 3461 ice_set_netdev_features(netdev); 3462 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 3463 + NETDEV_XDP_ACT_XSK_ZEROCOPY; 3465 3464 3466 3465 ice_set_ops(netdev); 3467 3466
+8 -1
drivers/net/ethernet/intel/igb/igb_main.c
··· 2871 2871 bpf_prog_put(old_prog); 2872 2872 2873 2873 /* bpf is just replaced, RXQ and MTU are already setup */ 2874 - if (!need_reset) 2874 + if (!need_reset) { 2875 2875 return 0; 2876 + } else { 2877 + if (prog) 2878 + xdp_features_set_redirect_target(dev, true); 2879 + else 2880 + xdp_features_clear_redirect_target(dev); 2881 + } 2876 2882 2877 2883 if (running) 2878 2884 igb_open(dev); ··· 3323 3317 netdev->priv_flags |= IFF_SUPP_NOFCS; 3324 3318 3325 3319 netdev->priv_flags |= IFF_UNICAST_FLT; 3320 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 3326 3321 3327 3322 /* MTU range: 68 - 9216 */ 3328 3323 netdev->min_mtu = ETH_MIN_MTU;
+3
drivers/net/ethernet/intel/igc/igc_main.c
··· 6533 6533 netdev->mpls_features |= NETIF_F_HW_CSUM; 6534 6534 netdev->hw_enc_features |= netdev->vlan_features; 6535 6535 6536 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 6537 + NETDEV_XDP_ACT_XSK_ZEROCOPY; 6538 + 6536 6539 /* MTU range: 68 - 9216 */ 6537 6540 netdev->min_mtu = ETH_MIN_MTU; 6538 6541 netdev->max_mtu = MAX_STD_JUMBO_FRAME_SIZE;
+5
drivers/net/ethernet/intel/igc/igc_xdp.c
··· 29 29 if (old_prog) 30 30 bpf_prog_put(old_prog); 31 31 32 + if (prog) 33 + xdp_features_set_redirect_target(dev, true); 34 + else 35 + xdp_features_clear_redirect_target(dev); 36 + 32 37 if (if_running) 33 38 igc_open(dev); 34 39
+6
drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
··· 10301 10301 10302 10302 if (err) 10303 10303 return -EINVAL; 10304 + if (!prog) 10305 + xdp_features_clear_redirect_target(dev); 10304 10306 } else { 10305 10307 for (i = 0; i < adapter->num_rx_queues; i++) { 10306 10308 WRITE_ONCE(adapter->rx_ring[i]->xdp_prog, ··· 10323 10321 if (adapter->xdp_ring[i]->xsk_pool) 10324 10322 (void)ixgbe_xsk_wakeup(adapter->netdev, i, 10325 10323 XDP_WAKEUP_RX); 10324 + xdp_features_set_redirect_target(dev, true); 10326 10325 } 10327 10326 10328 10327 return 0; ··· 11020 11017 11021 11018 netdev->priv_flags |= IFF_UNICAST_FLT; 11022 11019 netdev->priv_flags |= IFF_SUPP_NOFCS; 11020 + 11021 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 11022 + NETDEV_XDP_ACT_XSK_ZEROCOPY; 11023 11023 11024 11024 /* MTU range: 68 - 9710 */ 11025 11025 netdev->min_mtu = ETH_MIN_MTU;
+1
drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
··· 4634 4634 NETIF_F_HW_VLAN_CTAG_TX; 4635 4635 4636 4636 netdev->priv_flags |= IFF_UNICAST_FLT; 4637 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC; 4637 4638 4638 4639 /* MTU range: 68 - 1504 or 9710 */ 4639 4640 netdev->min_mtu = ETH_MIN_MTU;
+3
drivers/net/ethernet/marvell/mvneta.c
··· 5612 5612 NETIF_F_TSO | NETIF_F_RXCSUM; 5613 5613 dev->hw_features |= dev->features; 5614 5614 dev->vlan_features |= dev->features; 5615 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 5616 + NETDEV_XDP_ACT_NDO_XMIT | NETDEV_XDP_ACT_RX_SG | 5617 + NETDEV_XDP_ACT_NDO_XMIT_SG; 5615 5618 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 5616 5619 netif_set_tso_max_segs(dev, MVNETA_MAX_TSO_SEGS); 5617 5620
+4
drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
··· 6866 6866 6867 6867 dev->vlan_features |= features; 6868 6868 netif_set_tso_max_segs(dev, MVPP2_MAX_TSO_SEGS); 6869 + 6870 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 6871 + NETDEV_XDP_ACT_NDO_XMIT; 6872 + 6869 6873 dev->priv_flags |= IFF_UNICAST_FLT; 6870 6874 6871 6875 /* MTU range: 68 - 9704 */
+6 -2
drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c
··· 2512 2512 /* Network stack and XDP shared same rx queues. 2513 2513 * Use separate tx queues for XDP and network stack. 2514 2514 */ 2515 - if (pf->xdp_prog) 2515 + if (pf->xdp_prog) { 2516 2516 pf->hw.xdp_queues = pf->hw.rx_queues; 2517 - else 2517 + xdp_features_set_redirect_target(dev, false); 2518 + } else { 2518 2519 pf->hw.xdp_queues = 0; 2520 + xdp_features_clear_redirect_target(dev); 2521 + } 2519 2522 2520 2523 pf->hw.tot_tx_queues += pf->hw.xdp_queues; 2521 2524 ··· 2881 2878 netdev->watchdog_timeo = OTX2_TX_TIMEOUT; 2882 2879 2883 2880 netdev->netdev_ops = &otx2_netdev_ops; 2881 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 2884 2882 2885 2883 netdev->min_mtu = OTX2_MIN_MTU; 2886 2884 netdev->max_mtu = otx2_get_max_mtu(pf);
+6
drivers/net/ethernet/mediatek/mtk_eth_soc.c
··· 4447 4447 register_netdevice_notifier(&mac->device_notifier); 4448 4448 } 4449 4449 4450 + if (mtk_page_pool_enabled(eth)) 4451 + eth->netdev[id]->xdp_features = NETDEV_XDP_ACT_BASIC | 4452 + NETDEV_XDP_ACT_REDIRECT | 4453 + NETDEV_XDP_ACT_NDO_XMIT | 4454 + NETDEV_XDP_ACT_NDO_XMIT_SG; 4455 + 4450 4456 return 0; 4451 4457 4452 4458 free_netdev:
+2
drivers/net/ethernet/mellanox/mlx4/en_netdev.c
··· 3416 3416 priv->rss_hash_fn = ETH_RSS_HASH_TOP; 3417 3417 } 3418 3418 3419 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 3420 + 3419 3421 /* MTU range: 68 - hw-specific max */ 3420 3422 dev->min_mtu = ETH_MIN_MTU; 3421 3423 dev->max_mtu = priv->max_mtu;
+11
drivers/net/ethernet/mellanox/mlx5/core/en_main.c
··· 4780 4780 if (old_prog) 4781 4781 bpf_prog_put(old_prog); 4782 4782 4783 + if (reset) { 4784 + if (prog) 4785 + xdp_features_set_redirect_target(netdev, true); 4786 + else 4787 + xdp_features_clear_redirect_target(netdev); 4788 + } 4789 + 4783 4790 if (!test_bit(MLX5E_STATE_OPENED, &priv->state) || reset) 4784 4791 goto unlock; 4785 4792 ··· 5181 5174 5182 5175 netdev->features |= NETIF_F_HIGHDMA; 5183 5176 netdev->features |= NETIF_F_HW_VLAN_STAG_FILTER; 5177 + 5178 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 5179 + NETDEV_XDP_ACT_XSK_ZEROCOPY | 5180 + NETDEV_XDP_ACT_RX_SG; 5184 5181 5185 5182 netdev->priv_flags |= IFF_UNICAST_FLT; 5186 5183
+2
drivers/net/ethernet/microsoft/mana/mana_en.c
··· 2160 2160 ndev->hw_features |= NETIF_F_RXHASH; 2161 2161 ndev->features = ndev->hw_features; 2162 2162 ndev->vlan_features = 0; 2163 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 2164 + NETDEV_XDP_ACT_NDO_XMIT; 2163 2165 2164 2166 err = register_netdev(ndev); 2165 2167 if (err) {
+5
drivers/net/ethernet/netronome/nfp/nfp_net_common.c
··· 2529 2529 netdev->features &= ~NETIF_F_HW_VLAN_STAG_RX; 2530 2530 nn->dp.ctrl &= ~NFP_NET_CFG_CTRL_RXQINQ; 2531 2531 2532 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC; 2533 + if (nn->app && nn->app->type->id == NFP_APP_BPF_NIC) 2534 + netdev->xdp_features |= NETDEV_XDP_ACT_HW_OFFLOAD; 2535 + 2532 2536 /* Finalise the netdev setup */ 2533 2537 switch (nn->dp.ops->version) { 2534 2538 case NFP_NFD_VER_NFD3: 2535 2539 netdev->netdev_ops = &nfp_nfd3_netdev_ops; 2540 + netdev->xdp_features |= NETDEV_XDP_ACT_XSK_ZEROCOPY; 2536 2541 break; 2537 2542 case NFP_NFD_VER_NFDK: 2538 2543 netdev->netdev_ops = &nfp_nfdk_netdev_ops;
+3
drivers/net/ethernet/qlogic/qede/qede_main.c
··· 892 892 893 893 ndev->hw_features = hw_features; 894 894 895 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 896 + NETDEV_XDP_ACT_NDO_XMIT; 897 + 895 898 /* MTU range: 46 - 9600 */ 896 899 ndev->min_mtu = ETH_ZLEN - ETH_HLEN; 897 900 ndev->max_mtu = QEDE_MAX_JUMBO_PACKET_SIZE;
+4
drivers/net/ethernet/sfc/efx.c
··· 1078 1078 1079 1079 pci_info(pci_dev, "Solarflare NIC detected\n"); 1080 1080 1081 + efx->net_dev->xdp_features = NETDEV_XDP_ACT_BASIC | 1082 + NETDEV_XDP_ACT_REDIRECT | 1083 + NETDEV_XDP_ACT_NDO_XMIT; 1084 + 1081 1085 if (!efx->type->is_vf) 1082 1086 efx_probe_vpd_strings(efx); 1083 1087
+4
drivers/net/ethernet/sfc/siena/efx.c
··· 1048 1048 1049 1049 pci_info(pci_dev, "Solarflare NIC detected\n"); 1050 1050 1051 + efx->net_dev->xdp_features = NETDEV_XDP_ACT_BASIC | 1052 + NETDEV_XDP_ACT_REDIRECT | 1053 + NETDEV_XDP_ACT_NDO_XMIT; 1054 + 1051 1055 if (!efx->type->is_vf) 1052 1056 efx_probe_vpd_strings(efx); 1053 1057
+3
drivers/net/ethernet/socionext/netsec.c
··· 2104 2104 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; 2105 2105 ndev->hw_features = ndev->features; 2106 2106 2107 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 2108 + NETDEV_XDP_ACT_NDO_XMIT; 2109 + 2107 2110 priv->rx_cksum_offload_flag = true; 2108 2111 2109 2112 ret = netsec_register_mdio(priv, phy_addr);
+2
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
··· 7150 7150 7151 7151 ndev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 7152 7152 NETIF_F_RXCSUM; 7153 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 7154 + NETDEV_XDP_ACT_NDO_XMIT; 7153 7155 7154 7156 ret = stmmac_tc_init(priv, priv); 7155 7157 if (!ret) {
+4
drivers/net/ethernet/ti/cpsw.c
··· 1458 1458 priv_sl2->emac_port = 1; 1459 1459 cpsw->slaves[1].ndev = ndev; 1460 1460 ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_CTAG_RX; 1461 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 1462 + NETDEV_XDP_ACT_NDO_XMIT; 1461 1463 1462 1464 ndev->netdev_ops = &cpsw_netdev_ops; 1463 1465 ndev->ethtool_ops = &cpsw_ethtool_ops; ··· 1637 1635 cpsw->slaves[0].ndev = ndev; 1638 1636 1639 1637 ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_CTAG_RX; 1638 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 1639 + NETDEV_XDP_ACT_NDO_XMIT; 1640 1640 1641 1641 ndev->netdev_ops = &cpsw_netdev_ops; 1642 1642 ndev->ethtool_ops = &cpsw_ethtool_ops;
+4
drivers/net/ethernet/ti/cpsw_new.c
··· 1405 1405 ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | 1406 1406 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_NETNS_LOCAL | NETIF_F_HW_TC; 1407 1407 1408 + ndev->xdp_features = NETDEV_XDP_ACT_BASIC | 1409 + NETDEV_XDP_ACT_REDIRECT | 1410 + NETDEV_XDP_ACT_NDO_XMIT; 1411 + 1408 1412 ndev->netdev_ops = &cpsw_netdev_ops; 1409 1413 ndev->ethtool_ops = &cpsw_ethtool_ops; 1410 1414 SET_NETDEV_DEV(ndev, dev);
+2
drivers/net/hyperv/netvsc_drv.c
··· 2559 2559 2560 2560 netdev_lockdep_set_classes(net); 2561 2561 2562 + net->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 2563 + 2562 2564 /* MTU range: 68 - 1500 or 65521 */ 2563 2565 net->min_mtu = NETVSC_MTU_MIN; 2564 2566 if (nvdev->nvsp_version >= NVSP_PROTOCOL_VERSION_2)
+1
drivers/net/netdevsim/netdev.c
··· 286 286 NETIF_F_TSO; 287 287 dev->hw_features |= NETIF_F_HW_TC; 288 288 dev->max_mtu = ETH_MAX_MTU; 289 + dev->xdp_features = NETDEV_XDP_ACT_HW_OFFLOAD; 289 290 } 290 291 291 292 static int nsim_init_netdevsim(struct netdevsim *ns)
+5
drivers/net/tun.c
··· 1401 1401 1402 1402 eth_hw_addr_random(dev); 1403 1403 1404 + /* Currently tun does not support XDP, only tap does. */ 1405 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | 1406 + NETDEV_XDP_ACT_REDIRECT | 1407 + NETDEV_XDP_ACT_NDO_XMIT; 1408 + 1404 1409 break; 1405 1410 } 1406 1411
+4
drivers/net/veth.c
··· 1686 1686 dev->hw_enc_features = VETH_FEATURES; 1687 1687 dev->mpls_features = NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE; 1688 1688 netif_set_tso_max_size(dev, GSO_MAX_SIZE); 1689 + 1690 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 1691 + NETDEV_XDP_ACT_NDO_XMIT | NETDEV_XDP_ACT_RX_SG | 1692 + NETDEV_XDP_ACT_NDO_XMIT_SG; 1689 1693 } 1690 1694 1691 1695 /*
+4
drivers/net/virtio_net.c
··· 3280 3280 if (i == 0 && !old_prog) 3281 3281 virtnet_clear_guest_offloads(vi); 3282 3282 } 3283 + if (!old_prog) 3284 + xdp_features_set_redirect_target(dev, false); 3283 3285 } else { 3286 + xdp_features_clear_redirect_target(dev); 3284 3287 vi->xdp_enabled = false; 3285 3288 } 3286 3289 ··· 3913 3910 dev->hw_features |= NETIF_F_GRO_HW; 3914 3911 3915 3912 dev->vlan_features = dev->features; 3913 + dev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT; 3916 3914 3917 3915 /* MTU range: 68 - 65535 */ 3918 3916 dev->min_mtu = MIN_MTU;
+2
drivers/net/xen-netfront.c
··· 1741 1741 * negotiate with the backend regarding supported features. 1742 1742 */ 1743 1743 netdev->features |= netdev->hw_features; 1744 + netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | 1745 + NETDEV_XDP_ACT_NDO_XMIT; 1744 1746 1745 1747 netdev->ethtool_ops = &xennet_ethtool_ops; 1746 1748 netdev->min_mtu = ETH_MIN_MTU;
+12
include/net/xdp.h
··· 428 428 #ifdef CONFIG_NET 429 429 u32 bpf_xdp_metadata_kfunc_id(int id); 430 430 bool bpf_dev_bound_kfunc_id(u32 btf_id); 431 + void xdp_features_set_redirect_target(struct net_device *dev, bool support_sg); 432 + void xdp_features_clear_redirect_target(struct net_device *dev); 431 433 #else 432 434 static inline u32 bpf_xdp_metadata_kfunc_id(int id) { return 0; } 433 435 static inline bool bpf_dev_bound_kfunc_id(u32 btf_id) { return false; } 436 + 437 + static inline void 438 + xdp_features_set_redirect_target(struct net_device *dev, bool support_sg) 439 + { 440 + } 441 + 442 + static inline void 443 + xdp_features_clear_redirect_target(struct net_device *dev) 444 + { 445 + } 434 446 #endif 435 447 436 448 #endif /* __LINUX_NET_XDP_H__ */
+18
net/core/xdp.c
··· 774 774 return register_btf_kfunc_id_set(BPF_PROG_TYPE_XDP, &xdp_metadata_kfunc_set); 775 775 } 776 776 late_initcall(xdp_metadata_init); 777 + 778 + void xdp_features_set_redirect_target(struct net_device *dev, bool support_sg) 779 + { 780 + dev->xdp_features |= NETDEV_XDP_ACT_NDO_XMIT; 781 + if (support_sg) 782 + dev->xdp_features |= NETDEV_XDP_ACT_NDO_XMIT_SG; 783 + 784 + call_netdevice_notifiers(NETDEV_XDP_FEAT_CHANGE, dev); 785 + } 786 + EXPORT_SYMBOL_GPL(xdp_features_set_redirect_target); 787 + 788 + void xdp_features_clear_redirect_target(struct net_device *dev) 789 + { 790 + dev->xdp_features &= ~(NETDEV_XDP_ACT_NDO_XMIT | 791 + NETDEV_XDP_ACT_NDO_XMIT_SG); 792 + call_netdevice_notifiers(NETDEV_XDP_FEAT_CHANGE, dev); 793 + } 794 + EXPORT_SYMBOL_GPL(xdp_features_clear_redirect_target);