Loading...
1/* SPDX-License-Identifier: GPL-2.0-only */
2/* include/net/xdp.h
3 *
4 * Copyright (c) 2017 Jesper Dangaard Brouer, Red Hat Inc.
5 */
6#ifndef __LINUX_NET_XDP_H__
7#define __LINUX_NET_XDP_H__
8
9/**
10 * DOC: XDP RX-queue information
11 *
12 * The XDP RX-queue info (xdp_rxq_info) is associated with the driver
13 * level RX-ring queues. It is information that is specific to how
14 * the driver have configured a given RX-ring queue.
15 *
16 * Each xdp_buff frame received in the driver carry a (pointer)
17 * reference to this xdp_rxq_info structure. This provides the XDP
18 * data-path read-access to RX-info for both kernel and bpf-side
19 * (limited subset).
20 *
21 * For now, direct access is only safe while running in NAPI/softirq
22 * context. Contents is read-mostly and must not be updated during
23 * driver NAPI/softirq poll.
24 *
25 * The driver usage API is a register and unregister API.
26 *
27 * The struct is not directly tied to the XDP prog. A new XDP prog
28 * can be attached as long as it doesn't change the underlying
29 * RX-ring. If the RX-ring does change significantly, the NIC driver
30 * naturally need to stop the RX-ring before purging and reallocating
31 * memory. In that process the driver MUST call unregistor (which
32 * also apply for driver shutdown and unload). The register API is
33 * also mandatory during RX-ring setup.
34 */
35
36enum xdp_mem_type {
37 MEM_TYPE_PAGE_SHARED = 0, /* Split-page refcnt based model */
38 MEM_TYPE_PAGE_ORDER0, /* Orig XDP full page model */
39 MEM_TYPE_PAGE_POOL,
40 MEM_TYPE_ZERO_COPY,
41 MEM_TYPE_MAX,
42};
43
44/* XDP flags for ndo_xdp_xmit */
45#define XDP_XMIT_FLUSH (1U << 0) /* doorbell signal consumer */
46#define XDP_XMIT_FLAGS_MASK XDP_XMIT_FLUSH
47
48struct xdp_mem_info {
49 u32 type; /* enum xdp_mem_type, but known size type */
50 u32 id;
51};
52
53struct page_pool;
54
55struct zero_copy_allocator {
56 void (*free)(struct zero_copy_allocator *zca, unsigned long handle);
57};
58
59struct xdp_rxq_info {
60 struct net_device *dev;
61 u32 queue_index;
62 u32 reg_state;
63 struct xdp_mem_info mem;
64} ____cacheline_aligned; /* perf critical, avoid false-sharing */
65
66struct xdp_buff {
67 void *data;
68 void *data_end;
69 void *data_meta;
70 void *data_hard_start;
71 unsigned long handle;
72 struct xdp_rxq_info *rxq;
73};
74
75struct xdp_frame {
76 void *data;
77 u16 len;
78 u16 headroom;
79 u16 metasize;
80 /* Lifetime of xdp_rxq_info is limited to NAPI/enqueue time,
81 * while mem info is valid on remote CPU.
82 */
83 struct xdp_mem_info mem;
84 struct net_device *dev_rx; /* used by cpumap */
85};
86
87/* Clear kernel pointers in xdp_frame */
88static inline void xdp_scrub_frame(struct xdp_frame *frame)
89{
90 frame->data = NULL;
91 frame->dev_rx = NULL;
92}
93
94struct xdp_frame *xdp_convert_zc_to_xdp_frame(struct xdp_buff *xdp);
95
96/* Convert xdp_buff to xdp_frame */
97static inline
98struct xdp_frame *convert_to_xdp_frame(struct xdp_buff *xdp)
99{
100 struct xdp_frame *xdp_frame;
101 int metasize;
102 int headroom;
103
104 if (xdp->rxq->mem.type == MEM_TYPE_ZERO_COPY)
105 return xdp_convert_zc_to_xdp_frame(xdp);
106
107 /* Assure headroom is available for storing info */
108 headroom = xdp->data - xdp->data_hard_start;
109 metasize = xdp->data - xdp->data_meta;
110 metasize = metasize > 0 ? metasize : 0;
111 if (unlikely((headroom - metasize) < sizeof(*xdp_frame)))
112 return NULL;
113
114 /* Store info in top of packet */
115 xdp_frame = xdp->data_hard_start;
116
117 xdp_frame->data = xdp->data;
118 xdp_frame->len = xdp->data_end - xdp->data;
119 xdp_frame->headroom = headroom - sizeof(*xdp_frame);
120 xdp_frame->metasize = metasize;
121
122 /* rxq only valid until napi_schedule ends, convert to xdp_mem_info */
123 xdp_frame->mem = xdp->rxq->mem;
124
125 return xdp_frame;
126}
127
128void xdp_return_frame(struct xdp_frame *xdpf);
129void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
130void xdp_return_buff(struct xdp_buff *xdp);
131
132/* When sending xdp_frame into the network stack, then there is no
133 * return point callback, which is needed to release e.g. DMA-mapping
134 * resources with page_pool. Thus, have explicit function to release
135 * frame resources.
136 */
137void __xdp_release_frame(void *data, struct xdp_mem_info *mem);
138static inline void xdp_release_frame(struct xdp_frame *xdpf)
139{
140 struct xdp_mem_info *mem = &xdpf->mem;
141
142 /* Curr only page_pool needs this */
143 if (mem->type == MEM_TYPE_PAGE_POOL)
144 __xdp_release_frame(xdpf->data, mem);
145}
146
147int xdp_rxq_info_reg(struct xdp_rxq_info *xdp_rxq,
148 struct net_device *dev, u32 queue_index);
149void xdp_rxq_info_unreg(struct xdp_rxq_info *xdp_rxq);
150void xdp_rxq_info_unused(struct xdp_rxq_info *xdp_rxq);
151bool xdp_rxq_info_is_reg(struct xdp_rxq_info *xdp_rxq);
152int xdp_rxq_info_reg_mem_model(struct xdp_rxq_info *xdp_rxq,
153 enum xdp_mem_type type, void *allocator);
154void xdp_rxq_info_unreg_mem_model(struct xdp_rxq_info *xdp_rxq);
155
156/* Drivers not supporting XDP metadata can use this helper, which
157 * rejects any room expansion for metadata as a result.
158 */
159static __always_inline void
160xdp_set_data_meta_invalid(struct xdp_buff *xdp)
161{
162 xdp->data_meta = xdp->data + 1;
163}
164
165static __always_inline bool
166xdp_data_meta_unsupported(const struct xdp_buff *xdp)
167{
168 return unlikely(xdp->data_meta > xdp->data);
169}
170
171struct xdp_attachment_info {
172 struct bpf_prog *prog;
173 u32 flags;
174};
175
176struct netdev_bpf;
177int xdp_attachment_query(struct xdp_attachment_info *info,
178 struct netdev_bpf *bpf);
179bool xdp_attachment_flags_ok(struct xdp_attachment_info *info,
180 struct netdev_bpf *bpf);
181void xdp_attachment_setup(struct xdp_attachment_info *info,
182 struct netdev_bpf *bpf);
183
184#endif /* __LINUX_NET_XDP_H__ */
1/* SPDX-License-Identifier: GPL-2.0-only */
2/* include/net/xdp.h
3 *
4 * Copyright (c) 2017 Jesper Dangaard Brouer, Red Hat Inc.
5 */
6#ifndef __LINUX_NET_XDP_H__
7#define __LINUX_NET_XDP_H__
8
9#include <linux/skbuff.h> /* skb_shared_info */
10
11/**
12 * DOC: XDP RX-queue information
13 *
14 * The XDP RX-queue info (xdp_rxq_info) is associated with the driver
15 * level RX-ring queues. It is information that is specific to how
16 * the driver have configured a given RX-ring queue.
17 *
18 * Each xdp_buff frame received in the driver carry a (pointer)
19 * reference to this xdp_rxq_info structure. This provides the XDP
20 * data-path read-access to RX-info for both kernel and bpf-side
21 * (limited subset).
22 *
23 * For now, direct access is only safe while running in NAPI/softirq
24 * context. Contents is read-mostly and must not be updated during
25 * driver NAPI/softirq poll.
26 *
27 * The driver usage API is a register and unregister API.
28 *
29 * The struct is not directly tied to the XDP prog. A new XDP prog
30 * can be attached as long as it doesn't change the underlying
31 * RX-ring. If the RX-ring does change significantly, the NIC driver
32 * naturally need to stop the RX-ring before purging and reallocating
33 * memory. In that process the driver MUST call unregistor (which
34 * also apply for driver shutdown and unload). The register API is
35 * also mandatory during RX-ring setup.
36 */
37
38enum xdp_mem_type {
39 MEM_TYPE_PAGE_SHARED = 0, /* Split-page refcnt based model */
40 MEM_TYPE_PAGE_ORDER0, /* Orig XDP full page model */
41 MEM_TYPE_PAGE_POOL,
42 MEM_TYPE_XSK_BUFF_POOL,
43 MEM_TYPE_MAX,
44};
45
46/* XDP flags for ndo_xdp_xmit */
47#define XDP_XMIT_FLUSH (1U << 0) /* doorbell signal consumer */
48#define XDP_XMIT_FLAGS_MASK XDP_XMIT_FLUSH
49
50struct xdp_mem_info {
51 u32 type; /* enum xdp_mem_type, but known size 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} ____cacheline_aligned; /* perf critical, avoid false-sharing */
63
64struct xdp_txq_info {
65 struct net_device *dev;
66};
67
68struct xdp_buff {
69 void *data;
70 void *data_end;
71 void *data_meta;
72 void *data_hard_start;
73 struct xdp_rxq_info *rxq;
74 struct xdp_txq_info *txq;
75 u32 frame_sz; /* frame size to deduce data_hard_end/reserved tailroom*/
76};
77
78/* Reserve memory area at end-of data area.
79 *
80 * This macro reserves tailroom in the XDP buffer by limiting the
81 * XDP/BPF data access to data_hard_end. Notice same area (and size)
82 * is used for XDP_PASS, when constructing the SKB via build_skb().
83 */
84#define xdp_data_hard_end(xdp) \
85 ((xdp)->data_hard_start + (xdp)->frame_sz - \
86 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
87
88static inline struct skb_shared_info *
89xdp_get_shared_info_from_buff(struct xdp_buff *xdp)
90{
91 return (struct skb_shared_info *)xdp_data_hard_end(xdp);
92}
93
94struct xdp_frame {
95 void *data;
96 u16 len;
97 u16 headroom;
98 u32 metasize:8;
99 u32 frame_sz:24;
100 /* Lifetime of xdp_rxq_info is limited to NAPI/enqueue time,
101 * while mem info is valid on remote CPU.
102 */
103 struct xdp_mem_info mem;
104 struct net_device *dev_rx; /* used by cpumap */
105};
106
107
108static inline struct skb_shared_info *
109xdp_get_shared_info_from_frame(struct xdp_frame *frame)
110{
111 void *data_hard_start = frame->data - frame->headroom - sizeof(*frame);
112
113 return (struct skb_shared_info *)(data_hard_start + frame->frame_sz -
114 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)));
115}
116
117struct xdp_cpumap_stats {
118 unsigned int redirect;
119 unsigned int pass;
120 unsigned int drop;
121};
122
123/* Clear kernel pointers in xdp_frame */
124static inline void xdp_scrub_frame(struct xdp_frame *frame)
125{
126 frame->data = NULL;
127 frame->dev_rx = NULL;
128}
129
130/* Avoids inlining WARN macro in fast-path */
131void xdp_warn(const char *msg, const char *func, const int line);
132#define XDP_WARN(msg) xdp_warn(msg, __func__, __LINE__)
133
134struct xdp_frame *xdp_convert_zc_to_xdp_frame(struct xdp_buff *xdp);
135
136static inline
137void xdp_convert_frame_to_buff(struct xdp_frame *frame, struct xdp_buff *xdp)
138{
139 xdp->data_hard_start = frame->data - frame->headroom - sizeof(*frame);
140 xdp->data = frame->data;
141 xdp->data_end = frame->data + frame->len;
142 xdp->data_meta = frame->data - frame->metasize;
143 xdp->frame_sz = frame->frame_sz;
144}
145
146static inline
147int xdp_update_frame_from_buff(struct xdp_buff *xdp,
148 struct xdp_frame *xdp_frame)
149{
150 int metasize, headroom;
151
152 /* Assure headroom is available for storing info */
153 headroom = xdp->data - xdp->data_hard_start;
154 metasize = xdp->data - xdp->data_meta;
155 metasize = metasize > 0 ? metasize : 0;
156 if (unlikely((headroom - metasize) < sizeof(*xdp_frame)))
157 return -ENOSPC;
158
159 /* Catch if driver didn't reserve tailroom for skb_shared_info */
160 if (unlikely(xdp->data_end > xdp_data_hard_end(xdp))) {
161 XDP_WARN("Driver BUG: missing reserved tailroom");
162 return -ENOSPC;
163 }
164
165 xdp_frame->data = xdp->data;
166 xdp_frame->len = xdp->data_end - xdp->data;
167 xdp_frame->headroom = headroom - sizeof(*xdp_frame);
168 xdp_frame->metasize = metasize;
169 xdp_frame->frame_sz = xdp->frame_sz;
170
171 return 0;
172}
173
174/* Convert xdp_buff to xdp_frame */
175static inline
176struct xdp_frame *xdp_convert_buff_to_frame(struct xdp_buff *xdp)
177{
178 struct xdp_frame *xdp_frame;
179
180 if (xdp->rxq->mem.type == MEM_TYPE_XSK_BUFF_POOL)
181 return xdp_convert_zc_to_xdp_frame(xdp);
182
183 /* Store info in top of packet */
184 xdp_frame = xdp->data_hard_start;
185 if (unlikely(xdp_update_frame_from_buff(xdp, xdp_frame) < 0))
186 return NULL;
187
188 /* rxq only valid until napi_schedule ends, convert to xdp_mem_info */
189 xdp_frame->mem = xdp->rxq->mem;
190
191 return xdp_frame;
192}
193
194void xdp_return_frame(struct xdp_frame *xdpf);
195void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
196void xdp_return_buff(struct xdp_buff *xdp);
197
198/* When sending xdp_frame into the network stack, then there is no
199 * return point callback, which is needed to release e.g. DMA-mapping
200 * resources with page_pool. Thus, have explicit function to release
201 * frame resources.
202 */
203void __xdp_release_frame(void *data, struct xdp_mem_info *mem);
204static inline void xdp_release_frame(struct xdp_frame *xdpf)
205{
206 struct xdp_mem_info *mem = &xdpf->mem;
207
208 /* Curr only page_pool needs this */
209 if (mem->type == MEM_TYPE_PAGE_POOL)
210 __xdp_release_frame(xdpf->data, mem);
211}
212
213int xdp_rxq_info_reg(struct xdp_rxq_info *xdp_rxq,
214 struct net_device *dev, u32 queue_index);
215void xdp_rxq_info_unreg(struct xdp_rxq_info *xdp_rxq);
216void xdp_rxq_info_unused(struct xdp_rxq_info *xdp_rxq);
217bool xdp_rxq_info_is_reg(struct xdp_rxq_info *xdp_rxq);
218int xdp_rxq_info_reg_mem_model(struct xdp_rxq_info *xdp_rxq,
219 enum xdp_mem_type type, void *allocator);
220void xdp_rxq_info_unreg_mem_model(struct xdp_rxq_info *xdp_rxq);
221
222/* Drivers not supporting XDP metadata can use this helper, which
223 * rejects any room expansion for metadata as a result.
224 */
225static __always_inline void
226xdp_set_data_meta_invalid(struct xdp_buff *xdp)
227{
228 xdp->data_meta = xdp->data + 1;
229}
230
231static __always_inline bool
232xdp_data_meta_unsupported(const struct xdp_buff *xdp)
233{
234 return unlikely(xdp->data_meta > xdp->data);
235}
236
237struct xdp_attachment_info {
238 struct bpf_prog *prog;
239 u32 flags;
240};
241
242struct netdev_bpf;
243bool xdp_attachment_flags_ok(struct xdp_attachment_info *info,
244 struct netdev_bpf *bpf);
245void xdp_attachment_setup(struct xdp_attachment_info *info,
246 struct netdev_bpf *bpf);
247
248#define DEV_MAP_BULK_SIZE 16
249
250#endif /* __LINUX_NET_XDP_H__ */