1
2
3
4
5
6#ifndef __LINUX_NET_XDP_H__
7#define __LINUX_NET_XDP_H__
8
9#include <linux/skbuff.h>
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38enum xdp_mem_type {
39 MEM_TYPE_PAGE_SHARED = 0,
40 MEM_TYPE_PAGE_ORDER0,
41 MEM_TYPE_PAGE_POOL,
42 MEM_TYPE_XSK_BUFF_POOL,
43 MEM_TYPE_MAX,
44};
45
46
47#define XDP_XMIT_FLUSH (1U << 0)
48#define XDP_XMIT_FLAGS_MASK XDP_XMIT_FLUSH
49
50struct xdp_mem_info {
51 u32 type;
52 u32 id;
53};
54
55struct page_pool;
56
57struct xdp_rxq_info {
58 struct net_device *dev;
59 u32 queue_index;
60 u32 reg_state;
61 struct xdp_mem_info mem;
62 unsigned int napi_id;
63} ____cacheline_aligned;
64
65struct xdp_txq_info {
66 struct net_device *dev;
67};
68
69struct xdp_buff {
70 void *data;
71 void *data_end;
72 void *data_meta;
73 void *data_hard_start;
74 struct xdp_rxq_info *rxq;
75 struct xdp_txq_info *txq;
76 u32 frame_sz;
77};
78
79static __always_inline void
80xdp_init_buff(struct xdp_buff *xdp, u32 frame_sz, struct xdp_rxq_info *rxq)
81{
82 xdp->frame_sz = frame_sz;
83 xdp->rxq = rxq;
84}
85
86static __always_inline void
87xdp_prepare_buff(struct xdp_buff *xdp, unsigned char *hard_start,
88 int headroom, int data_len, const bool meta_valid)
89{
90 unsigned char *data = hard_start + headroom;
91
92 xdp->data_hard_start = hard_start;
93 xdp->data = data;
94 xdp->data_end = data + data_len;
95 xdp->data_meta = meta_valid ? data : data + 1;
96}
97
98
99
100
101
102
103
104#define xdp_data_hard_end(xdp) \
105 ((xdp)->data_hard_start + (xdp)->frame_sz - \
106 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
107
108static inline struct skb_shared_info *
109xdp_get_shared_info_from_buff(struct xdp_buff *xdp)
110{
111 return (struct skb_shared_info *)xdp_data_hard_end(xdp);
112}
113
114struct xdp_frame {
115 void *data;
116 u16 len;
117 u16 headroom;
118 u32 metasize:8;
119 u32 frame_sz:24;
120
121
122
123 struct xdp_mem_info mem;
124 struct net_device *dev_rx;
125};
126
127#define XDP_BULK_QUEUE_SIZE 16
128struct xdp_frame_bulk {
129 int count;
130 void *xa;
131 void *q[XDP_BULK_QUEUE_SIZE];
132};
133
134static __always_inline void xdp_frame_bulk_init(struct xdp_frame_bulk *bq)
135{
136
137 bq->xa = NULL;
138}
139
140static inline struct skb_shared_info *
141xdp_get_shared_info_from_frame(struct xdp_frame *frame)
142{
143 void *data_hard_start = frame->data - frame->headroom - sizeof(*frame);
144
145 return (struct skb_shared_info *)(data_hard_start + frame->frame_sz -
146 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)));
147}
148
149struct xdp_cpumap_stats {
150 unsigned int redirect;
151 unsigned int pass;
152 unsigned int drop;
153};
154
155
156static inline void xdp_scrub_frame(struct xdp_frame *frame)
157{
158 frame->data = NULL;
159 frame->dev_rx = NULL;
160}
161
162
163void xdp_warn(const char *msg, const char *func, const int line);
164#define XDP_WARN(msg) xdp_warn(msg, __func__, __LINE__)
165
166struct xdp_frame *xdp_convert_zc_to_xdp_frame(struct xdp_buff *xdp);
167struct sk_buff *__xdp_build_skb_from_frame(struct xdp_frame *xdpf,
168 struct sk_buff *skb,
169 struct net_device *dev);
170struct sk_buff *xdp_build_skb_from_frame(struct xdp_frame *xdpf,
171 struct net_device *dev);
172int xdp_alloc_skb_bulk(void **skbs, int n_skb, gfp_t gfp);
173struct xdp_frame *xdpf_clone(struct xdp_frame *xdpf);
174
175static inline
176void xdp_convert_frame_to_buff(struct xdp_frame *frame, struct xdp_buff *xdp)
177{
178 xdp->data_hard_start = frame->data - frame->headroom - sizeof(*frame);
179 xdp->data = frame->data;
180 xdp->data_end = frame->data + frame->len;
181 xdp->data_meta = frame->data - frame->metasize;
182 xdp->frame_sz = frame->frame_sz;
183}
184
185static inline
186int xdp_update_frame_from_buff(struct xdp_buff *xdp,
187 struct xdp_frame *xdp_frame)
188{
189 int metasize, headroom;
190
191
192 headroom = xdp->data - xdp->data_hard_start;
193 metasize = xdp->data - xdp->data_meta;
194 metasize = metasize > 0 ? metasize : 0;
195 if (unlikely((headroom - metasize) < sizeof(*xdp_frame)))
196 return -ENOSPC;
197
198
199 if (unlikely(xdp->data_end > xdp_data_hard_end(xdp))) {
200 XDP_WARN("Driver BUG: missing reserved tailroom");
201 return -ENOSPC;
202 }
203
204 xdp_frame->data = xdp->data;
205 xdp_frame->len = xdp->data_end - xdp->data;
206 xdp_frame->headroom = headroom - sizeof(*xdp_frame);
207 xdp_frame->metasize = metasize;
208 xdp_frame->frame_sz = xdp->frame_sz;
209
210 return 0;
211}
212
213
214static inline
215struct xdp_frame *xdp_convert_buff_to_frame(struct xdp_buff *xdp)
216{
217 struct xdp_frame *xdp_frame;
218
219 if (xdp->rxq->mem.type == MEM_TYPE_XSK_BUFF_POOL)
220 return xdp_convert_zc_to_xdp_frame(xdp);
221
222
223 xdp_frame = xdp->data_hard_start;
224 if (unlikely(xdp_update_frame_from_buff(xdp, xdp_frame) < 0))
225 return NULL;
226
227
228 xdp_frame->mem = xdp->rxq->mem;
229
230 return xdp_frame;
231}
232
233void xdp_return_frame(struct xdp_frame *xdpf);
234void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
235void xdp_return_buff(struct xdp_buff *xdp);
236void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq);
237void xdp_return_frame_bulk(struct xdp_frame *xdpf,
238 struct xdp_frame_bulk *bq);
239
240
241
242
243
244
245void __xdp_release_frame(void *data, struct xdp_mem_info *mem);
246static inline void xdp_release_frame(struct xdp_frame *xdpf)
247{
248 struct xdp_mem_info *mem = &xdpf->mem;
249
250
251 if (mem->type == MEM_TYPE_PAGE_POOL)
252 __xdp_release_frame(xdpf->data, mem);
253}
254
255int xdp_rxq_info_reg(struct xdp_rxq_info *xdp_rxq,
256 struct net_device *dev, u32 queue_index, unsigned int napi_id);
257void xdp_rxq_info_unreg(struct xdp_rxq_info *xdp_rxq);
258void xdp_rxq_info_unused(struct xdp_rxq_info *xdp_rxq);
259bool xdp_rxq_info_is_reg(struct xdp_rxq_info *xdp_rxq);
260int xdp_rxq_info_reg_mem_model(struct xdp_rxq_info *xdp_rxq,
261 enum xdp_mem_type type, void *allocator);
262void xdp_rxq_info_unreg_mem_model(struct xdp_rxq_info *xdp_rxq);
263
264
265
266
267static __always_inline void
268xdp_set_data_meta_invalid(struct xdp_buff *xdp)
269{
270 xdp->data_meta = xdp->data + 1;
271}
272
273static __always_inline bool
274xdp_data_meta_unsupported(const struct xdp_buff *xdp)
275{
276 return unlikely(xdp->data_meta > xdp->data);
277}
278
279static inline bool xdp_metalen_invalid(unsigned long metalen)
280{
281 return (metalen & (sizeof(__u32) - 1)) || (metalen > 32);
282}
283
284struct xdp_attachment_info {
285 struct bpf_prog *prog;
286 u32 flags;
287};
288
289struct netdev_bpf;
290void xdp_attachment_setup(struct xdp_attachment_info *info,
291 struct netdev_bpf *bpf);
292
293#define DEV_MAP_BULK_SIZE XDP_BULK_QUEUE_SIZE
294
295#endif
296