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.

Merge branch 'net-xdp-add-missing-metadata-support-for-some-xdp-drvs'

Lorenzo Bianconi says:

====================
net: xdp: Add missing metadata support for some xdp drvs

Introduce missing metadata support for some xdp drivers setting metadata
size building the skb from xdp_buff.
Please note most of the drivers are just compile tested.

v1: https://lore.kernel.org/20250311-mvneta-xdp-meta-v1-0-36cf1c99790e@kernel.org
====================

Link: https://patch.msgid.link/20250318-mvneta-xdp-meta-v2-0-b6075778f61f@kernel.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski 82b06429 6165feda

+44 -14
+4 -1
drivers/net/ethernet/marvell/mvneta.c
··· 2342 2342 prefetch(data); 2343 2343 xdp_buff_clear_frags_flag(xdp); 2344 2344 xdp_prepare_buff(xdp, data, pp->rx_offset_correction + MVNETA_MH_SIZE, 2345 - data_len, false); 2345 + data_len, true); 2346 2346 } 2347 2347 2348 2348 static void ··· 2396 2396 struct xdp_buff *xdp, u32 desc_status) 2397 2397 { 2398 2398 struct skb_shared_info *sinfo = xdp_get_shared_info_from_buff(xdp); 2399 + u32 metasize = xdp->data - xdp->data_meta; 2399 2400 struct sk_buff *skb; 2400 2401 u8 num_frags; 2401 2402 ··· 2411 2410 2412 2411 skb_reserve(skb, xdp->data - xdp->data_hard_start); 2413 2412 skb_put(skb, xdp->data_end - xdp->data); 2413 + if (metasize) 2414 + skb_metadata_set(skb, metasize); 2414 2415 skb->ip_summed = mvneta_rx_csum(pp, desc_status); 2415 2416 2416 2417 if (unlikely(xdp_buff_has_frags(xdp)))
+6 -2
drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
··· 3915 3915 3916 3916 while (rx_done < rx_todo) { 3917 3917 struct mvpp2_rx_desc *rx_desc = mvpp2_rxq_next_desc_get(rxq); 3918 + u32 rx_status, timestamp, metasize = 0; 3918 3919 struct mvpp2_bm_pool *bm_pool; 3919 3920 struct page_pool *pp = NULL; 3920 3921 struct sk_buff *skb; 3921 3922 unsigned int frag_size; 3922 3923 dma_addr_t dma_addr; 3923 3924 phys_addr_t phys_addr; 3924 - u32 rx_status, timestamp; 3925 3925 int pool, rx_bytes, err, ret; 3926 3926 struct page *page; 3927 3927 void *data; ··· 3983 3983 xdp_init_buff(&xdp, PAGE_SIZE, xdp_rxq); 3984 3984 xdp_prepare_buff(&xdp, data, 3985 3985 MVPP2_MH_SIZE + MVPP2_SKB_HEADROOM, 3986 - rx_bytes, false); 3986 + rx_bytes, true); 3987 3987 3988 3988 ret = mvpp2_run_xdp(port, xdp_prog, &xdp, pp, &ps); 3989 3989 ··· 3999 3999 ps.rx_bytes += rx_bytes; 4000 4000 continue; 4001 4001 } 4002 + 4003 + metasize = xdp.data - xdp.data_meta; 4002 4004 } 4003 4005 4004 4006 if (frag_size) ··· 4040 4038 4041 4039 skb_reserve(skb, MVPP2_MH_SIZE + MVPP2_SKB_HEADROOM); 4042 4040 skb_put(skb, rx_bytes); 4041 + if (metasize) 4042 + skb_metadata_set(skb, metasize); 4043 4043 skb->ip_summed = mvpp2_rx_csum(port, rx_status); 4044 4044 skb->protocol = eth_type_trans(skb, dev); 4045 4045
+9 -4
drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c
··· 41 41 struct bpf_prog *prog, 42 42 struct nix_cqe_rx_s *cqe, 43 43 struct otx2_cq_queue *cq, 44 - bool *need_xdp_flush); 44 + u32 *metasize, bool *need_xdp_flush); 45 45 46 46 static void otx2_sq_set_sqe_base(struct otx2_snd_queue *sq, 47 47 struct sk_buff *skb) ··· 336 336 struct nix_rx_sg_s *sg = &cqe->sg; 337 337 struct sk_buff *skb = NULL; 338 338 void *end, *start; 339 + u32 metasize = 0; 339 340 u64 *seg_addr; 340 341 u16 *seg_size; 341 342 int seg; ··· 347 346 } 348 347 349 348 if (pfvf->xdp_prog) 350 - if (otx2_xdp_rcv_pkt_handler(pfvf, pfvf->xdp_prog, cqe, cq, need_xdp_flush)) 349 + if (otx2_xdp_rcv_pkt_handler(pfvf, pfvf->xdp_prog, cqe, cq, 350 + &metasize, need_xdp_flush)) 351 351 return; 352 352 353 353 skb = napi_get_frags(napi); ··· 380 378 skb->mark = parse->match_id; 381 379 382 380 skb_mark_for_recycle(skb); 381 + if (metasize) 382 + skb_metadata_set(skb, metasize); 383 383 384 384 napi_gro_frags(napi); 385 385 } ··· 1486 1482 struct bpf_prog *prog, 1487 1483 struct nix_cqe_rx_s *cqe, 1488 1484 struct otx2_cq_queue *cq, 1489 - bool *need_xdp_flush) 1485 + u32 *metasize, bool *need_xdp_flush) 1490 1486 { 1491 1487 struct xdp_buff xdp, *xsk_buff = NULL; 1492 1488 unsigned char *hard_start; ··· 1518 1514 1519 1515 hard_start = (unsigned char *)phys_to_virt(pa); 1520 1516 xdp_prepare_buff(&xdp, hard_start, OTX2_HEAD_ROOM, 1521 - cqe->sg.seg_size, false); 1517 + cqe->sg.seg_size, true); 1522 1518 1523 1519 act = bpf_prog_run_xdp(prog, &xdp); 1524 1520 1525 1521 handle_xdp_verdict: 1526 1522 switch (act) { 1527 1523 case XDP_PASS: 1524 + *metasize = xdp.data - xdp.data_meta; 1528 1525 break; 1529 1526 case XDP_TX: 1530 1527 qidx += pfvf->hw.tx_queues;
+5 -2
drivers/net/ethernet/mediatek/mtk_eth_soc.c
··· 2122 2122 if (ring->page_pool) { 2123 2123 struct page *page = virt_to_head_page(data); 2124 2124 struct xdp_buff xdp; 2125 - u32 ret; 2125 + u32 ret, metasize; 2126 2126 2127 2127 new_data = mtk_page_pool_get_buff(ring->page_pool, 2128 2128 &dma_addr, ··· 2138 2138 2139 2139 xdp_init_buff(&xdp, PAGE_SIZE, &ring->xdp_q); 2140 2140 xdp_prepare_buff(&xdp, data, MTK_PP_HEADROOM, pktlen, 2141 - false); 2141 + true); 2142 2142 xdp_buff_clear_frags_flag(&xdp); 2143 2143 2144 2144 ret = mtk_xdp_run(eth, ring, &xdp, netdev); ··· 2158 2158 2159 2159 skb_reserve(skb, xdp.data - xdp.data_hard_start); 2160 2160 skb_put(skb, xdp.data_end - xdp.data); 2161 + metasize = xdp.data - xdp.data_meta; 2162 + if (metasize) 2163 + skb_metadata_set(skb, metasize); 2161 2164 skb_mark_for_recycle(skb); 2162 2165 } else { 2163 2166 if (ring->frag_size <= PAGE_SIZE)
+1 -1
drivers/net/ethernet/microsoft/mana/mana_bpf.c
··· 91 91 goto out; 92 92 93 93 xdp_init_buff(xdp, PAGE_SIZE, &rxq->xdp_rxq); 94 - xdp_prepare_buff(xdp, buf_va, XDP_PACKET_HEADROOM, pkt_len, false); 94 + xdp_prepare_buff(xdp, buf_va, XDP_PACKET_HEADROOM, pkt_len, true); 95 95 96 96 act = bpf_prog_run_xdp(prog, xdp); 97 97
+4
drivers/net/ethernet/microsoft/mana/mana_en.c
··· 1559 1559 return NULL; 1560 1560 1561 1561 if (xdp->data_hard_start) { 1562 + u32 metasize = xdp->data - xdp->data_meta; 1563 + 1562 1564 skb_reserve(skb, xdp->data - xdp->data_hard_start); 1563 1565 skb_put(skb, xdp->data_end - xdp->data); 1566 + if (metasize) 1567 + skb_metadata_set(skb, metasize); 1564 1568 return skb; 1565 1569 } 1566 1570
+5 -2
drivers/net/ethernet/socionext/netsec.c
··· 970 970 struct netsec_de *de = dring->vaddr + (DESC_SZ * idx); 971 971 struct netsec_desc *desc = &dring->desc[idx]; 972 972 struct page *page = virt_to_page(desc->addr); 973 - u32 xdp_result = NETSEC_XDP_PASS; 973 + u32 metasize, xdp_result = NETSEC_XDP_PASS; 974 974 struct sk_buff *skb = NULL; 975 975 u16 pkt_len, desc_len; 976 976 dma_addr_t dma_handle; ··· 1019 1019 prefetch(desc->addr); 1020 1020 1021 1021 xdp_prepare_buff(&xdp, desc->addr, NETSEC_RXBUF_HEADROOM, 1022 - pkt_len, false); 1022 + pkt_len, true); 1023 1023 1024 1024 if (xdp_prog) { 1025 1025 xdp_result = netsec_run_xdp(priv, xdp_prog, &xdp); ··· 1048 1048 1049 1049 skb_reserve(skb, xdp.data - xdp.data_hard_start); 1050 1050 skb_put(skb, xdp.data_end - xdp.data); 1051 + metasize = xdp.data - xdp.data_meta; 1052 + if (metasize) 1053 + skb_metadata_set(skb, metasize); 1051 1054 skb->protocol = eth_type_trans(skb, priv->ndev); 1052 1055 1053 1056 if (priv->rx_cksum_offload_flag &&
+5 -1
drivers/net/ethernet/ti/cpsw.c
··· 351 351 int ret = 0, port, ch = xmeta->ch; 352 352 int headroom = CPSW_HEADROOM_NA; 353 353 struct net_device *ndev = xmeta->ndev; 354 + u32 metasize = 0; 354 355 struct cpsw_priv *priv; 355 356 struct page_pool *pool; 356 357 struct sk_buff *skb; ··· 401 400 size -= CPSW_RX_VLAN_ENCAP_HDR_SIZE; 402 401 } 403 402 404 - xdp_prepare_buff(&xdp, pa, headroom, size, false); 403 + xdp_prepare_buff(&xdp, pa, headroom, size, true); 405 404 406 405 port = priv->emac_port + cpsw->data.dual_emac; 407 406 ret = cpsw_run_xdp(priv, ch, &xdp, page, port, &len); ··· 409 408 goto requeue; 410 409 411 410 headroom = xdp.data - xdp.data_hard_start; 411 + metasize = xdp.data - xdp.data_meta; 412 412 413 413 /* XDP prog can modify vlan tag, so can't use encap header */ 414 414 status &= ~CPDMA_RX_VLAN_ENCAP; ··· 425 423 426 424 skb_reserve(skb, headroom); 427 425 skb_put(skb, len); 426 + if (metasize) 427 + skb_metadata_set(skb, metasize); 428 428 skb->dev = ndev; 429 429 if (status & CPDMA_RX_VLAN_ENCAP) 430 430 cpsw_rx_vlan_encap(skb);
+5 -1
drivers/net/ethernet/ti/cpsw_new.c
··· 293 293 struct page_pool *pool; 294 294 struct sk_buff *skb; 295 295 struct xdp_buff xdp; 296 + u32 metasize = 0; 296 297 int ret = 0; 297 298 dma_addr_t dma; 298 299 ··· 346 345 size -= CPSW_RX_VLAN_ENCAP_HDR_SIZE; 347 346 } 348 347 349 - xdp_prepare_buff(&xdp, pa, headroom, size, false); 348 + xdp_prepare_buff(&xdp, pa, headroom, size, true); 350 349 351 350 ret = cpsw_run_xdp(priv, ch, &xdp, page, priv->emac_port, &len); 352 351 if (ret != CPSW_XDP_PASS) 353 352 goto requeue; 354 353 355 354 headroom = xdp.data - xdp.data_hard_start; 355 + metasize = xdp.data - xdp.data_meta; 356 356 357 357 /* XDP prog can modify vlan tag, so can't use encap header */ 358 358 status &= ~CPDMA_RX_VLAN_ENCAP; ··· 370 368 skb->offload_fwd_mark = priv->offload_fwd_mark; 371 369 skb_reserve(skb, headroom); 372 370 skb_put(skb, len); 371 + if (metasize) 372 + skb_metadata_set(skb, metasize); 373 373 skb->dev = ndev; 374 374 if (status & CPDMA_RX_VLAN_ENCAP) 375 375 cpsw_rx_vlan_encap(skb);