net, xdp: Introduce xdp_init_buff utility routine

Introduce xdp_init_buff utility routine to initialize xdp_buff fields
const over NAPI iterations (e.g. frame_sz or rxq pointer). Rely on
xdp_init_buff in all XDP capable drivers.

Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Reviewed-by: Alexander Duyck <alexanderduyck@fb.com>
Acked-by: Jesper Dangaard Brouer <brouer@redhat.com>
Acked-by: John Fastabend <john.fastabend@gmail.com>
Acked-by: Shay Agroskin <shayagr@amazon.com>
Acked-by: Martin Habets <habetsm.xilinx@gmail.com>
Acked-by: Camelia Groza <camelia.groza@nxp.com>
Acked-by: Marcin Wojtas <mw@semihalf.com>
Link: https://lore.kernel.org/bpf/7f8329b6da1434dc2b05a77f2e800b29628a8913.1608670965.git.lorenzo@kernel.org
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c
index 06596fa1f9fea3dc6c6ff4e3820f5a7d88c24259..43331f6967c9e8b8fd89fa2555ba578fc50f8a82 100644 (file)
--- a/drivers/net/ethernet/amazon/ena/ena_netdev.c
+++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c
@@ -1634,8 +1634,7 @@ static int ena_clean_rx_irq(struct ena_ring *rx_ring, struct napi_struct *napi,
        netif_dbg(rx_ring->adapter, rx_status, rx_ring->netdev,
                  "%s qid %d\n", __func__, rx_ring->qid);
        res_budget = budget;
-       xdp.rxq = &rx_ring->xdp_rxq;
-       xdp.frame_sz = ENA_PAGE_SIZE;
+       xdp_init_buff(&xdp, ENA_PAGE_SIZE, &rx_ring->xdp_rxq);
 
        do {
                xdp_verdict = XDP_PASS;

diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c
index fcc262064766a2d432c9006c7206c2e3fca438cf..ab805d6750e595f9bab2afcf34102153d5f7e5d3 100644 (file)
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c
@@ -133,12 +133,12 @@ bool bnxt_rx_xdp(struct bnxt *bp, struct bnxt_rx_ring_info *rxr, u16 cons,
        dma_sync_single_for_cpu(&pdev->dev, mapping + offset, *len, bp->rx_dir);
 
        txr = rxr->bnapi->tx_ring;
+       /* BNXT_RX_PAGE_MODE(bp) when XDP enabled */
+       xdp_init_buff(&xdp, PAGE_SIZE, &rxr->xdp_rxq);
        xdp.data_hard_start = *data_ptr - offset;
        xdp.data = *data_ptr;
        xdp_set_data_meta_invalid(&xdp);
        xdp.data_end = *data_ptr + *len;
-       xdp.rxq = &rxr->xdp_rxq;
-       xdp.frame_sz = PAGE_SIZE; /* BNXT_RX_PAGE_MODE(bp) when XDP enabled */
        orig_data = xdp.data;
 
        rcu_read_lock();

diff --git a/drivers/net/ethernet/cavium/thunder/nicvf_main.c b/drivers/net/ethernet/cavium/thunder/nicvf_main.c
index f3b7b443f9648ef3279b6a39010b0337962203d2..9fc672f075f2bc0168bc0e99f3dbd1dccdda2f61 100644 (file)
--- a/drivers/net/ethernet/cavium/thunder/nicvf_main.c
+++ b/drivers/net/ethernet/cavium/thunder/nicvf_main.c
@@ -547,12 +547,12 @@ static inline bool nicvf_xdp_rx(struct nicvf *nic, struct bpf_prog *prog,
        cpu_addr = (u64)phys_to_virt(cpu_addr);
        page = virt_to_page((void *)cpu_addr);
 
+       xdp_init_buff(&xdp, RCV_FRAG_LEN + XDP_PACKET_HEADROOM,
+                     &rq->xdp_rxq);
        xdp.data_hard_start = page_address(page);
        xdp.data = (void *)cpu_addr;
        xdp_set_data_meta_invalid(&xdp);
        xdp.data_end = xdp.data + len;
-       xdp.rxq = &rq->xdp_rxq;
-       xdp.frame_sz = RCV_FRAG_LEN + XDP_PACKET_HEADROOM;
        orig_data = xdp.data;
 
        rcu_read_lock();

diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
index 4360ce4d3fb6a1a9a4be2796a01c848f479251db..26e20b96fd96a9e93524bdd5d4d5189b3fd779bb 100644 (file)
--- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
+++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
@@ -2532,12 +2532,12 @@ static u32 dpaa_run_xdp(struct dpaa_priv *priv, struct qm_fd *fd, void *vaddr,
                return XDP_PASS;
        }
 
+       xdp_init_buff(&xdp, DPAA_BP_RAW_SIZE - DPAA_TX_PRIV_DATA_SIZE,
+                     &dpaa_fq->xdp_rxq);
        xdp.data = vaddr + fd_off;
        xdp.data_meta = xdp.data;
        xdp.data_hard_start = xdp.data - XDP_PACKET_HEADROOM;
        xdp.data_end = xdp.data + qm_fd_get_length(fd);
-       xdp.frame_sz = DPAA_BP_RAW_SIZE - DPAA_TX_PRIV_DATA_SIZE;
-       xdp.rxq = &dpaa_fq->xdp_rxq;
 
        /* We reserve a fixed headroom of 256 bytes under the erratum and we
         * offer it all to XDP programs to use. If no room is left for the

diff --git a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c
index fb0bcd18ec0c1c6e82ae89a4b63a9872bb9dab4d..3a7892a66fe54fa53e0c596322e9e06631272989 100644 (file)
--- a/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c
+++ b/drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c
@@ -358,14 +358,14 @@ static u32 dpaa2_eth_run_xdp(struct dpaa2_eth_priv *priv,
        if (!xdp_prog)
                goto out;
 
+       xdp_init_buff(&xdp,
+                     DPAA2_ETH_RX_BUF_RAW_SIZE -
+                     (dpaa2_fd_get_offset(fd) - XDP_PACKET_HEADROOM),
+                     &ch->xdp_rxq);
        xdp.data = vaddr + dpaa2_fd_get_offset(fd);
        xdp.data_end = xdp.data + dpaa2_fd_get_len(fd);
        xdp.data_hard_start = xdp.data - XDP_PACKET_HEADROOM;
        xdp_set_data_meta_invalid(&xdp);
-       xdp.rxq = &ch->xdp_rxq;
-
-       xdp.frame_sz = DPAA2_ETH_RX_BUF_RAW_SIZE -
-               (dpaa2_fd_get_offset(fd) - XDP_PACKET_HEADROOM);
 
        xdp_act = bpf_prog_run_xdp(xdp_prog, &xdp);
 

diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
index 4aca637d4a23cdd3513e4ec73d6e3ccc6b934aea..a87fb8264d0cf833445004be305274ce6166abe9 100644 (file)
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
@@ -2344,7 +2344,7 @@ static void i40e_inc_ntc(struct i40e_ring *rx_ring)
  **/
 static int i40e_clean_rx_irq(struct i40e_ring *rx_ring, int budget)
 {
-       unsigned int total_rx_bytes = 0, total_rx_packets = 0;
+       unsigned int total_rx_bytes = 0, total_rx_packets = 0, frame_sz = 0;
        struct sk_buff *skb = rx_ring->skb;
        u16 cleaned_count = I40E_DESC_UNUSED(rx_ring);
        unsigned int xdp_xmit = 0;
@@ -2352,9 +2352,9 @@ static int i40e_clean_rx_irq(struct i40e_ring *rx_ring, int budget)
        struct xdp_buff xdp;
 
 #if (PAGE_SIZE < 8192)
-       xdp.frame_sz = i40e_rx_frame_truesize(rx_ring, 0);
+       frame_sz = i40e_rx_frame_truesize(rx_ring, 0);
 #endif
-       xdp.rxq = &rx_ring->xdp_rxq;
+       xdp_init_buff(&xdp, frame_sz, &rx_ring->xdp_rxq);
 
        while (likely(total_rx_packets < (unsigned int)budget)) {
                struct i40e_rx_buffer *rx_buffer;

diff --git a/drivers/net/ethernet/intel/ice/ice_txrx.c b/drivers/net/ethernet/intel/ice/ice_txrx.c
index a2d0aad8cfdd765decb8e089bb2660f94e3442e2..500e93bf6238f0af872c8cf92c0062be3df3d4fc 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_txrx.c
+++ b/drivers/net/ethernet/intel/ice/ice_txrx.c
@@ -1089,18 +1089,18 @@ ice_is_non_eop(struct ice_ring *rx_ring, union ice_32b_rx_flex_desc *rx_desc,
  */
 int ice_clean_rx_irq(struct ice_ring *rx_ring, int budget)
 {
-       unsigned int total_rx_bytes = 0, total_rx_pkts = 0;
+       unsigned int total_rx_bytes = 0, total_rx_pkts = 0, frame_sz = 0;
        u16 cleaned_count = ICE_DESC_UNUSED(rx_ring);
        unsigned int xdp_res, xdp_xmit = 0;
        struct bpf_prog *xdp_prog = NULL;
        struct xdp_buff xdp;
        bool failure;
 
-       xdp.rxq = &rx_ring->xdp_rxq;
        /* Frame size depend on rx_ring setup when PAGE_SIZE=4K */
 #if (PAGE_SIZE < 8192)
-       xdp.frame_sz = ice_rx_frame_truesize(rx_ring, 0);
+       frame_sz = ice_rx_frame_truesize(rx_ring, 0);
 #endif
+       xdp_init_buff(&xdp, frame_sz, &rx_ring->xdp_rxq);
 
        /* start the loop to process Rx packets bounded by 'budget' */
        while (likely(total_rx_pkts < (unsigned int)budget)) {

diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index 03f78fdb0dcdd9b90eaa325dff8b481d093f712a..cf9e8b7d2c70d6846fe11a55de1d41cea76def5f 100644 (file)
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -8681,13 +8681,13 @@ static int igb_clean_rx_irq(struct igb_q_vector *q_vector, const int budget)
        u16 cleaned_count = igb_desc_unused(rx_ring);
        unsigned int xdp_xmit = 0;
        struct xdp_buff xdp;
-
-       xdp.rxq = &rx_ring->xdp_rxq;
+       u32 frame_sz = 0;
 
        /* Frame size depend on rx_ring setup when PAGE_SIZE=4K */
 #if (PAGE_SIZE < 8192)
-       xdp.frame_sz = igb_rx_frame_truesize(rx_ring, 0);
+       frame_sz = igb_rx_frame_truesize(rx_ring, 0);
 #endif
+       xdp_init_buff(&xdp, frame_sz, &rx_ring->xdp_rxq);
 
        while (likely(total_packets < budget)) {
                union e1000_adv_rx_desc *rx_desc;

diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 6cbbe09ce8a0d93486702fd450b3728481554046..7a7c86835a87d55d04cc68238f4678eed859b65a 100644 (file)
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -2291,7 +2291,7 @@ static int ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
                               struct ixgbe_ring *rx_ring,
                               const int budget)
 {
-       unsigned int total_rx_bytes = 0, total_rx_packets = 0;
+       unsigned int total_rx_bytes = 0, total_rx_packets = 0, frame_sz = 0;
        struct ixgbe_adapter *adapter = q_vector->adapter;
 #ifdef IXGBE_FCOE
        int ddp_bytes;
@@ -2301,12 +2301,11 @@ static int ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
        unsigned int xdp_xmit = 0;
        struct xdp_buff xdp;
 
-       xdp.rxq = &rx_ring->xdp_rxq;
-
        /* Frame size depend on rx_ring setup when PAGE_SIZE=4K */
 #if (PAGE_SIZE < 8192)
-       xdp.frame_sz = ixgbe_rx_frame_truesize(rx_ring, 0);
+       frame_sz = ixgbe_rx_frame_truesize(rx_ring, 0);
 #endif
+       xdp_init_buff(&xdp, frame_sz, &rx_ring->xdp_rxq);
 
        while (likely(total_rx_packets < budget)) {
                union ixgbe_adv_rx_desc *rx_desc;

diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index 4061cd7db5dd759715dc71e4b038bd1109777bc3..624efcd71569a000464cde4ec1837a2f68e159f2 100644 (file)
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -1121,19 +1121,18 @@ static int ixgbevf_clean_rx_irq(struct ixgbevf_q_vector *q_vector,
                                struct ixgbevf_ring *rx_ring,
                                int budget)
 {
-       unsigned int total_rx_bytes = 0, total_rx_packets = 0;
+       unsigned int total_rx_bytes = 0, total_rx_packets = 0, frame_sz = 0;
        struct ixgbevf_adapter *adapter = q_vector->adapter;
        u16 cleaned_count = ixgbevf_desc_unused(rx_ring);
        struct sk_buff *skb = rx_ring->skb;
        bool xdp_xmit = false;
        struct xdp_buff xdp;
 
-       xdp.rxq = &rx_ring->xdp_rxq;
-
        /* Frame size depend on rx_ring setup when PAGE_SIZE=4K */
 #if (PAGE_SIZE < 8192)
-       xdp.frame_sz = ixgbevf_rx_frame_truesize(rx_ring, 0);
+       frame_sz = ixgbevf_rx_frame_truesize(rx_ring, 0);
 #endif
+       xdp_init_buff(&xdp, frame_sz, &rx_ring->xdp_rxq);
 
        while (likely(total_rx_packets < budget)) {
                struct ixgbevf_rx_buffer *rx_buffer;

diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
index bc4d8d14440199b5d3d548204d010927ae1802d6..038c6b436cba4a8c93d0c053f119468fc1656450 100644 (file)
--- a/drivers/net/ethernet/marvell/mvneta.c
+++ b/drivers/net/ethernet/marvell/mvneta.c
@@ -2363,9 +2363,8 @@ static int mvneta_rx_swbm(struct napi_struct *napi,
        u32 desc_status, frame_sz;
        struct xdp_buff xdp_buf;
 
+       xdp_init_buff(&xdp_buf, PAGE_SIZE, &rxq->xdp_rxq);
        xdp_buf.data_hard_start = NULL;
-       xdp_buf.frame_sz = PAGE_SIZE;
-       xdp_buf.rxq = &rxq->xdp_rxq;
 
        sinfo.nr_frags = 0;
 

diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
index 4b1808acef5812a934aeed1b44a804bd4fdb9bb2..5872cb011ae15f328c9e979ef292d826c71cefe0 100644 (file)
--- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
+++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
@@ -3563,16 +3563,18 @@ static int mvpp2_rx(struct mvpp2_port *port, struct napi_struct *napi,
                        frag_size = bm_pool->frag_size;
 
                if (xdp_prog) {
+                       struct xdp_rxq_info *xdp_rxq;
+
                        xdp.data_hard_start = data;
                        xdp.data = data + MVPP2_MH_SIZE + MVPP2_SKB_HEADROOM;
                        xdp.data_end = xdp.data + rx_bytes;
-                       xdp.frame_sz = PAGE_SIZE;
 
                        if (bm_pool->pkt_size == MVPP2_BM_SHORT_PKT_SIZE)
-                               xdp.rxq = &rxq->xdp_rxq_short;
+                               xdp_rxq = &rxq->xdp_rxq_short;
                        else
-                               xdp.rxq = &rxq->xdp_rxq_long;
+                               xdp_rxq = &rxq->xdp_rxq_long;
 
+                       xdp_init_buff(&xdp, PAGE_SIZE, xdp_rxq);
                        xdp_set_data_meta_invalid(&xdp);
 
                        ret = mvpp2_run_xdp(port, rxq, xdp_prog, &xdp, pp, &ps);

diff --git a/drivers/net/ethernet/mellanox/mlx4/en_rx.c b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
index c1c9118a66c9326982d33bcf2245feed73a3e0c7..93da9c2d50c078aecad2294d1502c26065df286a 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx4/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
@@ -682,8 +682,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
        /* Protect accesses to: ring->xdp_prog, priv->mac_hash list */
        rcu_read_lock();
        xdp_prog = rcu_dereference(ring->xdp_prog);
-       xdp.rxq = &ring->xdp_rxq;
-       xdp.frame_sz = priv->frag_info[0].frag_stride;
+       xdp_init_buff(&xdp, priv->frag_info[0].frag_stride, &ring->xdp_rxq);
        doorbell_pending = false;
 
        /* We assume a 1:1 mapping between CQEs and Rx descriptors, so Rx

diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
index 7f5851c612181e42489dddbaa2e6450950ce64f9..bc7c81f2b0360db86ed7b83a12eb1e8b5166643d 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
@@ -1126,12 +1126,11 @@ struct sk_buff *mlx5e_build_linear_skb(struct mlx5e_rq *rq, void *va,
 static void mlx5e_fill_xdp_buff(struct mlx5e_rq *rq, void *va, u16 headroom,
                                u32 len, struct xdp_buff *xdp)
 {
+       xdp_init_buff(xdp, rq->buff.frame0_sz, &rq->xdp_rxq);
        xdp->data_hard_start = va;
        xdp->data = va + headroom;
        xdp_set_data_meta_invalid(xdp);
        xdp->data_end = xdp->data + len;
-       xdp->rxq = &rq->xdp_rxq;
-       xdp->frame_sz = rq->buff.frame0_sz;
 }
 
 static struct sk_buff *

diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
index 7ba8f4c7f26d5b746a10724d78fc540d7b425602..513bc60bcd09c8401c2959ed2760af0313e85abf 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
@@ -1822,8 +1822,8 @@ static int nfp_net_rx(struct nfp_net_rx_ring *rx_ring, int budget)
        rcu_read_lock();
        xdp_prog = READ_ONCE(dp->xdp_prog);
        true_bufsz = xdp_prog ? PAGE_SIZE : dp->fl_bufsz;
-       xdp.frame_sz = PAGE_SIZE - NFP_NET_RX_BUF_HEADROOM;
-       xdp.rxq = &rx_ring->xdp_rxq;
+       xdp_init_buff(&xdp, PAGE_SIZE - NFP_NET_RX_BUF_HEADROOM,
+                     &rx_ring->xdp_rxq);
        tx_ring = r_vec->xdp_ring;
 
        while (pkts_polled < budget) {

diff --git a/drivers/net/ethernet/qlogic/qede/qede_fp.c b/drivers/net/ethernet/qlogic/qede/qede_fp.c
index ca0ee29a57b50ac4fd15d19be46ab6de0766a311..8d0c6d62022a1cbab93366c5cfbda09ee6f02e83 100644 (file)
--- a/drivers/net/ethernet/qlogic/qede/qede_fp.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_fp.c
@@ -1090,12 +1090,11 @@ static bool qede_rx_xdp(struct qede_dev *edev,
        struct xdp_buff xdp;
        enum xdp_action act;
 
+       xdp_init_buff(&xdp, rxq->rx_buf_seg_size, &rxq->xdp_rxq);
        xdp.data_hard_start = page_address(bd->data);
        xdp.data = xdp.data_hard_start + *data_offset;
        xdp_set_data_meta_invalid(&xdp);
        xdp.data_end = xdp.data + *len;
-       xdp.rxq = &rxq->xdp_rxq;
-       xdp.frame_sz = rxq->rx_buf_seg_size; /* PAGE_SIZE when XDP enabled */
 
        /* Queues always have a full reset currently, so for the time
         * being until there's atomic program replace just mark read

diff --git a/drivers/net/ethernet/sfc/rx.c b/drivers/net/ethernet/sfc/rx.c
index aaa112877561ffdeaf5bd7c0661be7e1232cd969..eaa6650955d1ae3cd5a3c715e7faede26e382e8a 100644 (file)
--- a/drivers/net/ethernet/sfc/rx.c
+++ b/drivers/net/ethernet/sfc/rx.c
@@ -293,14 +293,13 @@ static bool efx_do_xdp(struct efx_nic *efx, struct efx_channel *channel,
        memcpy(rx_prefix, *ehp - efx->rx_prefix_size,
               efx->rx_prefix_size);
 
+       xdp_init_buff(&xdp, efx->rx_page_buf_step, &rx_queue->xdp_rxq_info);
        xdp.data = *ehp;
        xdp.data_hard_start = xdp.data - EFX_XDP_HEADROOM;
 
        /* No support yet for XDP metadata */
        xdp_set_data_meta_invalid(&xdp);
        xdp.data_end = xdp.data + rx_buf->len;
-       xdp.rxq = &rx_queue->xdp_rxq_info;
-       xdp.frame_sz = efx->rx_page_buf_step;
 
        xdp_act = bpf_prog_run_xdp(xdp_prog, &xdp);
        rcu_read_unlock();

diff --git a/drivers/net/ethernet/socionext/netsec.c b/drivers/net/ethernet/socionext/netsec.c
index 19d20a6d0d4452545eb0dac1946a16cefdfb05c9..945ca9517bf94911deb780c28af2d010a22bb999 100644 (file)
--- a/drivers/net/ethernet/socionext/netsec.c
+++ b/drivers/net/ethernet/socionext/netsec.c
@@ -956,8 +956,7 @@ static int netsec_process_rx(struct netsec_priv *priv, int budget)
        u32 xdp_act = 0;
        int done = 0;
 
-       xdp.rxq = &dring->xdp_rxq;
-       xdp.frame_sz = PAGE_SIZE;
+       xdp_init_buff(&xdp, PAGE_SIZE, &dring->xdp_rxq);
 
        rcu_read_lock();
        xdp_prog = READ_ONCE(priv->xdp_prog);

diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index b0f00b4edd9491b1d0cb37df8a7c6be6818b32ef..78a923391828ecf7347c96fd39d3c8ab059877eb 100644 (file)
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -392,6 +392,8 @@ static void cpsw_rx_handler(void *token, int len, int status)
        }
 
        if (priv->xdp_prog) {
+               xdp_init_buff(&xdp, PAGE_SIZE, &priv->xdp_rxq[ch]);
+
                if (status & CPDMA_RX_VLAN_ENCAP) {
                        xdp.data = pa + CPSW_HEADROOM +
                                   CPSW_RX_VLAN_ENCAP_HDR_SIZE;
@@ -405,8 +407,6 @@ static void cpsw_rx_handler(void *token, int len, int status)
                xdp_set_data_meta_invalid(&xdp);
 
                xdp.data_hard_start = pa;
-               xdp.rxq = &priv->xdp_rxq[ch];
-               xdp.frame_sz = PAGE_SIZE;
 
                port = priv->emac_port + cpsw->data.dual_emac;
                ret = cpsw_run_xdp(priv, ch, &xdp, page, port);

diff --git a/drivers/net/ethernet/ti/cpsw_new.c b/drivers/net/ethernet/ti/cpsw_new.c
index 2f5e0ad23ad7cf13a090471f553c656063ca285a..1b3385ec9645f8d804026e6c09e60ad1022ad794 100644 (file)
--- a/drivers/net/ethernet/ti/cpsw_new.c
+++ b/drivers/net/ethernet/ti/cpsw_new.c
@@ -335,6 +335,8 @@ static void cpsw_rx_handler(void *token, int len, int status)
        }
 
        if (priv->xdp_prog) {
+               xdp_init_buff(&xdp, PAGE_SIZE, &priv->xdp_rxq[ch]);
+
                if (status & CPDMA_RX_VLAN_ENCAP) {
                        xdp.data = pa + CPSW_HEADROOM +
                                   CPSW_RX_VLAN_ENCAP_HDR_SIZE;
@@ -348,8 +350,6 @@ static void cpsw_rx_handler(void *token, int len, int status)
                xdp_set_data_meta_invalid(&xdp);
 
                xdp.data_hard_start = pa;
-               xdp.rxq = &priv->xdp_rxq[ch];
-               xdp.frame_sz = PAGE_SIZE;
 
                ret = cpsw_run_xdp(priv, ch, &xdp, page, priv->emac_port);
                if (ret != CPSW_XDP_PASS)

diff --git a/drivers/net/hyperv/netvsc_bpf.c b/drivers/net/hyperv/netvsc_bpf.c
index 440486d9c999e4358781102869ce37fe14ef7e9d..14a7ee4c68998a816896b2e07eaa6aac4345d35f 100644 (file)
--- a/drivers/net/hyperv/netvsc_bpf.c
+++ b/drivers/net/hyperv/netvsc_bpf.c
@@ -44,12 +44,11 @@ u32 netvsc_run_xdp(struct net_device *ndev, struct netvsc_channel *nvchan,
                goto out;
        }
 
+       xdp_init_buff(xdp, PAGE_SIZE, &nvchan->xdp_rxq);
        xdp->data_hard_start = page_address(page);
        xdp->data = xdp->data_hard_start + NETVSC_XDP_HDRM;
        xdp_set_data_meta_invalid(xdp);
        xdp->data_end = xdp->data + len;
-       xdp->rxq = &nvchan->xdp_rxq;
-       xdp->frame_sz = PAGE_SIZE;
 
        memcpy(xdp->data, data, len);
 

diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 02a93cfdb6b1a94d2e61916eb4e2b69f01edee45..3b7728433a863c60fa41a16d3e32669217eb790c 100644 (file)
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -1599,12 +1599,11 @@ static struct sk_buff *tun_build_skb(struct tun_struct *tun,
                struct xdp_buff xdp;
                u32 act;
 
+               xdp_init_buff(&xdp, buflen, &tfile->xdp_rxq);
                xdp.data_hard_start = buf;
                xdp.data = buf + pad;
                xdp_set_data_meta_invalid(&xdp);
                xdp.data_end = xdp.data + len;
-               xdp.rxq = &tfile->xdp_rxq;
-               xdp.frame_sz = buflen;
 
                act = bpf_prog_run_xdp(xdp_prog, &xdp);
                if (act == XDP_REDIRECT || act == XDP_TX) {
@@ -2342,9 +2341,9 @@ static int tun_xdp_one(struct tun_struct *tun,
                        skb_xdp = true;
                        goto build;
                }
+
+               xdp_init_buff(xdp, buflen, &tfile->xdp_rxq);
                xdp_set_data_meta_invalid(xdp);
-               xdp->rxq = &tfile->xdp_rxq;
-               xdp->frame_sz = buflen;
 
                act = bpf_prog_run_xdp(xdp_prog, xdp);
                err = tun_xdp_act(tun, xdp_prog, xdp, act);

diff --git a/drivers/net/veth.c b/drivers/net/veth.c
index 02bfcdf50a7ac60e14aeeaec242eeba7c6b7c88c..25f3601fb6dd59990d36414707c47f9e63cf9ec4 100644 (file)
--- a/drivers/net/veth.c
+++ b/drivers/net/veth.c
@@ -654,7 +654,7 @@ static struct sk_buff *veth_xdp_rcv_skb(struct veth_rq *rq,
                                        struct veth_xdp_tx_bq *bq,
                                        struct veth_stats *stats)
 {
-       u32 pktlen, headroom, act, metalen;
+       u32 pktlen, headroom, act, metalen, frame_sz;
        void *orig_data, *orig_data_end;
        struct bpf_prog *xdp_prog;
        int mac_len, delta, off;
@@ -714,11 +714,11 @@ static struct sk_buff *veth_xdp_rcv_skb(struct veth_rq *rq,
        xdp.data = skb_mac_header(skb);
        xdp.data_end = xdp.data + pktlen;
        xdp.data_meta = xdp.data;
-       xdp.rxq = &rq->xdp_rxq;
 
        /* SKB "head" area always have tailroom for skb_shared_info */
-       xdp.frame_sz = (void *)skb_end_pointer(skb) - xdp.data_hard_start;
-       xdp.frame_sz += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+       frame_sz = (void *)skb_end_pointer(skb) - xdp.data_hard_start;
+       frame_sz += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+       xdp_init_buff(&xdp, frame_sz, &rq->xdp_rxq);
 
        orig_data = xdp.data;
        orig_data_end = xdp.data_end;

diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 508408fbe78fbd8658dc226834b5b1b334b8b011..36b0f81bcd7aa4912b170dd43704a05d865347dc 100644 (file)
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -689,12 +689,11 @@ static struct sk_buff *receive_small(struct net_device *dev,
                        page = xdp_page;
                }
 
+               xdp_init_buff(&xdp, buflen, &rq->xdp_rxq);
                xdp.data_hard_start = buf + VIRTNET_RX_PAD + vi->hdr_len;
                xdp.data = xdp.data_hard_start + xdp_headroom;
                xdp.data_end = xdp.data + len;
                xdp.data_meta = xdp.data;
-               xdp.rxq = &rq->xdp_rxq;
-               xdp.frame_sz = buflen;
                orig_data = xdp.data;
                act = bpf_prog_run_xdp(xdp_prog, &xdp);
                stats->xdp_packets++;
@@ -859,12 +858,11 @@ static struct sk_buff *receive_mergeable(struct net_device *dev,
                 * the descriptor on if we get an XDP_TX return code.
                 */
                data = page_address(xdp_page) + offset;
+               xdp_init_buff(&xdp, frame_sz - vi->hdr_len, &rq->xdp_rxq);
                xdp.data_hard_start = data - VIRTIO_XDP_HEADROOM + vi->hdr_len;
                xdp.data = data + vi->hdr_len;
                xdp.data_end = xdp.data + (len - vi->hdr_len);
                xdp.data_meta = xdp.data;
-               xdp.rxq = &rq->xdp_rxq;
-               xdp.frame_sz = frame_sz - vi->hdr_len;
 
                act = bpf_prog_run_xdp(xdp_prog, &xdp);
                stats->xdp_packets++;

diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index b01848ef46493f9bc19a853b784896429cd5923b..329397c60d846673af108af56bf6506d63535e4a 100644 (file)
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -864,12 +864,12 @@ static u32 xennet_run_xdp(struct netfront_queue *queue, struct page *pdata,
        u32 act;
        int err;
 
+       xdp_init_buff(xdp, XEN_PAGE_SIZE - XDP_PACKET_HEADROOM,
+                     &queue->xdp_rxq);
        xdp->data_hard_start = page_address(pdata);
        xdp->data = xdp->data_hard_start + XDP_PACKET_HEADROOM;
        xdp_set_data_meta_invalid(xdp);
        xdp->data_end = xdp->data + len;
-       xdp->rxq = &queue->xdp_rxq;
-       xdp->frame_sz = XEN_PAGE_SIZE - XDP_PACKET_HEADROOM;
 
        act = bpf_prog_run_xdp(prog, xdp);
        switch (act) {

diff --git a/include/net/xdp.h b/include/net/xdp.h
index 600acb307db6151bfe9057b418159069add25897..8a589f7e08e04ba812f74df30b0cdc4faa0b71dc 100644 (file)
--- a/include/net/xdp.h
+++ b/include/net/xdp.h
@@ -76,6 +76,13 @@ struct xdp_buff {
        u32 frame_sz; /* frame size to deduce data_hard_end/reserved tailroom*/
 };
 
+static __always_inline void
+xdp_init_buff(struct xdp_buff *xdp, u32 frame_sz, struct xdp_rxq_info *rxq)
+{
+       xdp->frame_sz = frame_sz;
+       xdp->rxq = rxq;
+}
+
 /* Reserve memory area at end-of data area.
  *
  * This macro reserves tailroom in the XDP buffer by limiting the

diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c
index c1c30a9f76f343e90570102e6eb9d8407ae563ea..a8fa5a9e41375db3ea0b85eb88e29377c0a4c090 100644 (file)
--- a/net/bpf/test_run.c
+++ b/net/bpf/test_run.c
@@ -640,10 +640,10 @@ int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,
        xdp.data = data + headroom;
        xdp.data_meta = xdp.data;
        xdp.data_end = xdp.data + size;
-       xdp.frame_sz = headroom + max_data_sz + tailroom;
 
        rxqueue = __netif_get_rx_queue(current->nsproxy->net_ns->loopback_dev, 0);
-       xdp.rxq = &rxqueue->xdp_rxq;
+       xdp_init_buff(&xdp, headroom + max_data_sz + tailroom,
+                     &rxqueue->xdp_rxq);
        bpf_prog_change_xdp(NULL, prog);
        ret = bpf_test_run(prog, &xdp, repeat, &retval, &duration, true);
        if (ret)

diff --git a/net/core/dev.c b/net/core/dev.c
index 7afbb642e203ad1556e96e2fc7595b6289152201..e6d758a3c2a92a235ad9be598416677bf330203c 100644 (file)
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -4606,11 +4606,11 @@ static u32 netif_receive_generic_xdp(struct sk_buff *skb,
        struct netdev_rx_queue *rxqueue;
        void *orig_data, *orig_data_end;
        u32 metalen, act = XDP_DROP;
+       u32 mac_len, frame_sz;
        __be16 orig_eth_type;
        struct ethhdr *eth;
        bool orig_bcast;
        int hlen, off;
-       u32 mac_len;
 
        /* Reinjected packets coming from act_mirred or similar should
         * not get XDP generic processing.
@@ -4649,8 +4649,8 @@ static u32 netif_receive_generic_xdp(struct sk_buff *skb,
        xdp->data_hard_start = skb->data - skb_headroom(skb);
 
        /* SKB "head" area always have tailroom for skb_shared_info */
-       xdp->frame_sz  = (void *)skb_end_pointer(skb) - xdp->data_hard_start;
-       xdp->frame_sz += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+       frame_sz = (void *)skb_end_pointer(skb) - xdp->data_hard_start;
+       frame_sz += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
 
        orig_data_end = xdp->data_end;
        orig_data = xdp->data;
@@ -4659,7 +4659,7 @@ static u32 netif_receive_generic_xdp(struct sk_buff *skb,
        orig_eth_type = eth->h_proto;
 
        rxqueue = netif_get_rxqueue(skb);
-       xdp->rxq = &rxqueue->xdp_rxq;
+       xdp_init_buff(xdp, frame_sz, &rxqueue->xdp_rxq);
 
        act = bpf_prog_run_xdp(xdp_prog, xdp);