gmac get mac form eeprom

hc

2024-05-10 37f49e37ab4cb5d0bc4c60eb5c6d4dd57db767bb

 kernel/tools/lib/bpf/bpf.h
..
..
@@ -1,4 +1,4 @@
1
-/* SPDX-License-Identifier: LGPL-2.1 */
1
+/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
2
2
 
3
3
 /*
4
4
  * common eBPF ELF operations.
..
..
@@ -20,13 +20,19 @@
20
20
  * You should have received a copy of the GNU Lesser General Public
21
21
  * License along with this program; if not,  see <http://www.gnu.org/licenses>
22
22
  */
23
-#ifndef __BPF_BPF_H
24
-#define __BPF_BPF_H
23
+#ifndef __LIBBPF_BPF_H
24
+#define __LIBBPF_BPF_H
25
25
 
26
26
 #include <linux/bpf.h>
27
27
 #include <stdbool.h>
28
28
 #include <stddef.h>
29
29
 #include <stdint.h>
30
+
31
+#include "libbpf_common.h"
32
+
33
+#ifdef __cplusplus
34
+extern "C" {
35
+#endif
30
36
 
31
37
 struct bpf_create_map_attr {
32
38
 	const char *name;
..
..
@@ -40,24 +46,30 @@
40
46
 	__u32 btf_key_type_id;
41
47
 	__u32 btf_value_type_id;
42
48
 	__u32 map_ifindex;
43
-	__u32 inner_map_fd;
49
+	union {
50
+		__u32 inner_map_fd;
51
+		__u32 btf_vmlinux_value_type_id;
52
+	};
44
53
 };
45
54
 
46
-int bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr);
47
-int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
48
-			int key_size, int value_size, int max_entries,
49
-			__u32 map_flags, int node);
50
-int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
51
-			int key_size, int value_size, int max_entries,
52
-			__u32 map_flags);
53
-int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
54
-		   int max_entries, __u32 map_flags);
55
-int bpf_create_map_in_map_node(enum bpf_map_type map_type, const char *name,
56
-			       int key_size, int inner_map_fd, int max_entries,
57
-			       __u32 map_flags, int node);
58
-int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name,
59
-			  int key_size, int inner_map_fd, int max_entries,
60
-			  __u32 map_flags);
55
+LIBBPF_API int
56
+bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr);
57
+LIBBPF_API int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
58
+				   int key_size, int value_size,
59
+				   int max_entries, __u32 map_flags, int node);
60
+LIBBPF_API int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
61
+				   int key_size, int value_size,
62
+				   int max_entries, __u32 map_flags);
63
+LIBBPF_API int bpf_create_map(enum bpf_map_type map_type, int key_size,
64
+			      int value_size, int max_entries, __u32 map_flags);
65
+LIBBPF_API int bpf_create_map_in_map_node(enum bpf_map_type map_type,
66
+					  const char *name, int key_size,
67
+					  int inner_map_fd, int max_entries,
68
+					  __u32 map_flags, int node);
69
+LIBBPF_API int bpf_create_map_in_map(enum bpf_map_type map_type,
70
+				     const char *name, int key_size,
71
+				     int inner_map_fd, int max_entries,
72
+				     __u32 map_flags);
61
73
 
62
74
 struct bpf_load_program_attr {
63
75
 	enum bpf_prog_type prog_type;
..
..
@@ -66,50 +78,215 @@
66
78
 	const struct bpf_insn *insns;
67
79
 	size_t insns_cnt;
68
80
 	const char *license;
69
-	__u32 kern_version;
70
-	__u32 prog_ifindex;
81
+	union {
82
+		__u32 kern_version;
83
+		__u32 attach_prog_fd;
84
+	};
85
+	union {
86
+		__u32 prog_ifindex;
87
+		__u32 attach_btf_id;
88
+	};
89
+	__u32 prog_btf_fd;
90
+	__u32 func_info_rec_size;
91
+	const void *func_info;
92
+	__u32 func_info_cnt;
93
+	__u32 line_info_rec_size;
94
+	const void *line_info;
95
+	__u32 line_info_cnt;
96
+	__u32 log_level;
97
+	__u32 prog_flags;
71
98
 };
72
99
 
100
+/* Flags to direct loading requirements */
101
+#define MAPS_RELAX_COMPAT	0x01
102
+
73
103
 /* Recommend log buffer size */
74
-#define BPF_LOG_BUF_SIZE (256 * 1024)
75
-int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,
76
-			   char *log_buf, size_t log_buf_sz);
77
-int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
78
-		     size_t insns_cnt, const char *license,
79
-		     __u32 kern_version, char *log_buf,
80
-		     size_t log_buf_sz);
81
-int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
82
-		       size_t insns_cnt, __u32 prog_flags,
83
-		       const char *license, __u32 kern_version,
84
-		       char *log_buf, size_t log_buf_sz, int log_level);
104
+#define BPF_LOG_BUF_SIZE (UINT32_MAX >> 8) /* verifier maximum in kernels <= 5.1 */
105
+LIBBPF_API int
106
+bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,
107
+		       char *log_buf, size_t log_buf_sz);
108
+LIBBPF_API int bpf_load_program(enum bpf_prog_type type,
109
+				const struct bpf_insn *insns, size_t insns_cnt,
110
+				const char *license, __u32 kern_version,
111
+				char *log_buf, size_t log_buf_sz);
112
+LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,
113
+				  const struct bpf_insn *insns,
114
+				  size_t insns_cnt, __u32 prog_flags,
115
+				  const char *license, __u32 kern_version,
116
+				  char *log_buf, size_t log_buf_sz,
117
+				  int log_level);
85
118
 
86
-int bpf_map_update_elem(int fd, const void *key, const void *value,
87
-			__u64 flags);
119
+LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value,
120
+				   __u64 flags);
88
121
 
89
-int bpf_map_lookup_elem(int fd, const void *key, void *value);
90
-int bpf_map_delete_elem(int fd, const void *key);
91
-int bpf_map_get_next_key(int fd, const void *key, void *next_key);
92
-int bpf_obj_pin(int fd, const char *pathname);
93
-int bpf_obj_get(const char *pathname);
94
-int bpf_prog_attach(int prog_fd, int attachable_fd, enum bpf_attach_type type,
95
-		    unsigned int flags);
96
-int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
97
-int bpf_prog_detach2(int prog_fd, int attachable_fd, enum bpf_attach_type type);
98
-int bpf_prog_test_run(int prog_fd, int repeat, void *data, __u32 size,
99
-		      void *data_out, __u32 *size_out, __u32 *retval,
100
-		      __u32 *duration);
101
-int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id);
102
-int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);
103
-int bpf_prog_get_fd_by_id(__u32 id);
104
-int bpf_map_get_fd_by_id(__u32 id);
105
-int bpf_btf_get_fd_by_id(__u32 id);
106
-int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len);
107
-int bpf_prog_query(int target_fd, enum bpf_attach_type type, __u32 query_flags,
108
-		   __u32 *attach_flags, __u32 *prog_ids, __u32 *prog_cnt);
109
-int bpf_raw_tracepoint_open(const char *name, int prog_fd);
110
-int bpf_load_btf(void *btf, __u32 btf_size, char *log_buf, __u32 log_buf_size,
111
-		 bool do_log);
112
-int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf, __u32 *buf_len,
113
-		      __u32 *prog_id, __u32 *fd_type, __u64 *probe_offset,
114
-		      __u64 *probe_addr);
122
+LIBBPF_API int bpf_map_lookup_elem(int fd, const void *key, void *value);
123
+LIBBPF_API int bpf_map_lookup_elem_flags(int fd, const void *key, void *value,
124
+					 __u64 flags);
125
+LIBBPF_API int bpf_map_lookup_and_delete_elem(int fd, const void *key,
126
+					      void *value);
127
+LIBBPF_API int bpf_map_delete_elem(int fd, const void *key);
128
+LIBBPF_API int bpf_map_get_next_key(int fd, const void *key, void *next_key);
129
+LIBBPF_API int bpf_map_freeze(int fd);
130
+
131
+struct bpf_map_batch_opts {
132
+	size_t sz; /* size of this struct for forward/backward compatibility */
133
+	__u64 elem_flags;
134
+	__u64 flags;
135
+};
136
+#define bpf_map_batch_opts__last_field flags
137
+
138
+LIBBPF_API int bpf_map_delete_batch(int fd, void *keys,
139
+				    __u32 *count,
140
+				    const struct bpf_map_batch_opts *opts);
141
+LIBBPF_API int bpf_map_lookup_batch(int fd, void *in_batch, void *out_batch,
142
+				    void *keys, void *values, __u32 *count,
143
+				    const struct bpf_map_batch_opts *opts);
144
+LIBBPF_API int bpf_map_lookup_and_delete_batch(int fd, void *in_batch,
145
+					void *out_batch, void *keys,
146
+					void *values, __u32 *count,
147
+					const struct bpf_map_batch_opts *opts);
148
+LIBBPF_API int bpf_map_update_batch(int fd, void *keys, void *values,
149
+				    __u32 *count,
150
+				    const struct bpf_map_batch_opts *opts);
151
+
152
+LIBBPF_API int bpf_obj_pin(int fd, const char *pathname);
153
+LIBBPF_API int bpf_obj_get(const char *pathname);
154
+
155
+struct bpf_prog_attach_opts {
156
+	size_t sz; /* size of this struct for forward/backward compatibility */
157
+	unsigned int flags;
158
+	int replace_prog_fd;
159
+};
160
+#define bpf_prog_attach_opts__last_field replace_prog_fd
161
+
162
+LIBBPF_API int bpf_prog_attach(int prog_fd, int attachable_fd,
163
+			       enum bpf_attach_type type, unsigned int flags);
164
+LIBBPF_API int bpf_prog_attach_xattr(int prog_fd, int attachable_fd,
165
+				     enum bpf_attach_type type,
166
+				     const struct bpf_prog_attach_opts *opts);
167
+LIBBPF_API int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
168
+LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,
169
+				enum bpf_attach_type type);
170
+
171
+union bpf_iter_link_info; /* defined in up-to-date linux/bpf.h */
172
+struct bpf_link_create_opts {
173
+	size_t sz; /* size of this struct for forward/backward compatibility */
174
+	__u32 flags;
175
+	union bpf_iter_link_info *iter_info;
176
+	__u32 iter_info_len;
177
+	__u32 target_btf_id;
178
+};
179
+#define bpf_link_create_opts__last_field target_btf_id
180
+
181
+LIBBPF_API int bpf_link_create(int prog_fd, int target_fd,
182
+			       enum bpf_attach_type attach_type,
183
+			       const struct bpf_link_create_opts *opts);
184
+
185
+LIBBPF_API int bpf_link_detach(int link_fd);
186
+
187
+struct bpf_link_update_opts {
188
+	size_t sz; /* size of this struct for forward/backward compatibility */
189
+	__u32 flags;	   /* extra flags */
190
+	__u32 old_prog_fd; /* expected old program FD */
191
+};
192
+#define bpf_link_update_opts__last_field old_prog_fd
193
+
194
+LIBBPF_API int bpf_link_update(int link_fd, int new_prog_fd,
195
+			       const struct bpf_link_update_opts *opts);
196
+
197
+LIBBPF_API int bpf_iter_create(int link_fd);
198
+
199
+struct bpf_prog_test_run_attr {
200
+	int prog_fd;
201
+	int repeat;
202
+	const void *data_in;
203
+	__u32 data_size_in;
204
+	void *data_out;      /* optional */
205
+	__u32 data_size_out; /* in: max length of data_out
206
+			      * out: length of data_out */
207
+	__u32 retval;        /* out: return code of the BPF program */
208
+	__u32 duration;      /* out: average per repetition in ns */
209
+	const void *ctx_in; /* optional */
210
+	__u32 ctx_size_in;
211
+	void *ctx_out;      /* optional */
212
+	__u32 ctx_size_out; /* in: max length of ctx_out
213
+			     * out: length of cxt_out */
214
+};
215
+
216
+LIBBPF_API int bpf_prog_test_run_xattr(struct bpf_prog_test_run_attr *test_attr);
217
+
218
+/*
219
+ * bpf_prog_test_run does not check that data_out is large enough. Consider
220
+ * using bpf_prog_test_run_xattr instead.
221
+ */
222
+LIBBPF_API int bpf_prog_test_run(int prog_fd, int repeat, void *data,
223
+				 __u32 size, void *data_out, __u32 *size_out,
224
+				 __u32 *retval, __u32 *duration);
225
+LIBBPF_API int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id);
226
+LIBBPF_API int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);
227
+LIBBPF_API int bpf_btf_get_next_id(__u32 start_id, __u32 *next_id);
228
+LIBBPF_API int bpf_link_get_next_id(__u32 start_id, __u32 *next_id);
229
+LIBBPF_API int bpf_prog_get_fd_by_id(__u32 id);
230
+LIBBPF_API int bpf_map_get_fd_by_id(__u32 id);
231
+LIBBPF_API int bpf_btf_get_fd_by_id(__u32 id);
232
+LIBBPF_API int bpf_link_get_fd_by_id(__u32 id);
233
+LIBBPF_API int bpf_obj_get_info_by_fd(int bpf_fd, void *info, __u32 *info_len);
234
+LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,
235
+			      __u32 query_flags, __u32 *attach_flags,
236
+			      __u32 *prog_ids, __u32 *prog_cnt);
237
+LIBBPF_API int bpf_raw_tracepoint_open(const char *name, int prog_fd);
238
+LIBBPF_API int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf,
239
+			    __u32 log_buf_size, bool do_log);
240
+LIBBPF_API int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf,
241
+				 __u32 *buf_len, __u32 *prog_id, __u32 *fd_type,
242
+				 __u64 *probe_offset, __u64 *probe_addr);
243
+
244
+#ifdef __cplusplus
245
+/* forward-declaring enums in C++ isn't compatible with pure C enums, so
246
+ * instead define bpf_enable_stats() as accepting int as an input
247
+ */
248
+LIBBPF_API int bpf_enable_stats(int type);
249
+#else
250
+enum bpf_stats_type; /* defined in up-to-date linux/bpf.h */
251
+LIBBPF_API int bpf_enable_stats(enum bpf_stats_type type);
115
252
 #endif
253
+
254
+struct bpf_prog_bind_opts {
255
+	size_t sz; /* size of this struct for forward/backward compatibility */
256
+	__u32 flags;
257
+};
258
+#define bpf_prog_bind_opts__last_field flags
259
+
260
+LIBBPF_API int bpf_prog_bind_map(int prog_fd, int map_fd,
261
+				 const struct bpf_prog_bind_opts *opts);
262
+
263
+struct bpf_test_run_opts {
264
+	size_t sz; /* size of this struct for forward/backward compatibility */
265
+	const void *data_in; /* optional */
266
+	void *data_out;      /* optional */
267
+	__u32 data_size_in;
268
+	__u32 data_size_out; /* in: max length of data_out
269
+			      * out: length of data_out
270
+			      */
271
+	const void *ctx_in; /* optional */
272
+	void *ctx_out;      /* optional */
273
+	__u32 ctx_size_in;
274
+	__u32 ctx_size_out; /* in: max length of ctx_out
275
+			     * out: length of cxt_out
276
+			     */
277
+	__u32 retval;        /* out: return code of the BPF program */
278
+	int repeat;
279
+	__u32 duration;      /* out: average per repetition in ns */
280
+	__u32 flags;
281
+	__u32 cpu;
282
+};
283
+#define bpf_test_run_opts__last_field cpu
284
+
285
+LIBBPF_API int bpf_prog_test_run_opts(int prog_fd,
286
+				      struct bpf_test_run_opts *opts);
287
+
288
+#ifdef __cplusplus
289
+} /* extern "C" */
290
+#endif
291
+
292
+#endif /* __LIBBPF_BPF_H */