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
38 enum 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
50 struct xdp_mem_info {
51 u32 type; /* enum xdp_mem_type, but known size type */
52 u32 id;
53 };
54
55 struct page_pool;
56
57 struct 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
64 struct xdp_txq_info {
65 struct net_device *dev;
66 };
67
68 struct 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
88 static inline struct skb_shared_info *
xdp_get_shared_info_from_buff(struct xdp_buff * xdp)89 xdp_get_shared_info_from_buff(struct xdp_buff *xdp)
90 {
91 return (struct skb_shared_info *)xdp_data_hard_end(xdp);
92 }
93
94 struct 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
108 static inline struct skb_shared_info *
xdp_get_shared_info_from_frame(struct xdp_frame * frame)109 xdp_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
117 struct xdp_cpumap_stats {
118 unsigned int redirect;
119 unsigned int pass;
120 unsigned int drop;
121 };
122
123 /* Clear kernel pointers in xdp_frame */
xdp_scrub_frame(struct xdp_frame * frame)124 static 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 */
131 void xdp_warn(const char *msg, const char *func, const int line);
132 #define XDP_WARN(msg) xdp_warn(msg, __func__, __LINE__)
133
134 struct xdp_frame *xdp_convert_zc_to_xdp_frame(struct xdp_buff *xdp);
135
136 static inline
xdp_convert_frame_to_buff(struct xdp_frame * frame,struct xdp_buff * xdp)137 void 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
146 static inline
xdp_update_frame_from_buff(struct xdp_buff * xdp,struct xdp_frame * xdp_frame)147 int 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 */
175 static inline
xdp_convert_buff_to_frame(struct xdp_buff * xdp)176 struct 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
194 void xdp_return_frame(struct xdp_frame *xdpf);
195 void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
196 void 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 */
203 void __xdp_release_frame(void *data, struct xdp_mem_info *mem);
xdp_release_frame(struct xdp_frame * xdpf)204 static 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
213 int xdp_rxq_info_reg(struct xdp_rxq_info *xdp_rxq,
214 struct net_device *dev, u32 queue_index);
215 void xdp_rxq_info_unreg(struct xdp_rxq_info *xdp_rxq);
216 void xdp_rxq_info_unused(struct xdp_rxq_info *xdp_rxq);
217 bool xdp_rxq_info_is_reg(struct xdp_rxq_info *xdp_rxq);
218 int xdp_rxq_info_reg_mem_model(struct xdp_rxq_info *xdp_rxq,
219 enum xdp_mem_type type, void *allocator);
220 void 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 */
225 static __always_inline void
xdp_set_data_meta_invalid(struct xdp_buff * xdp)226 xdp_set_data_meta_invalid(struct xdp_buff *xdp)
227 {
228 xdp->data_meta = xdp->data + 1;
229 }
230
231 static __always_inline bool
xdp_data_meta_unsupported(const struct xdp_buff * xdp)232 xdp_data_meta_unsupported(const struct xdp_buff *xdp)
233 {
234 return unlikely(xdp->data_meta > xdp->data);
235 }
236
237 struct xdp_attachment_info {
238 struct bpf_prog *prog;
239 u32 flags;
240 };
241
242 struct netdev_bpf;
243 void xdp_attachment_setup(struct xdp_attachment_info *info,
244 struct netdev_bpf *bpf);
245
246 #define DEV_MAP_BULK_SIZE 16
247
248 #endif /* __LINUX_NET_XDP_H__ */
249