disable pwm7

hc

2024-05-10 23fa18eaa71266feff7ba8d83022d9e1cc83c65a

 kernel/include/net/xdp.h
..
..
@@ -1,10 +1,12 @@
1
+/* SPDX-License-Identifier: GPL-2.0-only */
1
2
 /* include/net/xdp.h
2
3
  *
3
4
  * Copyright (c) 2017 Jesper Dangaard Brouer, Red Hat Inc.
4
- * Released under terms in GPL version 2.  See COPYING.
5
5
  */
6
6
 #ifndef __LINUX_NET_XDP_H__
7
7
 #define __LINUX_NET_XDP_H__
8
+
9
+#include <linux/skbuff.h> /* skb_shared_info */
8
10
 
9
11
 /**
10
12
  * DOC: XDP RX-queue information
..
..
@@ -37,7 +39,7 @@
37
39
 	MEM_TYPE_PAGE_SHARED = 0, /* Split-page refcnt based model */
38
40
 	MEM_TYPE_PAGE_ORDER0,     /* Orig XDP full page model */
39
41
 	MEM_TYPE_PAGE_POOL,
40
-	MEM_TYPE_ZERO_COPY,
42
+	MEM_TYPE_XSK_BUFF_POOL,
41
43
 	MEM_TYPE_MAX,
42
44
 };
43
45
 
..
..
@@ -52,10 +54,6 @@
52
54
 
53
55
 struct page_pool;
54
56
 
55
-struct zero_copy_allocator {
56
-	void (*free)(struct zero_copy_allocator *zca, unsigned long handle);
57
-};
58
-
59
57
 struct xdp_rxq_info {
60
58
 	struct net_device *dev;
61
59
 	u32 queue_index;
..
..
@@ -63,25 +61,63 @@
63
61
 	struct xdp_mem_info mem;
64
62
 } ____cacheline_aligned; /* perf critical, avoid false-sharing */
65
63
 
64
+struct xdp_txq_info {
65
+	struct net_device *dev;
66
+};
67
+
66
68
 struct xdp_buff {
67
69
 	void *data;
68
70
 	void *data_end;
69
71
 	void *data_meta;
70
72
 	void *data_hard_start;
71
-	unsigned long handle;
72
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*/
73
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 *
89
+xdp_get_shared_info_from_buff(struct xdp_buff *xdp)
90
+{
91
+	return (struct skb_shared_info *)xdp_data_hard_end(xdp);
92
+}
74
93
 
75
94
 struct xdp_frame {
76
95
 	void *data;
77
96
 	u16 len;
78
97
 	u16 headroom;
79
-	u16 metasize;
98
+	u32 metasize:8;
99
+	u32 frame_sz:24;
80
100
 	/* Lifetime of xdp_rxq_info is limited to NAPI/enqueue time,
81
101
 	 * while mem info is valid on remote CPU.
82
102
 	 */
83
103
 	struct xdp_mem_info mem;
84
104
 	struct net_device *dev_rx; /* used by cpumap */
105
+};
106
+
107
+
108
+static inline struct skb_shared_info *
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;
85
121
 };
86
122
 
87
123
 /* Clear kernel pointers in xdp_frame */
..
..
@@ -91,32 +127,63 @@
91
127
 	frame->dev_rx = NULL;
92
128
 }
93
129
 
94
-/* Convert xdp_buff to xdp_frame */
95
-static inline
96
-struct xdp_frame *convert_to_xdp_frame(struct xdp_buff *xdp)
97
-{
98
-	struct xdp_frame *xdp_frame;
99
-	int metasize;
100
-	int headroom;
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__)
101
133
 
102
-	/* TODO: implement clone, copy, use "native" MEM_TYPE */
103
-	if (xdp->rxq->mem.type == MEM_TYPE_ZERO_COPY)
104
-		return NULL;
134
+struct xdp_frame *xdp_convert_zc_to_xdp_frame(struct xdp_buff *xdp);
135
+
136
+static inline
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
147
+int xdp_update_frame_from_buff(struct xdp_buff *xdp,
148
+			       struct xdp_frame *xdp_frame)
149
+{
150
+	int metasize, headroom;
105
151
 
106
152
 	/* Assure headroom is available for storing info */
107
153
 	headroom = xdp->data - xdp->data_hard_start;
108
154
 	metasize = xdp->data - xdp->data_meta;
109
155
 	metasize = metasize > 0 ? metasize : 0;
110
156
 	if (unlikely((headroom - metasize) < sizeof(*xdp_frame)))
111
-		return NULL;
157
+		return -ENOSPC;
112
158
 
113
-	/* Store info in top of packet */
114
-	xdp_frame = xdp->data_hard_start;
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
+	}
115
164
 
116
165
 	xdp_frame->data = xdp->data;
117
166
 	xdp_frame->len  = xdp->data_end - xdp->data;
118
167
 	xdp_frame->headroom = headroom - sizeof(*xdp_frame);
119
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
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;
120
187
 
121
188
 	/* rxq only valid until napi_schedule ends, convert to xdp_mem_info */
122
189
 	xdp_frame->mem = xdp->rxq->mem;
..
..
@@ -128,6 +195,21 @@
128
195
 void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
129
196
 void xdp_return_buff(struct xdp_buff *xdp);
130
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);
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
+
131
213
 int xdp_rxq_info_reg(struct xdp_rxq_info *xdp_rxq,
132
214
 		     struct net_device *dev, u32 queue_index);
133
215
 void xdp_rxq_info_unreg(struct xdp_rxq_info *xdp_rxq);
..
..
@@ -135,6 +217,7 @@
135
217
 bool xdp_rxq_info_is_reg(struct xdp_rxq_info *xdp_rxq);
136
218
 int xdp_rxq_info_reg_mem_model(struct xdp_rxq_info *xdp_rxq,
137
219
 			       enum xdp_mem_type type, void *allocator);
220
+void xdp_rxq_info_unreg_mem_model(struct xdp_rxq_info *xdp_rxq);
138
221
 
139
222
 /* Drivers not supporting XDP metadata can use this helper, which
140
223
  * rejects any room expansion for metadata as a result.
..
..
@@ -157,11 +240,9 @@
157
240
 };
158
241
 
159
242
 struct netdev_bpf;
160
-int xdp_attachment_query(struct xdp_attachment_info *info,
161
-			 struct netdev_bpf *bpf);
162
-bool xdp_attachment_flags_ok(struct xdp_attachment_info *info,
163
-			     struct netdev_bpf *bpf);
164
243
 void xdp_attachment_setup(struct xdp_attachment_info *info,
165
244
 			  struct netdev_bpf *bpf);
166
245
 
246
+#define DEV_MAP_BULK_SIZE 16
247
+
167
248
 #endif /* __LINUX_NET_XDP_H__ */