1 /* Generated by ./gen_bpf_attr_check.sh from bpf_attr.h; do not edit. */
2 #include "defs.h"
3 #ifdef HAVE_LINUX_BPF_H
4 # include <linux/bpf.h>
5 # include "bpf_attr.h"
6 # include "static_assert.h"
7
8
9 # ifdef HAVE_UNION_BPF_ATTR_MAP_TYPE
10 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_type) == sizeof_field(union bpf_attr, map_type),
11 "BPF_MAP_CREATE_struct.map_type size mismatch");
12 static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_type) == offsetof(union bpf_attr, map_type),
13 "BPF_MAP_CREATE_struct.map_type offset mismatch");
14 # endif /* HAVE_UNION_BPF_ATTR_MAP_TYPE */
15
16 # ifdef HAVE_UNION_BPF_ATTR_KEY_SIZE
17 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, key_size) == sizeof_field(union bpf_attr, key_size),
18 "BPF_MAP_CREATE_struct.key_size size mismatch");
19 static_assert(offsetof(struct BPF_MAP_CREATE_struct, key_size) == offsetof(union bpf_attr, key_size),
20 "BPF_MAP_CREATE_struct.key_size offset mismatch");
21 # endif /* HAVE_UNION_BPF_ATTR_KEY_SIZE */
22
23 # ifdef HAVE_UNION_BPF_ATTR_VALUE_SIZE
24 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, value_size) == sizeof_field(union bpf_attr, value_size),
25 "BPF_MAP_CREATE_struct.value_size size mismatch");
26 static_assert(offsetof(struct BPF_MAP_CREATE_struct, value_size) == offsetof(union bpf_attr, value_size),
27 "BPF_MAP_CREATE_struct.value_size offset mismatch");
28 # endif /* HAVE_UNION_BPF_ATTR_VALUE_SIZE */
29
30 # ifdef HAVE_UNION_BPF_ATTR_MAX_ENTRIES
31 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, max_entries) == sizeof_field(union bpf_attr, max_entries),
32 "BPF_MAP_CREATE_struct.max_entries size mismatch");
33 static_assert(offsetof(struct BPF_MAP_CREATE_struct, max_entries) == offsetof(union bpf_attr, max_entries),
34 "BPF_MAP_CREATE_struct.max_entries offset mismatch");
35 # endif /* HAVE_UNION_BPF_ATTR_MAX_ENTRIES */
36
37 # ifdef HAVE_UNION_BPF_ATTR_MAP_FLAGS
38 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_flags) == sizeof_field(union bpf_attr, map_flags),
39 "BPF_MAP_CREATE_struct.map_flags size mismatch");
40 static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_flags) == offsetof(union bpf_attr, map_flags),
41 "BPF_MAP_CREATE_struct.map_flags offset mismatch");
42 # endif /* HAVE_UNION_BPF_ATTR_MAP_FLAGS */
43
44 # ifdef HAVE_UNION_BPF_ATTR_INNER_MAP_FD
45 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, inner_map_fd) == sizeof_field(union bpf_attr, inner_map_fd),
46 "BPF_MAP_CREATE_struct.inner_map_fd size mismatch");
47 static_assert(offsetof(struct BPF_MAP_CREATE_struct, inner_map_fd) == offsetof(union bpf_attr, inner_map_fd),
48 "BPF_MAP_CREATE_struct.inner_map_fd offset mismatch");
49 # endif /* HAVE_UNION_BPF_ATTR_INNER_MAP_FD */
50
51 # ifdef HAVE_UNION_BPF_ATTR_NUMA_NODE
52 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, numa_node) == sizeof_field(union bpf_attr, numa_node),
53 "BPF_MAP_CREATE_struct.numa_node size mismatch");
54 static_assert(offsetof(struct BPF_MAP_CREATE_struct, numa_node) == offsetof(union bpf_attr, numa_node),
55 "BPF_MAP_CREATE_struct.numa_node offset mismatch");
56 # endif /* HAVE_UNION_BPF_ATTR_NUMA_NODE */
57
58 # ifdef HAVE_UNION_BPF_ATTR_MAP_NAME
59 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_name) == sizeof_field(union bpf_attr, map_name),
60 "BPF_MAP_CREATE_struct.map_name size mismatch");
61 static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_name) == offsetof(union bpf_attr, map_name),
62 "BPF_MAP_CREATE_struct.map_name offset mismatch");
63 # endif /* HAVE_UNION_BPF_ATTR_MAP_NAME */
64
65 # ifdef HAVE_UNION_BPF_ATTR_MAP_IFINDEX
66 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_ifindex) == sizeof_field(union bpf_attr, map_ifindex),
67 "BPF_MAP_CREATE_struct.map_ifindex size mismatch");
68 static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_ifindex) == offsetof(union bpf_attr, map_ifindex),
69 "BPF_MAP_CREATE_struct.map_ifindex offset mismatch");
70 # endif /* HAVE_UNION_BPF_ATTR_MAP_IFINDEX */
71
72 # ifdef HAVE_UNION_BPF_ATTR_BTF_FD
73 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_fd) == sizeof_field(union bpf_attr, btf_fd),
74 "BPF_MAP_CREATE_struct.btf_fd size mismatch");
75 static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_fd) == offsetof(union bpf_attr, btf_fd),
76 "BPF_MAP_CREATE_struct.btf_fd offset mismatch");
77 # endif /* HAVE_UNION_BPF_ATTR_BTF_FD */
78
79 # ifdef HAVE_UNION_BPF_ATTR_BTF_KEY_TYPE_ID
80 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_key_type_id) == sizeof_field(union bpf_attr, btf_key_type_id),
81 "BPF_MAP_CREATE_struct.btf_key_type_id size mismatch");
82 static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_key_type_id) == offsetof(union bpf_attr, btf_key_type_id),
83 "BPF_MAP_CREATE_struct.btf_key_type_id offset mismatch");
84 # endif /* HAVE_UNION_BPF_ATTR_BTF_KEY_TYPE_ID */
85
86 # ifdef HAVE_UNION_BPF_ATTR_BTF_VALUE_TYPE_ID
87 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_value_type_id) == sizeof_field(union bpf_attr, btf_value_type_id),
88 "BPF_MAP_CREATE_struct.btf_value_type_id size mismatch");
89 static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_value_type_id) == offsetof(union bpf_attr, btf_value_type_id),
90 "BPF_MAP_CREATE_struct.btf_value_type_id offset mismatch");
91 # endif /* HAVE_UNION_BPF_ATTR_BTF_VALUE_TYPE_ID */
92
93 # ifdef HAVE_UNION_BPF_ATTR_BTF_VMLINUX_VALUE_TYPE_ID
94 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, btf_vmlinux_value_type_id) == sizeof_field(union bpf_attr, btf_vmlinux_value_type_id),
95 "BPF_MAP_CREATE_struct.btf_vmlinux_value_type_id size mismatch");
96 static_assert(offsetof(struct BPF_MAP_CREATE_struct, btf_vmlinux_value_type_id) == offsetof(union bpf_attr, btf_vmlinux_value_type_id),
97 "BPF_MAP_CREATE_struct.btf_vmlinux_value_type_id offset mismatch");
98 # endif /* HAVE_UNION_BPF_ATTR_BTF_VMLINUX_VALUE_TYPE_ID */
99
100 # ifdef HAVE_UNION_BPF_ATTR_MAP_EXTRA
101 static_assert(sizeof_field(struct BPF_MAP_CREATE_struct, map_extra) == sizeof_field(union bpf_attr, map_extra),
102 "BPF_MAP_CREATE_struct.map_extra size mismatch");
103 static_assert(offsetof(struct BPF_MAP_CREATE_struct, map_extra) == offsetof(union bpf_attr, map_extra),
104 "BPF_MAP_CREATE_struct.map_extra offset mismatch");
105 # endif /* HAVE_UNION_BPF_ATTR_MAP_EXTRA */
106
107 static_assert(BPF_MAP_CREATE_struct_size == expected_BPF_MAP_CREATE_struct_size,
108 "BPF_MAP_CREATE_struct_size mismatch");
109
110 # ifdef HAVE_UNION_BPF_ATTR_MAP_FD
111 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
112 "BPF_MAP_LOOKUP_ELEM_struct.map_fd size mismatch");
113 static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd),
114 "BPF_MAP_LOOKUP_ELEM_struct.map_fd offset mismatch");
115 # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */
116
117 # ifdef HAVE_UNION_BPF_ATTR_KEY
118 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, key) == sizeof_field(union bpf_attr, key),
119 "BPF_MAP_LOOKUP_ELEM_struct.key size mismatch");
120 static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, key) == offsetof(union bpf_attr, key),
121 "BPF_MAP_LOOKUP_ELEM_struct.key offset mismatch");
122 # endif /* HAVE_UNION_BPF_ATTR_KEY */
123
124 # ifdef HAVE_UNION_BPF_ATTR_VALUE
125 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, value) == sizeof_field(union bpf_attr, value),
126 "BPF_MAP_LOOKUP_ELEM_struct.value size mismatch");
127 static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, value) == offsetof(union bpf_attr, value),
128 "BPF_MAP_LOOKUP_ELEM_struct.value offset mismatch");
129 # endif /* HAVE_UNION_BPF_ATTR_VALUE */
130
131 # ifdef HAVE_UNION_BPF_ATTR_FLAGS
132 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_ELEM_struct, flags) == sizeof_field(union bpf_attr, flags),
133 "BPF_MAP_LOOKUP_ELEM_struct.flags size mismatch");
134 static_assert(offsetof(struct BPF_MAP_LOOKUP_ELEM_struct, flags) == offsetof(union bpf_attr, flags),
135 "BPF_MAP_LOOKUP_ELEM_struct.flags offset mismatch");
136 # endif /* HAVE_UNION_BPF_ATTR_FLAGS */
137
138 static_assert(BPF_MAP_LOOKUP_ELEM_struct_size == expected_BPF_MAP_LOOKUP_ELEM_struct_size,
139 "BPF_MAP_LOOKUP_ELEM_struct_size mismatch");
140
141 # ifdef HAVE_UNION_BPF_ATTR_MAP_FD
142 static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
143 "BPF_MAP_UPDATE_ELEM_struct.map_fd size mismatch");
144 static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd),
145 "BPF_MAP_UPDATE_ELEM_struct.map_fd offset mismatch");
146 # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */
147
148 # ifdef HAVE_UNION_BPF_ATTR_KEY
149 static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, key) == sizeof_field(union bpf_attr, key),
150 "BPF_MAP_UPDATE_ELEM_struct.key size mismatch");
151 static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, key) == offsetof(union bpf_attr, key),
152 "BPF_MAP_UPDATE_ELEM_struct.key offset mismatch");
153 # endif /* HAVE_UNION_BPF_ATTR_KEY */
154
155 # ifdef HAVE_UNION_BPF_ATTR_VALUE
156 static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, value) == sizeof_field(union bpf_attr, value),
157 "BPF_MAP_UPDATE_ELEM_struct.value size mismatch");
158 static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, value) == offsetof(union bpf_attr, value),
159 "BPF_MAP_UPDATE_ELEM_struct.value offset mismatch");
160 # endif /* HAVE_UNION_BPF_ATTR_VALUE */
161
162 # ifdef HAVE_UNION_BPF_ATTR_FLAGS
163 static_assert(sizeof_field(struct BPF_MAP_UPDATE_ELEM_struct, flags) == sizeof_field(union bpf_attr, flags),
164 "BPF_MAP_UPDATE_ELEM_struct.flags size mismatch");
165 static_assert(offsetof(struct BPF_MAP_UPDATE_ELEM_struct, flags) == offsetof(union bpf_attr, flags),
166 "BPF_MAP_UPDATE_ELEM_struct.flags offset mismatch");
167 # endif /* HAVE_UNION_BPF_ATTR_FLAGS */
168
169 static_assert(BPF_MAP_UPDATE_ELEM_struct_size == expected_BPF_MAP_UPDATE_ELEM_struct_size,
170 "BPF_MAP_UPDATE_ELEM_struct_size mismatch");
171
172 # ifdef HAVE_UNION_BPF_ATTR_MAP_FD
173 static_assert(sizeof_field(struct BPF_MAP_DELETE_ELEM_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
174 "BPF_MAP_DELETE_ELEM_struct.map_fd size mismatch");
175 static_assert(offsetof(struct BPF_MAP_DELETE_ELEM_struct, map_fd) == offsetof(union bpf_attr, map_fd),
176 "BPF_MAP_DELETE_ELEM_struct.map_fd offset mismatch");
177 # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */
178
179 # ifdef HAVE_UNION_BPF_ATTR_KEY
180 static_assert(sizeof_field(struct BPF_MAP_DELETE_ELEM_struct, key) == sizeof_field(union bpf_attr, key),
181 "BPF_MAP_DELETE_ELEM_struct.key size mismatch");
182 static_assert(offsetof(struct BPF_MAP_DELETE_ELEM_struct, key) == offsetof(union bpf_attr, key),
183 "BPF_MAP_DELETE_ELEM_struct.key offset mismatch");
184 # endif /* HAVE_UNION_BPF_ATTR_KEY */
185
186 static_assert(BPF_MAP_DELETE_ELEM_struct_size == expected_BPF_MAP_DELETE_ELEM_struct_size,
187 "BPF_MAP_DELETE_ELEM_struct_size mismatch");
188
189 # ifdef HAVE_UNION_BPF_ATTR_MAP_FD
190 static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
191 "BPF_MAP_GET_NEXT_KEY_struct.map_fd size mismatch");
192 static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, map_fd) == offsetof(union bpf_attr, map_fd),
193 "BPF_MAP_GET_NEXT_KEY_struct.map_fd offset mismatch");
194 # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */
195
196 # ifdef HAVE_UNION_BPF_ATTR_KEY
197 static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, key) == sizeof_field(union bpf_attr, key),
198 "BPF_MAP_GET_NEXT_KEY_struct.key size mismatch");
199 static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, key) == offsetof(union bpf_attr, key),
200 "BPF_MAP_GET_NEXT_KEY_struct.key offset mismatch");
201 # endif /* HAVE_UNION_BPF_ATTR_KEY */
202
203 # ifdef HAVE_UNION_BPF_ATTR_NEXT_KEY
204 static_assert(sizeof_field(struct BPF_MAP_GET_NEXT_KEY_struct, next_key) == sizeof_field(union bpf_attr, next_key),
205 "BPF_MAP_GET_NEXT_KEY_struct.next_key size mismatch");
206 static_assert(offsetof(struct BPF_MAP_GET_NEXT_KEY_struct, next_key) == offsetof(union bpf_attr, next_key),
207 "BPF_MAP_GET_NEXT_KEY_struct.next_key offset mismatch");
208 # endif /* HAVE_UNION_BPF_ATTR_NEXT_KEY */
209
210 static_assert(BPF_MAP_GET_NEXT_KEY_struct_size == expected_BPF_MAP_GET_NEXT_KEY_struct_size,
211 "BPF_MAP_GET_NEXT_KEY_struct_size mismatch");
212
213 # ifdef HAVE_UNION_BPF_ATTR_MAP_FD
214 static_assert(sizeof_field(struct BPF_MAP_FREEZE_struct, map_fd) == sizeof_field(union bpf_attr, map_fd),
215 "BPF_MAP_FREEZE_struct.map_fd size mismatch");
216 static_assert(offsetof(struct BPF_MAP_FREEZE_struct, map_fd) == offsetof(union bpf_attr, map_fd),
217 "BPF_MAP_FREEZE_struct.map_fd offset mismatch");
218 # endif /* HAVE_UNION_BPF_ATTR_MAP_FD */
219
220 static_assert(BPF_MAP_FREEZE_struct_size == expected_BPF_MAP_FREEZE_struct_size,
221 "BPF_MAP_FREEZE_struct_size mismatch");
222
223 # ifdef HAVE_UNION_BPF_ATTR_PROG_TYPE
224 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_type) == sizeof_field(union bpf_attr, prog_type),
225 "BPF_PROG_LOAD_struct.prog_type size mismatch");
226 static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_type) == offsetof(union bpf_attr, prog_type),
227 "BPF_PROG_LOAD_struct.prog_type offset mismatch");
228 # endif /* HAVE_UNION_BPF_ATTR_PROG_TYPE */
229
230 # ifdef HAVE_UNION_BPF_ATTR_INSN_CNT
231 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, insn_cnt) == sizeof_field(union bpf_attr, insn_cnt),
232 "BPF_PROG_LOAD_struct.insn_cnt size mismatch");
233 static_assert(offsetof(struct BPF_PROG_LOAD_struct, insn_cnt) == offsetof(union bpf_attr, insn_cnt),
234 "BPF_PROG_LOAD_struct.insn_cnt offset mismatch");
235 # endif /* HAVE_UNION_BPF_ATTR_INSN_CNT */
236
237 # ifdef HAVE_UNION_BPF_ATTR_INSNS
238 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, insns) == sizeof_field(union bpf_attr, insns),
239 "BPF_PROG_LOAD_struct.insns size mismatch");
240 static_assert(offsetof(struct BPF_PROG_LOAD_struct, insns) == offsetof(union bpf_attr, insns),
241 "BPF_PROG_LOAD_struct.insns offset mismatch");
242 # endif /* HAVE_UNION_BPF_ATTR_INSNS */
243
244 # ifdef HAVE_UNION_BPF_ATTR_LICENSE
245 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, license) == sizeof_field(union bpf_attr, license),
246 "BPF_PROG_LOAD_struct.license size mismatch");
247 static_assert(offsetof(struct BPF_PROG_LOAD_struct, license) == offsetof(union bpf_attr, license),
248 "BPF_PROG_LOAD_struct.license offset mismatch");
249 # endif /* HAVE_UNION_BPF_ATTR_LICENSE */
250
251 # ifdef HAVE_UNION_BPF_ATTR_LOG_LEVEL
252 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_level) == sizeof_field(union bpf_attr, log_level),
253 "BPF_PROG_LOAD_struct.log_level size mismatch");
254 static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_level) == offsetof(union bpf_attr, log_level),
255 "BPF_PROG_LOAD_struct.log_level offset mismatch");
256 # endif /* HAVE_UNION_BPF_ATTR_LOG_LEVEL */
257
258 # ifdef HAVE_UNION_BPF_ATTR_LOG_SIZE
259 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_size) == sizeof_field(union bpf_attr, log_size),
260 "BPF_PROG_LOAD_struct.log_size size mismatch");
261 static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_size) == offsetof(union bpf_attr, log_size),
262 "BPF_PROG_LOAD_struct.log_size offset mismatch");
263 # endif /* HAVE_UNION_BPF_ATTR_LOG_SIZE */
264
265 # ifdef HAVE_UNION_BPF_ATTR_LOG_BUF
266 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, log_buf) == sizeof_field(union bpf_attr, log_buf),
267 "BPF_PROG_LOAD_struct.log_buf size mismatch");
268 static_assert(offsetof(struct BPF_PROG_LOAD_struct, log_buf) == offsetof(union bpf_attr, log_buf),
269 "BPF_PROG_LOAD_struct.log_buf offset mismatch");
270 # endif /* HAVE_UNION_BPF_ATTR_LOG_BUF */
271
272 # ifdef HAVE_UNION_BPF_ATTR_KERN_VERSION
273 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, kern_version) == sizeof_field(union bpf_attr, kern_version),
274 "BPF_PROG_LOAD_struct.kern_version size mismatch");
275 static_assert(offsetof(struct BPF_PROG_LOAD_struct, kern_version) == offsetof(union bpf_attr, kern_version),
276 "BPF_PROG_LOAD_struct.kern_version offset mismatch");
277 # endif /* HAVE_UNION_BPF_ATTR_KERN_VERSION */
278
279 # ifdef HAVE_UNION_BPF_ATTR_PROG_FLAGS
280 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_flags) == sizeof_field(union bpf_attr, prog_flags),
281 "BPF_PROG_LOAD_struct.prog_flags size mismatch");
282 static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_flags) == offsetof(union bpf_attr, prog_flags),
283 "BPF_PROG_LOAD_struct.prog_flags offset mismatch");
284 # endif /* HAVE_UNION_BPF_ATTR_PROG_FLAGS */
285
286 # ifdef HAVE_UNION_BPF_ATTR_PROG_NAME
287 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_name) == sizeof_field(union bpf_attr, prog_name),
288 "BPF_PROG_LOAD_struct.prog_name size mismatch");
289 static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_name) == offsetof(union bpf_attr, prog_name),
290 "BPF_PROG_LOAD_struct.prog_name offset mismatch");
291 # endif /* HAVE_UNION_BPF_ATTR_PROG_NAME */
292
293 # ifdef HAVE_UNION_BPF_ATTR_PROG_IFINDEX
294 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_ifindex) == sizeof_field(union bpf_attr, prog_ifindex),
295 "BPF_PROG_LOAD_struct.prog_ifindex size mismatch");
296 static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_ifindex) == offsetof(union bpf_attr, prog_ifindex),
297 "BPF_PROG_LOAD_struct.prog_ifindex offset mismatch");
298 # endif /* HAVE_UNION_BPF_ATTR_PROG_IFINDEX */
299
300 # ifdef HAVE_UNION_BPF_ATTR_EXPECTED_ATTACH_TYPE
301 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, expected_attach_type) == sizeof_field(union bpf_attr, expected_attach_type),
302 "BPF_PROG_LOAD_struct.expected_attach_type size mismatch");
303 static_assert(offsetof(struct BPF_PROG_LOAD_struct, expected_attach_type) == offsetof(union bpf_attr, expected_attach_type),
304 "BPF_PROG_LOAD_struct.expected_attach_type offset mismatch");
305 # endif /* HAVE_UNION_BPF_ATTR_EXPECTED_ATTACH_TYPE */
306
307 # ifdef HAVE_UNION_BPF_ATTR_PROG_BTF_FD
308 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, prog_btf_fd) == sizeof_field(union bpf_attr, prog_btf_fd),
309 "BPF_PROG_LOAD_struct.prog_btf_fd size mismatch");
310 static_assert(offsetof(struct BPF_PROG_LOAD_struct, prog_btf_fd) == offsetof(union bpf_attr, prog_btf_fd),
311 "BPF_PROG_LOAD_struct.prog_btf_fd offset mismatch");
312 # endif /* HAVE_UNION_BPF_ATTR_PROG_BTF_FD */
313
314 # ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO_REC_SIZE
315 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info_rec_size) == sizeof_field(union bpf_attr, func_info_rec_size),
316 "BPF_PROG_LOAD_struct.func_info_rec_size size mismatch");
317 static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info_rec_size) == offsetof(union bpf_attr, func_info_rec_size),
318 "BPF_PROG_LOAD_struct.func_info_rec_size offset mismatch");
319 # endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO_REC_SIZE */
320
321 # ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO
322 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info) == sizeof_field(union bpf_attr, func_info),
323 "BPF_PROG_LOAD_struct.func_info size mismatch");
324 static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info) == offsetof(union bpf_attr, func_info),
325 "BPF_PROG_LOAD_struct.func_info offset mismatch");
326 # endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO */
327
328 # ifdef HAVE_UNION_BPF_ATTR_FUNC_INFO_CNT
329 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, func_info_cnt) == sizeof_field(union bpf_attr, func_info_cnt),
330 "BPF_PROG_LOAD_struct.func_info_cnt size mismatch");
331 static_assert(offsetof(struct BPF_PROG_LOAD_struct, func_info_cnt) == offsetof(union bpf_attr, func_info_cnt),
332 "BPF_PROG_LOAD_struct.func_info_cnt offset mismatch");
333 # endif /* HAVE_UNION_BPF_ATTR_FUNC_INFO_CNT */
334
335 # ifdef HAVE_UNION_BPF_ATTR_LINE_INFO_REC_SIZE
336 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info_rec_size) == sizeof_field(union bpf_attr, line_info_rec_size),
337 "BPF_PROG_LOAD_struct.line_info_rec_size size mismatch");
338 static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info_rec_size) == offsetof(union bpf_attr, line_info_rec_size),
339 "BPF_PROG_LOAD_struct.line_info_rec_size offset mismatch");
340 # endif /* HAVE_UNION_BPF_ATTR_LINE_INFO_REC_SIZE */
341
342 # ifdef HAVE_UNION_BPF_ATTR_LINE_INFO
343 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info) == sizeof_field(union bpf_attr, line_info),
344 "BPF_PROG_LOAD_struct.line_info size mismatch");
345 static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info) == offsetof(union bpf_attr, line_info),
346 "BPF_PROG_LOAD_struct.line_info offset mismatch");
347 # endif /* HAVE_UNION_BPF_ATTR_LINE_INFO */
348
349 # ifdef HAVE_UNION_BPF_ATTR_LINE_INFO_CNT
350 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, line_info_cnt) == sizeof_field(union bpf_attr, line_info_cnt),
351 "BPF_PROG_LOAD_struct.line_info_cnt size mismatch");
352 static_assert(offsetof(struct BPF_PROG_LOAD_struct, line_info_cnt) == offsetof(union bpf_attr, line_info_cnt),
353 "BPF_PROG_LOAD_struct.line_info_cnt offset mismatch");
354 # endif /* HAVE_UNION_BPF_ATTR_LINE_INFO_CNT */
355
356 # ifdef HAVE_UNION_BPF_ATTR_ATTACH_BTF_ID
357 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, attach_btf_id) == sizeof_field(union bpf_attr, attach_btf_id),
358 "BPF_PROG_LOAD_struct.attach_btf_id size mismatch");
359 static_assert(offsetof(struct BPF_PROG_LOAD_struct, attach_btf_id) == offsetof(union bpf_attr, attach_btf_id),
360 "BPF_PROG_LOAD_struct.attach_btf_id offset mismatch");
361 # endif /* HAVE_UNION_BPF_ATTR_ATTACH_BTF_ID */
362
363 # ifdef HAVE_UNION_BPF_ATTR_ATTACH_PROG_FD
364 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, attach_prog_fd) == sizeof_field(union bpf_attr, attach_prog_fd),
365 "BPF_PROG_LOAD_struct.attach_prog_fd size mismatch");
366 static_assert(offsetof(struct BPF_PROG_LOAD_struct, attach_prog_fd) == offsetof(union bpf_attr, attach_prog_fd),
367 "BPF_PROG_LOAD_struct.attach_prog_fd offset mismatch");
368 # endif /* HAVE_UNION_BPF_ATTR_ATTACH_PROG_FD */
369
370 # ifdef HAVE_UNION_BPF_ATTR_PAD
371 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, pad) == sizeof_field(union bpf_attr, pad),
372 "BPF_PROG_LOAD_struct.pad size mismatch");
373 static_assert(offsetof(struct BPF_PROG_LOAD_struct, pad) == offsetof(union bpf_attr, pad),
374 "BPF_PROG_LOAD_struct.pad offset mismatch");
375 # endif /* HAVE_UNION_BPF_ATTR_PAD */
376
377 # ifdef HAVE_UNION_BPF_ATTR_FD_ARRAY
378 static_assert(sizeof_field(struct BPF_PROG_LOAD_struct, fd_array) == sizeof_field(union bpf_attr, fd_array),
379 "BPF_PROG_LOAD_struct.fd_array size mismatch");
380 static_assert(offsetof(struct BPF_PROG_LOAD_struct, fd_array) == offsetof(union bpf_attr, fd_array),
381 "BPF_PROG_LOAD_struct.fd_array offset mismatch");
382 # endif /* HAVE_UNION_BPF_ATTR_FD_ARRAY */
383
384 static_assert(BPF_PROG_LOAD_struct_size == expected_BPF_PROG_LOAD_struct_size,
385 "BPF_PROG_LOAD_struct_size mismatch");
386
387 # ifdef HAVE_UNION_BPF_ATTR_PATHNAME
388 static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, pathname) == sizeof_field(union bpf_attr, pathname),
389 "BPF_OBJ_PIN_struct.pathname size mismatch");
390 static_assert(offsetof(struct BPF_OBJ_PIN_struct, pathname) == offsetof(union bpf_attr, pathname),
391 "BPF_OBJ_PIN_struct.pathname offset mismatch");
392 # endif /* HAVE_UNION_BPF_ATTR_PATHNAME */
393
394 # ifdef HAVE_UNION_BPF_ATTR_BPF_FD
395 static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, bpf_fd) == sizeof_field(union bpf_attr, bpf_fd),
396 "BPF_OBJ_PIN_struct.bpf_fd size mismatch");
397 static_assert(offsetof(struct BPF_OBJ_PIN_struct, bpf_fd) == offsetof(union bpf_attr, bpf_fd),
398 "BPF_OBJ_PIN_struct.bpf_fd offset mismatch");
399 # endif /* HAVE_UNION_BPF_ATTR_BPF_FD */
400
401 # ifdef HAVE_UNION_BPF_ATTR_FILE_FLAGS
402 static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, file_flags) == sizeof_field(union bpf_attr, file_flags),
403 "BPF_OBJ_PIN_struct.file_flags size mismatch");
404 static_assert(offsetof(struct BPF_OBJ_PIN_struct, file_flags) == offsetof(union bpf_attr, file_flags),
405 "BPF_OBJ_PIN_struct.file_flags offset mismatch");
406 # endif /* HAVE_UNION_BPF_ATTR_FILE_FLAGS */
407
408 # ifdef HAVE_UNION_BPF_ATTR_PATH_FD
409 static_assert(sizeof_field(struct BPF_OBJ_PIN_struct, path_fd) == sizeof_field(union bpf_attr, path_fd),
410 "BPF_OBJ_PIN_struct.path_fd size mismatch");
411 static_assert(offsetof(struct BPF_OBJ_PIN_struct, path_fd) == offsetof(union bpf_attr, path_fd),
412 "BPF_OBJ_PIN_struct.path_fd offset mismatch");
413 # endif /* HAVE_UNION_BPF_ATTR_PATH_FD */
414
415 static_assert(BPF_OBJ_PIN_struct_size == expected_BPF_OBJ_PIN_struct_size,
416 "BPF_OBJ_PIN_struct_size mismatch");
417
418 # ifdef HAVE_UNION_BPF_ATTR_TARGET_FD
419 static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, target_fd) == sizeof_field(union bpf_attr, target_fd),
420 "BPF_PROG_ATTACH_struct.target_fd size mismatch");
421 static_assert(offsetof(struct BPF_PROG_ATTACH_struct, target_fd) == offsetof(union bpf_attr, target_fd),
422 "BPF_PROG_ATTACH_struct.target_fd offset mismatch");
423 # endif /* HAVE_UNION_BPF_ATTR_TARGET_FD */
424
425 # ifdef HAVE_UNION_BPF_ATTR_ATTACH_BPF_FD
426 static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_bpf_fd) == sizeof_field(union bpf_attr, attach_bpf_fd),
427 "BPF_PROG_ATTACH_struct.attach_bpf_fd size mismatch");
428 static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_bpf_fd) == offsetof(union bpf_attr, attach_bpf_fd),
429 "BPF_PROG_ATTACH_struct.attach_bpf_fd offset mismatch");
430 # endif /* HAVE_UNION_BPF_ATTR_ATTACH_BPF_FD */
431
432 # ifdef HAVE_UNION_BPF_ATTR_ATTACH_TYPE
433 static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_type) == sizeof_field(union bpf_attr, attach_type),
434 "BPF_PROG_ATTACH_struct.attach_type size mismatch");
435 static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_type) == offsetof(union bpf_attr, attach_type),
436 "BPF_PROG_ATTACH_struct.attach_type offset mismatch");
437 # endif /* HAVE_UNION_BPF_ATTR_ATTACH_TYPE */
438
439 # ifdef HAVE_UNION_BPF_ATTR_ATTACH_FLAGS
440 static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, attach_flags) == sizeof_field(union bpf_attr, attach_flags),
441 "BPF_PROG_ATTACH_struct.attach_flags size mismatch");
442 static_assert(offsetof(struct BPF_PROG_ATTACH_struct, attach_flags) == offsetof(union bpf_attr, attach_flags),
443 "BPF_PROG_ATTACH_struct.attach_flags offset mismatch");
444 # endif /* HAVE_UNION_BPF_ATTR_ATTACH_FLAGS */
445
446 # ifdef HAVE_UNION_BPF_ATTR_REPLACE_BPF_FD
447 static_assert(sizeof_field(struct BPF_PROG_ATTACH_struct, replace_bpf_fd) == sizeof_field(union bpf_attr, replace_bpf_fd),
448 "BPF_PROG_ATTACH_struct.replace_bpf_fd size mismatch");
449 static_assert(offsetof(struct BPF_PROG_ATTACH_struct, replace_bpf_fd) == offsetof(union bpf_attr, replace_bpf_fd),
450 "BPF_PROG_ATTACH_struct.replace_bpf_fd offset mismatch");
451 # endif /* HAVE_UNION_BPF_ATTR_REPLACE_BPF_FD */
452
453 static_assert(BPF_PROG_ATTACH_struct_size == expected_BPF_PROG_ATTACH_struct_size,
454 "BPF_PROG_ATTACH_struct_size mismatch");
455
456 # ifdef HAVE_UNION_BPF_ATTR_TARGET_FD
457 static_assert(sizeof_field(struct BPF_PROG_DETACH_struct, target_fd) == sizeof_field(union bpf_attr, target_fd),
458 "BPF_PROG_DETACH_struct.target_fd size mismatch");
459 static_assert(offsetof(struct BPF_PROG_DETACH_struct, target_fd) == offsetof(union bpf_attr, target_fd),
460 "BPF_PROG_DETACH_struct.target_fd offset mismatch");
461 # endif /* HAVE_UNION_BPF_ATTR_TARGET_FD */
462
463 # ifdef HAVE_UNION_BPF_ATTR_DUMMY
464 static_assert(sizeof_field(struct BPF_PROG_DETACH_struct, dummy) == sizeof_field(union bpf_attr, dummy),
465 "BPF_PROG_DETACH_struct.dummy size mismatch");
466 static_assert(offsetof(struct BPF_PROG_DETACH_struct, dummy) == offsetof(union bpf_attr, dummy),
467 "BPF_PROG_DETACH_struct.dummy offset mismatch");
468 # endif /* HAVE_UNION_BPF_ATTR_DUMMY */
469
470 # ifdef HAVE_UNION_BPF_ATTR_ATTACH_TYPE
471 static_assert(sizeof_field(struct BPF_PROG_DETACH_struct, attach_type) == sizeof_field(union bpf_attr, attach_type),
472 "BPF_PROG_DETACH_struct.attach_type size mismatch");
473 static_assert(offsetof(struct BPF_PROG_DETACH_struct, attach_type) == offsetof(union bpf_attr, attach_type),
474 "BPF_PROG_DETACH_struct.attach_type offset mismatch");
475 # endif /* HAVE_UNION_BPF_ATTR_ATTACH_TYPE */
476
477 static_assert(BPF_PROG_DETACH_struct_size == expected_BPF_PROG_DETACH_struct_size,
478 "BPF_PROG_DETACH_struct_size mismatch");
479
480 # ifdef HAVE_UNION_BPF_ATTR_TEST_PROG_FD
481 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, prog_fd) == sizeof_field(union bpf_attr, test.prog_fd),
482 "BPF_PROG_TEST_RUN_struct.prog_fd size mismatch");
483 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, prog_fd) == offsetof(union bpf_attr, test.prog_fd),
484 "BPF_PROG_TEST_RUN_struct.prog_fd offset mismatch");
485 # endif /* HAVE_UNION_BPF_ATTR_TEST_PROG_FD */
486
487 # ifdef HAVE_UNION_BPF_ATTR_TEST_RETVAL
488 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, retval) == sizeof_field(union bpf_attr, test.retval),
489 "BPF_PROG_TEST_RUN_struct.retval size mismatch");
490 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, retval) == offsetof(union bpf_attr, test.retval),
491 "BPF_PROG_TEST_RUN_struct.retval offset mismatch");
492 # endif /* HAVE_UNION_BPF_ATTR_TEST_RETVAL */
493
494 # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_IN
495 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_size_in) == sizeof_field(union bpf_attr, test.data_size_in),
496 "BPF_PROG_TEST_RUN_struct.data_size_in size mismatch");
497 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_size_in) == offsetof(union bpf_attr, test.data_size_in),
498 "BPF_PROG_TEST_RUN_struct.data_size_in offset mismatch");
499 # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_IN */
500
501 # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_OUT
502 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_size_out) == sizeof_field(union bpf_attr, test.data_size_out),
503 "BPF_PROG_TEST_RUN_struct.data_size_out size mismatch");
504 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_size_out) == offsetof(union bpf_attr, test.data_size_out),
505 "BPF_PROG_TEST_RUN_struct.data_size_out offset mismatch");
506 # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_SIZE_OUT */
507
508 # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_IN
509 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_in) == sizeof_field(union bpf_attr, test.data_in),
510 "BPF_PROG_TEST_RUN_struct.data_in size mismatch");
511 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_in) == offsetof(union bpf_attr, test.data_in),
512 "BPF_PROG_TEST_RUN_struct.data_in offset mismatch");
513 # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_IN */
514
515 # ifdef HAVE_UNION_BPF_ATTR_TEST_DATA_OUT
516 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, data_out) == sizeof_field(union bpf_attr, test.data_out),
517 "BPF_PROG_TEST_RUN_struct.data_out size mismatch");
518 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, data_out) == offsetof(union bpf_attr, test.data_out),
519 "BPF_PROG_TEST_RUN_struct.data_out offset mismatch");
520 # endif /* HAVE_UNION_BPF_ATTR_TEST_DATA_OUT */
521
522 # ifdef HAVE_UNION_BPF_ATTR_TEST_REPEAT
523 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, repeat) == sizeof_field(union bpf_attr, test.repeat),
524 "BPF_PROG_TEST_RUN_struct.repeat size mismatch");
525 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, repeat) == offsetof(union bpf_attr, test.repeat),
526 "BPF_PROG_TEST_RUN_struct.repeat offset mismatch");
527 # endif /* HAVE_UNION_BPF_ATTR_TEST_REPEAT */
528
529 # ifdef HAVE_UNION_BPF_ATTR_TEST_DURATION
530 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, duration) == sizeof_field(union bpf_attr, test.duration),
531 "BPF_PROG_TEST_RUN_struct.duration size mismatch");
532 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, duration) == offsetof(union bpf_attr, test.duration),
533 "BPF_PROG_TEST_RUN_struct.duration offset mismatch");
534 # endif /* HAVE_UNION_BPF_ATTR_TEST_DURATION */
535
536 # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_IN
537 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_size_in) == sizeof_field(union bpf_attr, test.ctx_size_in),
538 "BPF_PROG_TEST_RUN_struct.ctx_size_in size mismatch");
539 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_size_in) == offsetof(union bpf_attr, test.ctx_size_in),
540 "BPF_PROG_TEST_RUN_struct.ctx_size_in offset mismatch");
541 # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_IN */
542
543 # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_OUT
544 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_size_out) == sizeof_field(union bpf_attr, test.ctx_size_out),
545 "BPF_PROG_TEST_RUN_struct.ctx_size_out size mismatch");
546 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_size_out) == offsetof(union bpf_attr, test.ctx_size_out),
547 "BPF_PROG_TEST_RUN_struct.ctx_size_out offset mismatch");
548 # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_SIZE_OUT */
549
550 # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_IN
551 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_in) == sizeof_field(union bpf_attr, test.ctx_in),
552 "BPF_PROG_TEST_RUN_struct.ctx_in size mismatch");
553 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_in) == offsetof(union bpf_attr, test.ctx_in),
554 "BPF_PROG_TEST_RUN_struct.ctx_in offset mismatch");
555 # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_IN */
556
557 # ifdef HAVE_UNION_BPF_ATTR_TEST_CTX_OUT
558 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, ctx_out) == sizeof_field(union bpf_attr, test.ctx_out),
559 "BPF_PROG_TEST_RUN_struct.ctx_out size mismatch");
560 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, ctx_out) == offsetof(union bpf_attr, test.ctx_out),
561 "BPF_PROG_TEST_RUN_struct.ctx_out offset mismatch");
562 # endif /* HAVE_UNION_BPF_ATTR_TEST_CTX_OUT */
563
564 # ifdef HAVE_UNION_BPF_ATTR_TEST_FLAGS
565 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, flags) == sizeof_field(union bpf_attr, test.flags),
566 "BPF_PROG_TEST_RUN_struct.flags size mismatch");
567 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, flags) == offsetof(union bpf_attr, test.flags),
568 "BPF_PROG_TEST_RUN_struct.flags offset mismatch");
569 # endif /* HAVE_UNION_BPF_ATTR_TEST_FLAGS */
570
571 # ifdef HAVE_UNION_BPF_ATTR_TEST_CPU
572 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, cpu) == sizeof_field(union bpf_attr, test.cpu),
573 "BPF_PROG_TEST_RUN_struct.cpu size mismatch");
574 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, cpu) == offsetof(union bpf_attr, test.cpu),
575 "BPF_PROG_TEST_RUN_struct.cpu offset mismatch");
576 # endif /* HAVE_UNION_BPF_ATTR_TEST_CPU */
577
578 # ifdef HAVE_UNION_BPF_ATTR_TEST_BATCH_SIZE
579 static_assert(sizeof_field(struct BPF_PROG_TEST_RUN_struct, batch_size) == sizeof_field(union bpf_attr, test.batch_size),
580 "BPF_PROG_TEST_RUN_struct.batch_size size mismatch");
581 static_assert(offsetof(struct BPF_PROG_TEST_RUN_struct, batch_size) == offsetof(union bpf_attr, test.batch_size),
582 "BPF_PROG_TEST_RUN_struct.batch_size offset mismatch");
583 # endif /* HAVE_UNION_BPF_ATTR_TEST_BATCH_SIZE */
584
585 static_assert(BPF_PROG_TEST_RUN_struct_size == expected_BPF_PROG_TEST_RUN_struct_size,
586 "BPF_PROG_TEST_RUN_struct_size mismatch");
587
588 # ifdef HAVE_UNION_BPF_ATTR_START_ID
589 static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, start_id) == sizeof_field(union bpf_attr, start_id),
590 "BPF_PROG_GET_NEXT_ID_struct.start_id size mismatch");
591 static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, start_id) == offsetof(union bpf_attr, start_id),
592 "BPF_PROG_GET_NEXT_ID_struct.start_id offset mismatch");
593 # endif /* HAVE_UNION_BPF_ATTR_START_ID */
594
595 # ifdef HAVE_UNION_BPF_ATTR_NEXT_ID
596 static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id),
597 "BPF_PROG_GET_NEXT_ID_struct.next_id size mismatch");
598 static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, next_id) == offsetof(union bpf_attr, next_id),
599 "BPF_PROG_GET_NEXT_ID_struct.next_id offset mismatch");
600 # endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */
601
602 # ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS
603 static_assert(sizeof_field(struct BPF_PROG_GET_NEXT_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags),
604 "BPF_PROG_GET_NEXT_ID_struct.open_flags size mismatch");
605 static_assert(offsetof(struct BPF_PROG_GET_NEXT_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags),
606 "BPF_PROG_GET_NEXT_ID_struct.open_flags offset mismatch");
607 # endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */
608
609 static_assert(BPF_PROG_GET_NEXT_ID_struct_size == expected_BPF_PROG_GET_NEXT_ID_struct_size,
610 "BPF_PROG_GET_NEXT_ID_struct_size mismatch");
611
612 # ifdef HAVE_UNION_BPF_ATTR_PROG_ID
613 static_assert(sizeof_field(struct BPF_PROG_GET_FD_BY_ID_struct, prog_id) == sizeof_field(union bpf_attr, prog_id),
614 "BPF_PROG_GET_FD_BY_ID_struct.prog_id size mismatch");
615 static_assert(offsetof(struct BPF_PROG_GET_FD_BY_ID_struct, prog_id) == offsetof(union bpf_attr, prog_id),
616 "BPF_PROG_GET_FD_BY_ID_struct.prog_id offset mismatch");
617 # endif /* HAVE_UNION_BPF_ATTR_PROG_ID */
618
619 # ifdef HAVE_UNION_BPF_ATTR_NEXT_ID
620 static_assert(sizeof_field(struct BPF_PROG_GET_FD_BY_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id),
621 "BPF_PROG_GET_FD_BY_ID_struct.next_id size mismatch");
622 static_assert(offsetof(struct BPF_PROG_GET_FD_BY_ID_struct, next_id) == offsetof(union bpf_attr, next_id),
623 "BPF_PROG_GET_FD_BY_ID_struct.next_id offset mismatch");
624 # endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */
625
626 # ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS
627 static_assert(sizeof_field(struct BPF_PROG_GET_FD_BY_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags),
628 "BPF_PROG_GET_FD_BY_ID_struct.open_flags size mismatch");
629 static_assert(offsetof(struct BPF_PROG_GET_FD_BY_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags),
630 "BPF_PROG_GET_FD_BY_ID_struct.open_flags offset mismatch");
631 # endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */
632
633 static_assert(BPF_PROG_GET_FD_BY_ID_struct_size == expected_BPF_PROG_GET_FD_BY_ID_struct_size,
634 "BPF_PROG_GET_FD_BY_ID_struct_size mismatch");
635
636 # ifdef HAVE_UNION_BPF_ATTR_MAP_ID
637 static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, map_id) == sizeof_field(union bpf_attr, map_id),
638 "BPF_MAP_GET_FD_BY_ID_struct.map_id size mismatch");
639 static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, map_id) == offsetof(union bpf_attr, map_id),
640 "BPF_MAP_GET_FD_BY_ID_struct.map_id offset mismatch");
641 # endif /* HAVE_UNION_BPF_ATTR_MAP_ID */
642
643 # ifdef HAVE_UNION_BPF_ATTR_NEXT_ID
644 static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, next_id) == sizeof_field(union bpf_attr, next_id),
645 "BPF_MAP_GET_FD_BY_ID_struct.next_id size mismatch");
646 static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, next_id) == offsetof(union bpf_attr, next_id),
647 "BPF_MAP_GET_FD_BY_ID_struct.next_id offset mismatch");
648 # endif /* HAVE_UNION_BPF_ATTR_NEXT_ID */
649
650 # ifdef HAVE_UNION_BPF_ATTR_OPEN_FLAGS
651 static_assert(sizeof_field(struct BPF_MAP_GET_FD_BY_ID_struct, open_flags) == sizeof_field(union bpf_attr, open_flags),
652 "BPF_MAP_GET_FD_BY_ID_struct.open_flags size mismatch");
653 static_assert(offsetof(struct BPF_MAP_GET_FD_BY_ID_struct, open_flags) == offsetof(union bpf_attr, open_flags),
654 "BPF_MAP_GET_FD_BY_ID_struct.open_flags offset mismatch");
655 # endif /* HAVE_UNION_BPF_ATTR_OPEN_FLAGS */
656
657 static_assert(BPF_MAP_GET_FD_BY_ID_struct_size == expected_BPF_MAP_GET_FD_BY_ID_struct_size,
658 "BPF_MAP_GET_FD_BY_ID_struct_size mismatch");
659
660 # ifdef HAVE_UNION_BPF_ATTR_INFO_BPF_FD
661 static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, bpf_fd) == sizeof_field(union bpf_attr, info.bpf_fd),
662 "BPF_OBJ_GET_INFO_BY_FD_struct.bpf_fd size mismatch");
663 static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, bpf_fd) == offsetof(union bpf_attr, info.bpf_fd),
664 "BPF_OBJ_GET_INFO_BY_FD_struct.bpf_fd offset mismatch");
665 # endif /* HAVE_UNION_BPF_ATTR_INFO_BPF_FD */
666
667 # ifdef HAVE_UNION_BPF_ATTR_INFO_INFO_LEN
668 static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, info_len) == sizeof_field(union bpf_attr, info.info_len),
669 "BPF_OBJ_GET_INFO_BY_FD_struct.info_len size mismatch");
670 static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, info_len) == offsetof(union bpf_attr, info.info_len),
671 "BPF_OBJ_GET_INFO_BY_FD_struct.info_len offset mismatch");
672 # endif /* HAVE_UNION_BPF_ATTR_INFO_INFO_LEN */
673
674 # ifdef HAVE_UNION_BPF_ATTR_INFO_INFO
675 static_assert(sizeof_field(struct BPF_OBJ_GET_INFO_BY_FD_struct, info) == sizeof_field(union bpf_attr, info.info),
676 "BPF_OBJ_GET_INFO_BY_FD_struct.info size mismatch");
677 static_assert(offsetof(struct BPF_OBJ_GET_INFO_BY_FD_struct, info) == offsetof(union bpf_attr, info.info),
678 "BPF_OBJ_GET_INFO_BY_FD_struct.info offset mismatch");
679 # endif /* HAVE_UNION_BPF_ATTR_INFO_INFO */
680
681 static_assert(BPF_OBJ_GET_INFO_BY_FD_struct_size == expected_BPF_OBJ_GET_INFO_BY_FD_struct_size,
682 "BPF_OBJ_GET_INFO_BY_FD_struct_size mismatch");
683
684 # ifdef HAVE_UNION_BPF_ATTR_QUERY_TARGET_FD
685 static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, target_fd) == sizeof_field(union bpf_attr, query.target_fd),
686 "BPF_PROG_QUERY_struct.target_fd size mismatch");
687 static_assert(offsetof(struct BPF_PROG_QUERY_struct, target_fd) == offsetof(union bpf_attr, query.target_fd),
688 "BPF_PROG_QUERY_struct.target_fd offset mismatch");
689 # endif /* HAVE_UNION_BPF_ATTR_QUERY_TARGET_FD */
690
691 # ifdef HAVE_UNION_BPF_ATTR_QUERY_ATTACH_TYPE
692 static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, attach_type) == sizeof_field(union bpf_attr, query.attach_type),
693 "BPF_PROG_QUERY_struct.attach_type size mismatch");
694 static_assert(offsetof(struct BPF_PROG_QUERY_struct, attach_type) == offsetof(union bpf_attr, query.attach_type),
695 "BPF_PROG_QUERY_struct.attach_type offset mismatch");
696 # endif /* HAVE_UNION_BPF_ATTR_QUERY_ATTACH_TYPE */
697
698 # ifdef HAVE_UNION_BPF_ATTR_QUERY_QUERY_FLAGS
699 static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, query_flags) == sizeof_field(union bpf_attr, query.query_flags),
700 "BPF_PROG_QUERY_struct.query_flags size mismatch");
701 static_assert(offsetof(struct BPF_PROG_QUERY_struct, query_flags) == offsetof(union bpf_attr, query.query_flags),
702 "BPF_PROG_QUERY_struct.query_flags offset mismatch");
703 # endif /* HAVE_UNION_BPF_ATTR_QUERY_QUERY_FLAGS */
704
705 # ifdef HAVE_UNION_BPF_ATTR_QUERY_ATTACH_FLAGS
706 static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, attach_flags) == sizeof_field(union bpf_attr, query.attach_flags),
707 "BPF_PROG_QUERY_struct.attach_flags size mismatch");
708 static_assert(offsetof(struct BPF_PROG_QUERY_struct, attach_flags) == offsetof(union bpf_attr, query.attach_flags),
709 "BPF_PROG_QUERY_struct.attach_flags offset mismatch");
710 # endif /* HAVE_UNION_BPF_ATTR_QUERY_ATTACH_FLAGS */
711
712 # ifdef HAVE_UNION_BPF_ATTR_QUERY_PROG_IDS
713 static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, prog_ids) == sizeof_field(union bpf_attr, query.prog_ids),
714 "BPF_PROG_QUERY_struct.prog_ids size mismatch");
715 static_assert(offsetof(struct BPF_PROG_QUERY_struct, prog_ids) == offsetof(union bpf_attr, query.prog_ids),
716 "BPF_PROG_QUERY_struct.prog_ids offset mismatch");
717 # endif /* HAVE_UNION_BPF_ATTR_QUERY_PROG_IDS */
718
719 # ifdef HAVE_UNION_BPF_ATTR_QUERY_PROG_CNT
720 static_assert(sizeof_field(struct BPF_PROG_QUERY_struct, prog_cnt) == sizeof_field(union bpf_attr, query.prog_cnt),
721 "BPF_PROG_QUERY_struct.prog_cnt size mismatch");
722 static_assert(offsetof(struct BPF_PROG_QUERY_struct, prog_cnt) == offsetof(union bpf_attr, query.prog_cnt),
723 "BPF_PROG_QUERY_struct.prog_cnt offset mismatch");
724 # endif /* HAVE_UNION_BPF_ATTR_QUERY_PROG_CNT */
725
726 static_assert(BPF_PROG_QUERY_struct_size == expected_BPF_PROG_QUERY_struct_size,
727 "BPF_PROG_QUERY_struct_size mismatch");
728
729 # ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_NAME
730 static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, name) == sizeof_field(union bpf_attr, raw_tracepoint.name),
731 "BPF_RAW_TRACEPOINT_OPEN_struct.name size mismatch");
732 static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, name) == offsetof(union bpf_attr, raw_tracepoint.name),
733 "BPF_RAW_TRACEPOINT_OPEN_struct.name offset mismatch");
734 # endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_NAME */
735
736 # ifdef HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_PROG_FD
737 static_assert(sizeof_field(struct BPF_RAW_TRACEPOINT_OPEN_struct, prog_fd) == sizeof_field(union bpf_attr, raw_tracepoint.prog_fd),
738 "BPF_RAW_TRACEPOINT_OPEN_struct.prog_fd size mismatch");
739 static_assert(offsetof(struct BPF_RAW_TRACEPOINT_OPEN_struct, prog_fd) == offsetof(union bpf_attr, raw_tracepoint.prog_fd),
740 "BPF_RAW_TRACEPOINT_OPEN_struct.prog_fd offset mismatch");
741 # endif /* HAVE_UNION_BPF_ATTR_RAW_TRACEPOINT_PROG_FD */
742
743 static_assert(BPF_RAW_TRACEPOINT_OPEN_struct_size == expected_BPF_RAW_TRACEPOINT_OPEN_struct_size,
744 "BPF_RAW_TRACEPOINT_OPEN_struct_size mismatch");
745
746 # ifdef HAVE_UNION_BPF_ATTR_BTF
747 static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf) == sizeof_field(union bpf_attr, btf),
748 "BPF_BTF_LOAD_struct.btf size mismatch");
749 static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf) == offsetof(union bpf_attr, btf),
750 "BPF_BTF_LOAD_struct.btf offset mismatch");
751 # endif /* HAVE_UNION_BPF_ATTR_BTF */
752
753 # ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_BUF
754 static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_buf) == sizeof_field(union bpf_attr, btf_log_buf),
755 "BPF_BTF_LOAD_struct.btf_log_buf size mismatch");
756 static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_buf) == offsetof(union bpf_attr, btf_log_buf),
757 "BPF_BTF_LOAD_struct.btf_log_buf offset mismatch");
758 # endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_BUF */
759
760 # ifdef HAVE_UNION_BPF_ATTR_BTF_SIZE
761 static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_size) == sizeof_field(union bpf_attr, btf_size),
762 "BPF_BTF_LOAD_struct.btf_size size mismatch");
763 static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_size) == offsetof(union bpf_attr, btf_size),
764 "BPF_BTF_LOAD_struct.btf_size offset mismatch");
765 # endif /* HAVE_UNION_BPF_ATTR_BTF_SIZE */
766
767 # ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_SIZE
768 static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_size) == sizeof_field(union bpf_attr, btf_log_size),
769 "BPF_BTF_LOAD_struct.btf_log_size size mismatch");
770 static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_size) == offsetof(union bpf_attr, btf_log_size),
771 "BPF_BTF_LOAD_struct.btf_log_size offset mismatch");
772 # endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_SIZE */
773
774 # ifdef HAVE_UNION_BPF_ATTR_BTF_LOG_LEVEL
775 static_assert(sizeof_field(struct BPF_BTF_LOAD_struct, btf_log_level) == sizeof_field(union bpf_attr, btf_log_level),
776 "BPF_BTF_LOAD_struct.btf_log_level size mismatch");
777 static_assert(offsetof(struct BPF_BTF_LOAD_struct, btf_log_level) == offsetof(union bpf_attr, btf_log_level),
778 "BPF_BTF_LOAD_struct.btf_log_level offset mismatch");
779 # endif /* HAVE_UNION_BPF_ATTR_BTF_LOG_LEVEL */
780
781 static_assert(BPF_BTF_LOAD_struct_size == expected_BPF_BTF_LOAD_struct_size,
782 "BPF_BTF_LOAD_struct_size mismatch");
783
784 # ifdef HAVE_UNION_BPF_ATTR_BTF_ID
785 static_assert(sizeof_field(struct BPF_BTF_GET_FD_BY_ID_struct, btf_id) == sizeof_field(union bpf_attr, btf_id),
786 "BPF_BTF_GET_FD_BY_ID_struct.btf_id size mismatch");
787 static_assert(offsetof(struct BPF_BTF_GET_FD_BY_ID_struct, btf_id) == offsetof(union bpf_attr, btf_id),
788 "BPF_BTF_GET_FD_BY_ID_struct.btf_id offset mismatch");
789 # endif /* HAVE_UNION_BPF_ATTR_BTF_ID */
790
791 static_assert(BPF_BTF_GET_FD_BY_ID_struct_size == expected_BPF_BTF_GET_FD_BY_ID_struct_size,
792 "BPF_BTF_GET_FD_BY_ID_struct_size mismatch");
793
794 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PID
795 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, pid) == sizeof_field(union bpf_attr, task_fd_query.pid),
796 "BPF_TASK_FD_QUERY_struct.pid size mismatch");
797 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, pid) == offsetof(union bpf_attr, task_fd_query.pid),
798 "BPF_TASK_FD_QUERY_struct.pid offset mismatch");
799 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PID */
800
801 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD
802 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, fd) == sizeof_field(union bpf_attr, task_fd_query.fd),
803 "BPF_TASK_FD_QUERY_struct.fd size mismatch");
804 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, fd) == offsetof(union bpf_attr, task_fd_query.fd),
805 "BPF_TASK_FD_QUERY_struct.fd offset mismatch");
806 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD */
807
808 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FLAGS
809 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, flags) == sizeof_field(union bpf_attr, task_fd_query.flags),
810 "BPF_TASK_FD_QUERY_struct.flags size mismatch");
811 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, flags) == offsetof(union bpf_attr, task_fd_query.flags),
812 "BPF_TASK_FD_QUERY_struct.flags offset mismatch");
813 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FLAGS */
814
815 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF_LEN
816 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, buf_len) == sizeof_field(union bpf_attr, task_fd_query.buf_len),
817 "BPF_TASK_FD_QUERY_struct.buf_len size mismatch");
818 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, buf_len) == offsetof(union bpf_attr, task_fd_query.buf_len),
819 "BPF_TASK_FD_QUERY_struct.buf_len offset mismatch");
820 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF_LEN */
821
822 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF
823 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, buf) == sizeof_field(union bpf_attr, task_fd_query.buf),
824 "BPF_TASK_FD_QUERY_struct.buf size mismatch");
825 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, buf) == offsetof(union bpf_attr, task_fd_query.buf),
826 "BPF_TASK_FD_QUERY_struct.buf offset mismatch");
827 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_BUF */
828
829 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROG_ID
830 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, prog_id) == sizeof_field(union bpf_attr, task_fd_query.prog_id),
831 "BPF_TASK_FD_QUERY_struct.prog_id size mismatch");
832 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, prog_id) == offsetof(union bpf_attr, task_fd_query.prog_id),
833 "BPF_TASK_FD_QUERY_struct.prog_id offset mismatch");
834 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROG_ID */
835
836 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD_TYPE
837 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, fd_type) == sizeof_field(union bpf_attr, task_fd_query.fd_type),
838 "BPF_TASK_FD_QUERY_struct.fd_type size mismatch");
839 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, fd_type) == offsetof(union bpf_attr, task_fd_query.fd_type),
840 "BPF_TASK_FD_QUERY_struct.fd_type offset mismatch");
841 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_FD_TYPE */
842
843 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_OFFSET
844 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, probe_offset) == sizeof_field(union bpf_attr, task_fd_query.probe_offset),
845 "BPF_TASK_FD_QUERY_struct.probe_offset size mismatch");
846 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, probe_offset) == offsetof(union bpf_attr, task_fd_query.probe_offset),
847 "BPF_TASK_FD_QUERY_struct.probe_offset offset mismatch");
848 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_OFFSET */
849
850 # ifdef HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_ADDR
851 static_assert(sizeof_field(struct BPF_TASK_FD_QUERY_struct, probe_addr) == sizeof_field(union bpf_attr, task_fd_query.probe_addr),
852 "BPF_TASK_FD_QUERY_struct.probe_addr size mismatch");
853 static_assert(offsetof(struct BPF_TASK_FD_QUERY_struct, probe_addr) == offsetof(union bpf_attr, task_fd_query.probe_addr),
854 "BPF_TASK_FD_QUERY_struct.probe_addr offset mismatch");
855 # endif /* HAVE_UNION_BPF_ATTR_TASK_FD_QUERY_PROBE_ADDR */
856
857 static_assert(BPF_TASK_FD_QUERY_struct_size == expected_BPF_TASK_FD_QUERY_struct_size,
858 "BPF_TASK_FD_QUERY_struct_size mismatch");
859
860 # ifdef HAVE_STRUCT_BPF_MAP_INFO_TYPE
861 static_assert(sizeof_field(struct bpf_map_info_struct, type) == sizeof_field(struct bpf_map_info, type),
862 "bpf_map_info_struct.type size mismatch");
863 static_assert(offsetof(struct bpf_map_info_struct, type) == offsetof(struct bpf_map_info, type),
864 "bpf_map_info_struct.type offset mismatch");
865 # endif /* HAVE_STRUCT_BPF_MAP_INFO_TYPE */
866
867 # ifdef HAVE_STRUCT_BPF_MAP_INFO_ID
868 static_assert(sizeof_field(struct bpf_map_info_struct, id) == sizeof_field(struct bpf_map_info, id),
869 "bpf_map_info_struct.id size mismatch");
870 static_assert(offsetof(struct bpf_map_info_struct, id) == offsetof(struct bpf_map_info, id),
871 "bpf_map_info_struct.id offset mismatch");
872 # endif /* HAVE_STRUCT_BPF_MAP_INFO_ID */
873
874 # ifdef HAVE_STRUCT_BPF_MAP_INFO_KEY_SIZE
875 static_assert(sizeof_field(struct bpf_map_info_struct, key_size) == sizeof_field(struct bpf_map_info, key_size),
876 "bpf_map_info_struct.key_size size mismatch");
877 static_assert(offsetof(struct bpf_map_info_struct, key_size) == offsetof(struct bpf_map_info, key_size),
878 "bpf_map_info_struct.key_size offset mismatch");
879 # endif /* HAVE_STRUCT_BPF_MAP_INFO_KEY_SIZE */
880
881 # ifdef HAVE_STRUCT_BPF_MAP_INFO_VALUE_SIZE
882 static_assert(sizeof_field(struct bpf_map_info_struct, value_size) == sizeof_field(struct bpf_map_info, value_size),
883 "bpf_map_info_struct.value_size size mismatch");
884 static_assert(offsetof(struct bpf_map_info_struct, value_size) == offsetof(struct bpf_map_info, value_size),
885 "bpf_map_info_struct.value_size offset mismatch");
886 # endif /* HAVE_STRUCT_BPF_MAP_INFO_VALUE_SIZE */
887
888 # ifdef HAVE_STRUCT_BPF_MAP_INFO_MAX_ENTRIES
889 static_assert(sizeof_field(struct bpf_map_info_struct, max_entries) == sizeof_field(struct bpf_map_info, max_entries),
890 "bpf_map_info_struct.max_entries size mismatch");
891 static_assert(offsetof(struct bpf_map_info_struct, max_entries) == offsetof(struct bpf_map_info, max_entries),
892 "bpf_map_info_struct.max_entries offset mismatch");
893 # endif /* HAVE_STRUCT_BPF_MAP_INFO_MAX_ENTRIES */
894
895 # ifdef HAVE_STRUCT_BPF_MAP_INFO_MAP_FLAGS
896 static_assert(sizeof_field(struct bpf_map_info_struct, map_flags) == sizeof_field(struct bpf_map_info, map_flags),
897 "bpf_map_info_struct.map_flags size mismatch");
898 static_assert(offsetof(struct bpf_map_info_struct, map_flags) == offsetof(struct bpf_map_info, map_flags),
899 "bpf_map_info_struct.map_flags offset mismatch");
900 # endif /* HAVE_STRUCT_BPF_MAP_INFO_MAP_FLAGS */
901
902 # ifdef HAVE_STRUCT_BPF_MAP_INFO_NAME
903 static_assert(sizeof_field(struct bpf_map_info_struct, name) == sizeof_field(struct bpf_map_info, name),
904 "bpf_map_info_struct.name size mismatch");
905 static_assert(offsetof(struct bpf_map_info_struct, name) == offsetof(struct bpf_map_info, name),
906 "bpf_map_info_struct.name offset mismatch");
907 # endif /* HAVE_STRUCT_BPF_MAP_INFO_NAME */
908
909 # ifdef HAVE_STRUCT_BPF_MAP_INFO_IFINDEX
910 static_assert(sizeof_field(struct bpf_map_info_struct, ifindex) == sizeof_field(struct bpf_map_info, ifindex),
911 "bpf_map_info_struct.ifindex size mismatch");
912 static_assert(offsetof(struct bpf_map_info_struct, ifindex) == offsetof(struct bpf_map_info, ifindex),
913 "bpf_map_info_struct.ifindex offset mismatch");
914 # endif /* HAVE_STRUCT_BPF_MAP_INFO_IFINDEX */
915
916 # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_VALUE_TYPE_ID
917 static_assert(sizeof_field(struct bpf_map_info_struct, btf_vmlinux_value_type_id) == sizeof_field(struct bpf_map_info, btf_vmlinux_value_type_id),
918 "bpf_map_info_struct.btf_vmlinux_value_type_id size mismatch");
919 static_assert(offsetof(struct bpf_map_info_struct, btf_vmlinux_value_type_id) == offsetof(struct bpf_map_info, btf_vmlinux_value_type_id),
920 "bpf_map_info_struct.btf_vmlinux_value_type_id offset mismatch");
921 # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_VMLINUX_VALUE_TYPE_ID */
922
923 # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_ID
924 static_assert(sizeof_field(struct bpf_map_info_struct, btf_id) == sizeof_field(struct bpf_map_info, btf_id),
925 "bpf_map_info_struct.btf_id size mismatch");
926 static_assert(offsetof(struct bpf_map_info_struct, btf_id) == offsetof(struct bpf_map_info, btf_id),
927 "bpf_map_info_struct.btf_id offset mismatch");
928 # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_ID */
929
930 # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_KEY_TYPE_ID
931 static_assert(sizeof_field(struct bpf_map_info_struct, btf_key_type_id) == sizeof_field(struct bpf_map_info, btf_key_type_id),
932 "bpf_map_info_struct.btf_key_type_id size mismatch");
933 static_assert(offsetof(struct bpf_map_info_struct, btf_key_type_id) == offsetof(struct bpf_map_info, btf_key_type_id),
934 "bpf_map_info_struct.btf_key_type_id offset mismatch");
935 # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_KEY_TYPE_ID */
936
937 # ifdef HAVE_STRUCT_BPF_MAP_INFO_BTF_VALUE_TYPE_ID
938 static_assert(sizeof_field(struct bpf_map_info_struct, btf_value_type_id) == sizeof_field(struct bpf_map_info, btf_value_type_id),
939 "bpf_map_info_struct.btf_value_type_id size mismatch");
940 static_assert(offsetof(struct bpf_map_info_struct, btf_value_type_id) == offsetof(struct bpf_map_info, btf_value_type_id),
941 "bpf_map_info_struct.btf_value_type_id offset mismatch");
942 # endif /* HAVE_STRUCT_BPF_MAP_INFO_BTF_VALUE_TYPE_ID */
943
944 # ifdef HAVE_STRUCT_BPF_MAP_INFO_PAD
945 static_assert(sizeof_field(struct bpf_map_info_struct, pad) == sizeof_field(struct bpf_map_info, pad),
946 "bpf_map_info_struct.pad size mismatch");
947 static_assert(offsetof(struct bpf_map_info_struct, pad) == offsetof(struct bpf_map_info, pad),
948 "bpf_map_info_struct.pad offset mismatch");
949 # endif /* HAVE_STRUCT_BPF_MAP_INFO_PAD */
950
951 # ifdef HAVE_STRUCT_BPF_MAP_INFO_MAP_EXTRA
952 static_assert(sizeof_field(struct bpf_map_info_struct, map_extra) == sizeof_field(struct bpf_map_info, map_extra),
953 "bpf_map_info_struct.map_extra size mismatch");
954 static_assert(offsetof(struct bpf_map_info_struct, map_extra) == offsetof(struct bpf_map_info, map_extra),
955 "bpf_map_info_struct.map_extra offset mismatch");
956 # endif /* HAVE_STRUCT_BPF_MAP_INFO_MAP_EXTRA */
957
958 static_assert(bpf_map_info_struct_size == expected_bpf_map_info_struct_size,
959 "bpf_map_info_struct_size mismatch");
960
961 # ifdef HAVE_STRUCT_BPF_PROG_INFO_TYPE
962 static_assert(sizeof_field(struct bpf_prog_info_struct, type) == sizeof_field(struct bpf_prog_info, type),
963 "bpf_prog_info_struct.type size mismatch");
964 static_assert(offsetof(struct bpf_prog_info_struct, type) == offsetof(struct bpf_prog_info, type),
965 "bpf_prog_info_struct.type offset mismatch");
966 # endif /* HAVE_STRUCT_BPF_PROG_INFO_TYPE */
967
968 # ifdef HAVE_STRUCT_BPF_PROG_INFO_ID
969 static_assert(sizeof_field(struct bpf_prog_info_struct, id) == sizeof_field(struct bpf_prog_info, id),
970 "bpf_prog_info_struct.id size mismatch");
971 static_assert(offsetof(struct bpf_prog_info_struct, id) == offsetof(struct bpf_prog_info, id),
972 "bpf_prog_info_struct.id offset mismatch");
973 # endif /* HAVE_STRUCT_BPF_PROG_INFO_ID */
974
975 # ifdef HAVE_STRUCT_BPF_PROG_INFO_TAG
976 static_assert(sizeof_field(struct bpf_prog_info_struct, tag) == sizeof_field(struct bpf_prog_info, tag),
977 "bpf_prog_info_struct.tag size mismatch");
978 static_assert(offsetof(struct bpf_prog_info_struct, tag) == offsetof(struct bpf_prog_info, tag),
979 "bpf_prog_info_struct.tag offset mismatch");
980 # endif /* HAVE_STRUCT_BPF_PROG_INFO_TAG */
981
982 # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_LEN
983 static_assert(sizeof_field(struct bpf_prog_info_struct, jited_prog_len) == sizeof_field(struct bpf_prog_info, jited_prog_len),
984 "bpf_prog_info_struct.jited_prog_len size mismatch");
985 static_assert(offsetof(struct bpf_prog_info_struct, jited_prog_len) == offsetof(struct bpf_prog_info, jited_prog_len),
986 "bpf_prog_info_struct.jited_prog_len offset mismatch");
987 # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_LEN */
988
989 # ifdef HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_LEN
990 static_assert(sizeof_field(struct bpf_prog_info_struct, xlated_prog_len) == sizeof_field(struct bpf_prog_info, xlated_prog_len),
991 "bpf_prog_info_struct.xlated_prog_len size mismatch");
992 static_assert(offsetof(struct bpf_prog_info_struct, xlated_prog_len) == offsetof(struct bpf_prog_info, xlated_prog_len),
993 "bpf_prog_info_struct.xlated_prog_len offset mismatch");
994 # endif /* HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_LEN */
995
996 # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_INSNS
997 static_assert(sizeof_field(struct bpf_prog_info_struct, jited_prog_insns) == sizeof_field(struct bpf_prog_info, jited_prog_insns),
998 "bpf_prog_info_struct.jited_prog_insns size mismatch");
999 static_assert(offsetof(struct bpf_prog_info_struct, jited_prog_insns) == offsetof(struct bpf_prog_info, jited_prog_insns),
1000 "bpf_prog_info_struct.jited_prog_insns offset mismatch");
1001 # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_PROG_INSNS */
1002
1003 # ifdef HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_INSNS
1004 static_assert(sizeof_field(struct bpf_prog_info_struct, xlated_prog_insns) == sizeof_field(struct bpf_prog_info, xlated_prog_insns),
1005 "bpf_prog_info_struct.xlated_prog_insns size mismatch");
1006 static_assert(offsetof(struct bpf_prog_info_struct, xlated_prog_insns) == offsetof(struct bpf_prog_info, xlated_prog_insns),
1007 "bpf_prog_info_struct.xlated_prog_insns offset mismatch");
1008 # endif /* HAVE_STRUCT_BPF_PROG_INFO_XLATED_PROG_INSNS */
1009
1010 # ifdef HAVE_STRUCT_BPF_PROG_INFO_LOAD_TIME
1011 static_assert(sizeof_field(struct bpf_prog_info_struct, load_time) == sizeof_field(struct bpf_prog_info, load_time),
1012 "bpf_prog_info_struct.load_time size mismatch");
1013 static_assert(offsetof(struct bpf_prog_info_struct, load_time) == offsetof(struct bpf_prog_info, load_time),
1014 "bpf_prog_info_struct.load_time offset mismatch");
1015 # endif /* HAVE_STRUCT_BPF_PROG_INFO_LOAD_TIME */
1016
1017 # ifdef HAVE_STRUCT_BPF_PROG_INFO_CREATED_BY_UID
1018 static_assert(sizeof_field(struct bpf_prog_info_struct, created_by_uid) == sizeof_field(struct bpf_prog_info, created_by_uid),
1019 "bpf_prog_info_struct.created_by_uid size mismatch");
1020 static_assert(offsetof(struct bpf_prog_info_struct, created_by_uid) == offsetof(struct bpf_prog_info, created_by_uid),
1021 "bpf_prog_info_struct.created_by_uid offset mismatch");
1022 # endif /* HAVE_STRUCT_BPF_PROG_INFO_CREATED_BY_UID */
1023
1024 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_MAP_IDS
1025 static_assert(sizeof_field(struct bpf_prog_info_struct, nr_map_ids) == sizeof_field(struct bpf_prog_info, nr_map_ids),
1026 "bpf_prog_info_struct.nr_map_ids size mismatch");
1027 static_assert(offsetof(struct bpf_prog_info_struct, nr_map_ids) == offsetof(struct bpf_prog_info, nr_map_ids),
1028 "bpf_prog_info_struct.nr_map_ids offset mismatch");
1029 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_MAP_IDS */
1030
1031 # ifdef HAVE_STRUCT_BPF_PROG_INFO_MAP_IDS
1032 static_assert(sizeof_field(struct bpf_prog_info_struct, map_ids) == sizeof_field(struct bpf_prog_info, map_ids),
1033 "bpf_prog_info_struct.map_ids size mismatch");
1034 static_assert(offsetof(struct bpf_prog_info_struct, map_ids) == offsetof(struct bpf_prog_info, map_ids),
1035 "bpf_prog_info_struct.map_ids offset mismatch");
1036 # endif /* HAVE_STRUCT_BPF_PROG_INFO_MAP_IDS */
1037
1038 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NAME
1039 static_assert(sizeof_field(struct bpf_prog_info_struct, name) == sizeof_field(struct bpf_prog_info, name),
1040 "bpf_prog_info_struct.name size mismatch");
1041 static_assert(offsetof(struct bpf_prog_info_struct, name) == offsetof(struct bpf_prog_info, name),
1042 "bpf_prog_info_struct.name offset mismatch");
1043 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NAME */
1044
1045 # ifdef HAVE_STRUCT_BPF_PROG_INFO_IFINDEX
1046 static_assert(sizeof_field(struct bpf_prog_info_struct, ifindex) == sizeof_field(struct bpf_prog_info, ifindex),
1047 "bpf_prog_info_struct.ifindex size mismatch");
1048 static_assert(offsetof(struct bpf_prog_info_struct, ifindex) == offsetof(struct bpf_prog_info, ifindex),
1049 "bpf_prog_info_struct.ifindex offset mismatch");
1050 # endif /* HAVE_STRUCT_BPF_PROG_INFO_IFINDEX */
1051
1052 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_KSYMS
1053 static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_ksyms) == sizeof_field(struct bpf_prog_info, nr_jited_ksyms),
1054 "bpf_prog_info_struct.nr_jited_ksyms size mismatch");
1055 static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_ksyms) == offsetof(struct bpf_prog_info, nr_jited_ksyms),
1056 "bpf_prog_info_struct.nr_jited_ksyms offset mismatch");
1057 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_KSYMS */
1058
1059 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_FUNC_LENS
1060 static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_func_lens) == sizeof_field(struct bpf_prog_info, nr_jited_func_lens),
1061 "bpf_prog_info_struct.nr_jited_func_lens size mismatch");
1062 static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_func_lens) == offsetof(struct bpf_prog_info, nr_jited_func_lens),
1063 "bpf_prog_info_struct.nr_jited_func_lens offset mismatch");
1064 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_FUNC_LENS */
1065
1066 # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_KSYMS
1067 static_assert(sizeof_field(struct bpf_prog_info_struct, jited_ksyms) == sizeof_field(struct bpf_prog_info, jited_ksyms),
1068 "bpf_prog_info_struct.jited_ksyms size mismatch");
1069 static_assert(offsetof(struct bpf_prog_info_struct, jited_ksyms) == offsetof(struct bpf_prog_info, jited_ksyms),
1070 "bpf_prog_info_struct.jited_ksyms offset mismatch");
1071 # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_KSYMS */
1072
1073 # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_FUNC_LENS
1074 static_assert(sizeof_field(struct bpf_prog_info_struct, jited_func_lens) == sizeof_field(struct bpf_prog_info, jited_func_lens),
1075 "bpf_prog_info_struct.jited_func_lens size mismatch");
1076 static_assert(offsetof(struct bpf_prog_info_struct, jited_func_lens) == offsetof(struct bpf_prog_info, jited_func_lens),
1077 "bpf_prog_info_struct.jited_func_lens offset mismatch");
1078 # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_FUNC_LENS */
1079
1080 # ifdef HAVE_STRUCT_BPF_PROG_INFO_BTF_ID
1081 static_assert(sizeof_field(struct bpf_prog_info_struct, btf_id) == sizeof_field(struct bpf_prog_info, btf_id),
1082 "bpf_prog_info_struct.btf_id size mismatch");
1083 static_assert(offsetof(struct bpf_prog_info_struct, btf_id) == offsetof(struct bpf_prog_info, btf_id),
1084 "bpf_prog_info_struct.btf_id offset mismatch");
1085 # endif /* HAVE_STRUCT_BPF_PROG_INFO_BTF_ID */
1086
1087 # ifdef HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO_REC_SIZE
1088 static_assert(sizeof_field(struct bpf_prog_info_struct, func_info_rec_size) == sizeof_field(struct bpf_prog_info, func_info_rec_size),
1089 "bpf_prog_info_struct.func_info_rec_size size mismatch");
1090 static_assert(offsetof(struct bpf_prog_info_struct, func_info_rec_size) == offsetof(struct bpf_prog_info, func_info_rec_size),
1091 "bpf_prog_info_struct.func_info_rec_size offset mismatch");
1092 # endif /* HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO_REC_SIZE */
1093
1094 # ifdef HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO
1095 static_assert(sizeof_field(struct bpf_prog_info_struct, func_info) == sizeof_field(struct bpf_prog_info, func_info),
1096 "bpf_prog_info_struct.func_info size mismatch");
1097 static_assert(offsetof(struct bpf_prog_info_struct, func_info) == offsetof(struct bpf_prog_info, func_info),
1098 "bpf_prog_info_struct.func_info offset mismatch");
1099 # endif /* HAVE_STRUCT_BPF_PROG_INFO_FUNC_INFO */
1100
1101 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_FUNC_INFO
1102 static_assert(sizeof_field(struct bpf_prog_info_struct, nr_func_info) == sizeof_field(struct bpf_prog_info, nr_func_info),
1103 "bpf_prog_info_struct.nr_func_info size mismatch");
1104 static_assert(offsetof(struct bpf_prog_info_struct, nr_func_info) == offsetof(struct bpf_prog_info, nr_func_info),
1105 "bpf_prog_info_struct.nr_func_info offset mismatch");
1106 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_FUNC_INFO */
1107
1108 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_LINE_INFO
1109 static_assert(sizeof_field(struct bpf_prog_info_struct, nr_line_info) == sizeof_field(struct bpf_prog_info, nr_line_info),
1110 "bpf_prog_info_struct.nr_line_info size mismatch");
1111 static_assert(offsetof(struct bpf_prog_info_struct, nr_line_info) == offsetof(struct bpf_prog_info, nr_line_info),
1112 "bpf_prog_info_struct.nr_line_info offset mismatch");
1113 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_LINE_INFO */
1114
1115 # ifdef HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO
1116 static_assert(sizeof_field(struct bpf_prog_info_struct, line_info) == sizeof_field(struct bpf_prog_info, line_info),
1117 "bpf_prog_info_struct.line_info size mismatch");
1118 static_assert(offsetof(struct bpf_prog_info_struct, line_info) == offsetof(struct bpf_prog_info, line_info),
1119 "bpf_prog_info_struct.line_info offset mismatch");
1120 # endif /* HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO */
1121
1122 # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO
1123 static_assert(sizeof_field(struct bpf_prog_info_struct, jited_line_info) == sizeof_field(struct bpf_prog_info, jited_line_info),
1124 "bpf_prog_info_struct.jited_line_info size mismatch");
1125 static_assert(offsetof(struct bpf_prog_info_struct, jited_line_info) == offsetof(struct bpf_prog_info, jited_line_info),
1126 "bpf_prog_info_struct.jited_line_info offset mismatch");
1127 # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO */
1128
1129 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_LINE_INFO
1130 static_assert(sizeof_field(struct bpf_prog_info_struct, nr_jited_line_info) == sizeof_field(struct bpf_prog_info, nr_jited_line_info),
1131 "bpf_prog_info_struct.nr_jited_line_info size mismatch");
1132 static_assert(offsetof(struct bpf_prog_info_struct, nr_jited_line_info) == offsetof(struct bpf_prog_info, nr_jited_line_info),
1133 "bpf_prog_info_struct.nr_jited_line_info offset mismatch");
1134 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_JITED_LINE_INFO */
1135
1136 # ifdef HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO_REC_SIZE
1137 static_assert(sizeof_field(struct bpf_prog_info_struct, line_info_rec_size) == sizeof_field(struct bpf_prog_info, line_info_rec_size),
1138 "bpf_prog_info_struct.line_info_rec_size size mismatch");
1139 static_assert(offsetof(struct bpf_prog_info_struct, line_info_rec_size) == offsetof(struct bpf_prog_info, line_info_rec_size),
1140 "bpf_prog_info_struct.line_info_rec_size offset mismatch");
1141 # endif /* HAVE_STRUCT_BPF_PROG_INFO_LINE_INFO_REC_SIZE */
1142
1143 # ifdef HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO_REC_SIZE
1144 static_assert(sizeof_field(struct bpf_prog_info_struct, jited_line_info_rec_size) == sizeof_field(struct bpf_prog_info, jited_line_info_rec_size),
1145 "bpf_prog_info_struct.jited_line_info_rec_size size mismatch");
1146 static_assert(offsetof(struct bpf_prog_info_struct, jited_line_info_rec_size) == offsetof(struct bpf_prog_info, jited_line_info_rec_size),
1147 "bpf_prog_info_struct.jited_line_info_rec_size offset mismatch");
1148 # endif /* HAVE_STRUCT_BPF_PROG_INFO_JITED_LINE_INFO_REC_SIZE */
1149
1150 # ifdef HAVE_STRUCT_BPF_PROG_INFO_NR_PROG_TAGS
1151 static_assert(sizeof_field(struct bpf_prog_info_struct, nr_prog_tags) == sizeof_field(struct bpf_prog_info, nr_prog_tags),
1152 "bpf_prog_info_struct.nr_prog_tags size mismatch");
1153 static_assert(offsetof(struct bpf_prog_info_struct, nr_prog_tags) == offsetof(struct bpf_prog_info, nr_prog_tags),
1154 "bpf_prog_info_struct.nr_prog_tags offset mismatch");
1155 # endif /* HAVE_STRUCT_BPF_PROG_INFO_NR_PROG_TAGS */
1156
1157 # ifdef HAVE_STRUCT_BPF_PROG_INFO_PROG_TAGS
1158 static_assert(sizeof_field(struct bpf_prog_info_struct, prog_tags) == sizeof_field(struct bpf_prog_info, prog_tags),
1159 "bpf_prog_info_struct.prog_tags size mismatch");
1160 static_assert(offsetof(struct bpf_prog_info_struct, prog_tags) == offsetof(struct bpf_prog_info, prog_tags),
1161 "bpf_prog_info_struct.prog_tags offset mismatch");
1162 # endif /* HAVE_STRUCT_BPF_PROG_INFO_PROG_TAGS */
1163
1164 # ifdef HAVE_STRUCT_BPF_PROG_INFO_RUN_TIME_NS
1165 static_assert(sizeof_field(struct bpf_prog_info_struct, run_time_ns) == sizeof_field(struct bpf_prog_info, run_time_ns),
1166 "bpf_prog_info_struct.run_time_ns size mismatch");
1167 static_assert(offsetof(struct bpf_prog_info_struct, run_time_ns) == offsetof(struct bpf_prog_info, run_time_ns),
1168 "bpf_prog_info_struct.run_time_ns offset mismatch");
1169 # endif /* HAVE_STRUCT_BPF_PROG_INFO_RUN_TIME_NS */
1170
1171 # ifdef HAVE_STRUCT_BPF_PROG_INFO_RUN_CNT
1172 static_assert(sizeof_field(struct bpf_prog_info_struct, run_cnt) == sizeof_field(struct bpf_prog_info, run_cnt),
1173 "bpf_prog_info_struct.run_cnt size mismatch");
1174 static_assert(offsetof(struct bpf_prog_info_struct, run_cnt) == offsetof(struct bpf_prog_info, run_cnt),
1175 "bpf_prog_info_struct.run_cnt offset mismatch");
1176 # endif /* HAVE_STRUCT_BPF_PROG_INFO_RUN_CNT */
1177
1178 # ifdef HAVE_STRUCT_BPF_PROG_INFO_RECURSION_MISSES
1179 static_assert(sizeof_field(struct bpf_prog_info_struct, recursion_misses) == sizeof_field(struct bpf_prog_info, recursion_misses),
1180 "bpf_prog_info_struct.recursion_misses size mismatch");
1181 static_assert(offsetof(struct bpf_prog_info_struct, recursion_misses) == offsetof(struct bpf_prog_info, recursion_misses),
1182 "bpf_prog_info_struct.recursion_misses offset mismatch");
1183 # endif /* HAVE_STRUCT_BPF_PROG_INFO_RECURSION_MISSES */
1184
1185 # ifdef HAVE_STRUCT_BPF_PROG_INFO_VERIFIED_INSNS
1186 static_assert(sizeof_field(struct bpf_prog_info_struct, verified_insns) == sizeof_field(struct bpf_prog_info, verified_insns),
1187 "bpf_prog_info_struct.verified_insns size mismatch");
1188 static_assert(offsetof(struct bpf_prog_info_struct, verified_insns) == offsetof(struct bpf_prog_info, verified_insns),
1189 "bpf_prog_info_struct.verified_insns offset mismatch");
1190 # endif /* HAVE_STRUCT_BPF_PROG_INFO_VERIFIED_INSNS */
1191
1192 static_assert(bpf_prog_info_struct_size == expected_bpf_prog_info_struct_size,
1193 "bpf_prog_info_struct_size mismatch");
1194
1195 # ifdef HAVE_UNION_BPF_ATTR_BATCH_IN_BATCH
1196 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, in_batch) == sizeof_field(union bpf_attr, batch.in_batch),
1197 "BPF_MAP_LOOKUP_BATCH_struct.in_batch size mismatch");
1198 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, in_batch) == offsetof(union bpf_attr, batch.in_batch),
1199 "BPF_MAP_LOOKUP_BATCH_struct.in_batch offset mismatch");
1200 # endif /* HAVE_UNION_BPF_ATTR_BATCH_IN_BATCH */
1201
1202 # ifdef HAVE_UNION_BPF_ATTR_BATCH_OUT_BATCH
1203 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, out_batch) == sizeof_field(union bpf_attr, batch.out_batch),
1204 "BPF_MAP_LOOKUP_BATCH_struct.out_batch size mismatch");
1205 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, out_batch) == offsetof(union bpf_attr, batch.out_batch),
1206 "BPF_MAP_LOOKUP_BATCH_struct.out_batch offset mismatch");
1207 # endif /* HAVE_UNION_BPF_ATTR_BATCH_OUT_BATCH */
1208
1209 # ifdef HAVE_UNION_BPF_ATTR_BATCH_KEYS
1210 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, keys) == sizeof_field(union bpf_attr, batch.keys),
1211 "BPF_MAP_LOOKUP_BATCH_struct.keys size mismatch");
1212 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, keys) == offsetof(union bpf_attr, batch.keys),
1213 "BPF_MAP_LOOKUP_BATCH_struct.keys offset mismatch");
1214 # endif /* HAVE_UNION_BPF_ATTR_BATCH_KEYS */
1215
1216 # ifdef HAVE_UNION_BPF_ATTR_BATCH_VALUES
1217 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, values) == sizeof_field(union bpf_attr, batch.values),
1218 "BPF_MAP_LOOKUP_BATCH_struct.values size mismatch");
1219 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, values) == offsetof(union bpf_attr, batch.values),
1220 "BPF_MAP_LOOKUP_BATCH_struct.values offset mismatch");
1221 # endif /* HAVE_UNION_BPF_ATTR_BATCH_VALUES */
1222
1223 # ifdef HAVE_UNION_BPF_ATTR_BATCH_COUNT
1224 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, count) == sizeof_field(union bpf_attr, batch.count),
1225 "BPF_MAP_LOOKUP_BATCH_struct.count size mismatch");
1226 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, count) == offsetof(union bpf_attr, batch.count),
1227 "BPF_MAP_LOOKUP_BATCH_struct.count offset mismatch");
1228 # endif /* HAVE_UNION_BPF_ATTR_BATCH_COUNT */
1229
1230 # ifdef HAVE_UNION_BPF_ATTR_BATCH_MAP_FD
1231 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, map_fd) == sizeof_field(union bpf_attr, batch.map_fd),
1232 "BPF_MAP_LOOKUP_BATCH_struct.map_fd size mismatch");
1233 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, map_fd) == offsetof(union bpf_attr, batch.map_fd),
1234 "BPF_MAP_LOOKUP_BATCH_struct.map_fd offset mismatch");
1235 # endif /* HAVE_UNION_BPF_ATTR_BATCH_MAP_FD */
1236
1237 # ifdef HAVE_UNION_BPF_ATTR_BATCH_ELEM_FLAGS
1238 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, elem_flags) == sizeof_field(union bpf_attr, batch.elem_flags),
1239 "BPF_MAP_LOOKUP_BATCH_struct.elem_flags size mismatch");
1240 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, elem_flags) == offsetof(union bpf_attr, batch.elem_flags),
1241 "BPF_MAP_LOOKUP_BATCH_struct.elem_flags offset mismatch");
1242 # endif /* HAVE_UNION_BPF_ATTR_BATCH_ELEM_FLAGS */
1243
1244 # ifdef HAVE_UNION_BPF_ATTR_BATCH_FLAGS
1245 static_assert(sizeof_field(struct BPF_MAP_LOOKUP_BATCH_struct, flags) == sizeof_field(union bpf_attr, batch.flags),
1246 "BPF_MAP_LOOKUP_BATCH_struct.flags size mismatch");
1247 static_assert(offsetof(struct BPF_MAP_LOOKUP_BATCH_struct, flags) == offsetof(union bpf_attr, batch.flags),
1248 "BPF_MAP_LOOKUP_BATCH_struct.flags offset mismatch");
1249 # endif /* HAVE_UNION_BPF_ATTR_BATCH_FLAGS */
1250
1251 static_assert(BPF_MAP_LOOKUP_BATCH_struct_size == expected_BPF_MAP_LOOKUP_BATCH_struct_size,
1252 "BPF_MAP_LOOKUP_BATCH_struct_size mismatch");
1253
1254 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PROG_FD
1255 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, prog_fd) == sizeof_field(union bpf_attr, link_create.prog_fd),
1256 "BPF_LINK_CREATE_struct.prog_fd size mismatch");
1257 static_assert(offsetof(struct BPF_LINK_CREATE_struct, prog_fd) == offsetof(union bpf_attr, link_create.prog_fd),
1258 "BPF_LINK_CREATE_struct.prog_fd offset mismatch");
1259 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PROG_FD */
1260
1261 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_FD
1262 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, target_fd) == sizeof_field(union bpf_attr, link_create.target_fd),
1263 "BPF_LINK_CREATE_struct.target_fd size mismatch");
1264 static_assert(offsetof(struct BPF_LINK_CREATE_struct, target_fd) == offsetof(union bpf_attr, link_create.target_fd),
1265 "BPF_LINK_CREATE_struct.target_fd offset mismatch");
1266 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_FD */
1267
1268 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ATTACH_TYPE
1269 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, attach_type) == sizeof_field(union bpf_attr, link_create.attach_type),
1270 "BPF_LINK_CREATE_struct.attach_type size mismatch");
1271 static_assert(offsetof(struct BPF_LINK_CREATE_struct, attach_type) == offsetof(union bpf_attr, link_create.attach_type),
1272 "BPF_LINK_CREATE_struct.attach_type offset mismatch");
1273 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ATTACH_TYPE */
1274
1275 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS
1276 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, flags) == sizeof_field(union bpf_attr, link_create.flags),
1277 "BPF_LINK_CREATE_struct.flags size mismatch");
1278 static_assert(offsetof(struct BPF_LINK_CREATE_struct, flags) == offsetof(union bpf_attr, link_create.flags),
1279 "BPF_LINK_CREATE_struct.flags offset mismatch");
1280 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS */
1281
1282 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_BTF_ID
1283 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, target_btf_id) == sizeof_field(union bpf_attr, link_create.target_btf_id),
1284 "BPF_LINK_CREATE_struct.target_btf_id size mismatch");
1285 static_assert(offsetof(struct BPF_LINK_CREATE_struct, target_btf_id) == offsetof(union bpf_attr, link_create.target_btf_id),
1286 "BPF_LINK_CREATE_struct.target_btf_id offset mismatch");
1287 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_TARGET_BTF_ID */
1288
1289 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO
1290 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, iter_info) == sizeof_field(union bpf_attr, link_create.iter_info),
1291 "BPF_LINK_CREATE_struct.iter_info size mismatch");
1292 static_assert(offsetof(struct BPF_LINK_CREATE_struct, iter_info) == offsetof(union bpf_attr, link_create.iter_info),
1293 "BPF_LINK_CREATE_struct.iter_info offset mismatch");
1294 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO */
1295
1296 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO_LEN
1297 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, iter_info_len) == sizeof_field(union bpf_attr, link_create.iter_info_len),
1298 "BPF_LINK_CREATE_struct.iter_info_len size mismatch");
1299 static_assert(offsetof(struct BPF_LINK_CREATE_struct, iter_info_len) == offsetof(union bpf_attr, link_create.iter_info_len),
1300 "BPF_LINK_CREATE_struct.iter_info_len offset mismatch");
1301 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ITER_INFO_LEN */
1302
1303 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_BPF_COOKIE
1304 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, bpf_cookie) == sizeof_field(union bpf_attr, link_create.bpf_cookie),
1305 "BPF_LINK_CREATE_struct.bpf_cookie size mismatch");
1306 static_assert(offsetof(struct BPF_LINK_CREATE_struct, bpf_cookie) == offsetof(union bpf_attr, link_create.bpf_cookie),
1307 "BPF_LINK_CREATE_struct.bpf_cookie offset mismatch");
1308 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_BPF_COOKIE */
1309
1310 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_PERF_EVENT
1311 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, perf_event) == sizeof_field(union bpf_attr, link_create.perf_event),
1312 "BPF_LINK_CREATE_struct.perf_event size mismatch");
1313 static_assert(offsetof(struct BPF_LINK_CREATE_struct, perf_event) == offsetof(union bpf_attr, link_create.perf_event),
1314 "BPF_LINK_CREATE_struct.perf_event offset mismatch");
1315 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_PERF_EVENT */
1316
1317 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS
1318 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, flags) == sizeof_field(union bpf_attr, link_create.flags),
1319 "BPF_LINK_CREATE_struct.flags size mismatch");
1320 static_assert(offsetof(struct BPF_LINK_CREATE_struct, flags) == offsetof(union bpf_attr, link_create.flags),
1321 "BPF_LINK_CREATE_struct.flags offset mismatch");
1322 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_FLAGS */
1323
1324 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_CNT
1325 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, cnt) == sizeof_field(union bpf_attr, link_create.cnt),
1326 "BPF_LINK_CREATE_struct.cnt size mismatch");
1327 static_assert(offsetof(struct BPF_LINK_CREATE_struct, cnt) == offsetof(union bpf_attr, link_create.cnt),
1328 "BPF_LINK_CREATE_struct.cnt offset mismatch");
1329 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_CNT */
1330
1331 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_SYMS
1332 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, syms) == sizeof_field(union bpf_attr, link_create.syms),
1333 "BPF_LINK_CREATE_struct.syms size mismatch");
1334 static_assert(offsetof(struct BPF_LINK_CREATE_struct, syms) == offsetof(union bpf_attr, link_create.syms),
1335 "BPF_LINK_CREATE_struct.syms offset mismatch");
1336 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_SYMS */
1337
1338 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_ADDRS
1339 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, addrs) == sizeof_field(union bpf_attr, link_create.addrs),
1340 "BPF_LINK_CREATE_struct.addrs size mismatch");
1341 static_assert(offsetof(struct BPF_LINK_CREATE_struct, addrs) == offsetof(union bpf_attr, link_create.addrs),
1342 "BPF_LINK_CREATE_struct.addrs offset mismatch");
1343 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_ADDRS */
1344
1345 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_COOKIES
1346 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, cookies) == sizeof_field(union bpf_attr, link_create.cookies),
1347 "BPF_LINK_CREATE_struct.cookies size mismatch");
1348 static_assert(offsetof(struct BPF_LINK_CREATE_struct, cookies) == offsetof(union bpf_attr, link_create.cookies),
1349 "BPF_LINK_CREATE_struct.cookies offset mismatch");
1350 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_COOKIES */
1351
1352 # ifdef HAVE_UNION_BPF_ATTR_LINK_CREATE_KPROBE_MULTI
1353 static_assert(sizeof_field(struct BPF_LINK_CREATE_struct, kprobe_multi) == sizeof_field(union bpf_attr, link_create.kprobe_multi),
1354 "BPF_LINK_CREATE_struct.kprobe_multi size mismatch");
1355 static_assert(offsetof(struct BPF_LINK_CREATE_struct, kprobe_multi) == offsetof(union bpf_attr, link_create.kprobe_multi),
1356 "BPF_LINK_CREATE_struct.kprobe_multi offset mismatch");
1357 # endif /* HAVE_UNION_BPF_ATTR_LINK_CREATE_KPROBE_MULTI */
1358
1359 static_assert(BPF_LINK_CREATE_struct_size == expected_BPF_LINK_CREATE_struct_size,
1360 "BPF_LINK_CREATE_struct_size mismatch");
1361
1362 # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_LINK_FD
1363 static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, link_fd) == sizeof_field(union bpf_attr, link_update.link_fd),
1364 "BPF_LINK_UPDATE_struct.link_fd size mismatch");
1365 static_assert(offsetof(struct BPF_LINK_UPDATE_struct, link_fd) == offsetof(union bpf_attr, link_update.link_fd),
1366 "BPF_LINK_UPDATE_struct.link_fd offset mismatch");
1367 # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_LINK_FD */
1368
1369 # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_NEW_PROG_FD
1370 static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, new_prog_fd) == sizeof_field(union bpf_attr, link_update.new_prog_fd),
1371 "BPF_LINK_UPDATE_struct.new_prog_fd size mismatch");
1372 static_assert(offsetof(struct BPF_LINK_UPDATE_struct, new_prog_fd) == offsetof(union bpf_attr, link_update.new_prog_fd),
1373 "BPF_LINK_UPDATE_struct.new_prog_fd offset mismatch");
1374 # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_NEW_PROG_FD */
1375
1376 # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_FLAGS
1377 static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, flags) == sizeof_field(union bpf_attr, link_update.flags),
1378 "BPF_LINK_UPDATE_struct.flags size mismatch");
1379 static_assert(offsetof(struct BPF_LINK_UPDATE_struct, flags) == offsetof(union bpf_attr, link_update.flags),
1380 "BPF_LINK_UPDATE_struct.flags offset mismatch");
1381 # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_FLAGS */
1382
1383 # ifdef HAVE_UNION_BPF_ATTR_LINK_UPDATE_OLD_PROG_FD
1384 static_assert(sizeof_field(struct BPF_LINK_UPDATE_struct, old_prog_fd) == sizeof_field(union bpf_attr, link_update.old_prog_fd),
1385 "BPF_LINK_UPDATE_struct.old_prog_fd size mismatch");
1386 static_assert(offsetof(struct BPF_LINK_UPDATE_struct, old_prog_fd) == offsetof(union bpf_attr, link_update.old_prog_fd),
1387 "BPF_LINK_UPDATE_struct.old_prog_fd offset mismatch");
1388 # endif /* HAVE_UNION_BPF_ATTR_LINK_UPDATE_OLD_PROG_FD */
1389
1390 static_assert(BPF_LINK_UPDATE_struct_size == expected_BPF_LINK_UPDATE_struct_size,
1391 "BPF_LINK_UPDATE_struct_size mismatch");
1392
1393 # ifdef HAVE_UNION_BPF_ATTR_LINK_ID
1394 static_assert(sizeof_field(struct BPF_LINK_GET_FD_BY_ID_struct, link_id) == sizeof_field(union bpf_attr, link_id),
1395 "BPF_LINK_GET_FD_BY_ID_struct.link_id size mismatch");
1396 static_assert(offsetof(struct BPF_LINK_GET_FD_BY_ID_struct, link_id) == offsetof(union bpf_attr, link_id),
1397 "BPF_LINK_GET_FD_BY_ID_struct.link_id offset mismatch");
1398 # endif /* HAVE_UNION_BPF_ATTR_LINK_ID */
1399
1400 static_assert(BPF_LINK_GET_FD_BY_ID_struct_size == expected_BPF_LINK_GET_FD_BY_ID_struct_size,
1401 "BPF_LINK_GET_FD_BY_ID_struct_size mismatch");
1402
1403 # ifdef HAVE_UNION_BPF_ATTR_ENABLE_STATS_TYPE
1404 static_assert(sizeof_field(struct BPF_ENABLE_STATS_struct, type) == sizeof_field(union bpf_attr, enable_stats.type),
1405 "BPF_ENABLE_STATS_struct.type size mismatch");
1406 static_assert(offsetof(struct BPF_ENABLE_STATS_struct, type) == offsetof(union bpf_attr, enable_stats.type),
1407 "BPF_ENABLE_STATS_struct.type offset mismatch");
1408 # endif /* HAVE_UNION_BPF_ATTR_ENABLE_STATS_TYPE */
1409
1410 static_assert(BPF_ENABLE_STATS_struct_size == expected_BPF_ENABLE_STATS_struct_size,
1411 "BPF_ENABLE_STATS_struct_size mismatch");
1412
1413 # ifdef HAVE_UNION_BPF_ATTR_ITER_CREATE_LINK_FD
1414 static_assert(sizeof_field(struct BPF_ITER_CREATE_struct, link_fd) == sizeof_field(union bpf_attr, iter_create.link_fd),
1415 "BPF_ITER_CREATE_struct.link_fd size mismatch");
1416 static_assert(offsetof(struct BPF_ITER_CREATE_struct, link_fd) == offsetof(union bpf_attr, iter_create.link_fd),
1417 "BPF_ITER_CREATE_struct.link_fd offset mismatch");
1418 # endif /* HAVE_UNION_BPF_ATTR_ITER_CREATE_LINK_FD */
1419
1420 # ifdef HAVE_UNION_BPF_ATTR_ITER_CREATE_FLAGS
1421 static_assert(sizeof_field(struct BPF_ITER_CREATE_struct, flags) == sizeof_field(union bpf_attr, iter_create.flags),
1422 "BPF_ITER_CREATE_struct.flags size mismatch");
1423 static_assert(offsetof(struct BPF_ITER_CREATE_struct, flags) == offsetof(union bpf_attr, iter_create.flags),
1424 "BPF_ITER_CREATE_struct.flags offset mismatch");
1425 # endif /* HAVE_UNION_BPF_ATTR_ITER_CREATE_FLAGS */
1426
1427 static_assert(BPF_ITER_CREATE_struct_size == expected_BPF_ITER_CREATE_struct_size,
1428 "BPF_ITER_CREATE_struct_size mismatch");
1429
1430 # ifdef HAVE_UNION_BPF_ATTR_LINK_DETACH_LINK_FD
1431 static_assert(sizeof_field(struct BPF_LINK_DETACH_struct, link_fd) == sizeof_field(union bpf_attr, link_detach.link_fd),
1432 "BPF_LINK_DETACH_struct.link_fd size mismatch");
1433 static_assert(offsetof(struct BPF_LINK_DETACH_struct, link_fd) == offsetof(union bpf_attr, link_detach.link_fd),
1434 "BPF_LINK_DETACH_struct.link_fd offset mismatch");
1435 # endif /* HAVE_UNION_BPF_ATTR_LINK_DETACH_LINK_FD */
1436
1437 static_assert(BPF_LINK_DETACH_struct_size == expected_BPF_LINK_DETACH_struct_size,
1438 "BPF_LINK_DETACH_struct_size mismatch");
1439
1440 # ifdef HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_PROG_FD
1441 static_assert(sizeof_field(struct BPF_PROG_BIND_MAP_struct, prog_fd) == sizeof_field(union bpf_attr, prog_bind_map.prog_fd),
1442 "BPF_PROG_BIND_MAP_struct.prog_fd size mismatch");
1443 static_assert(offsetof(struct BPF_PROG_BIND_MAP_struct, prog_fd) == offsetof(union bpf_attr, prog_bind_map.prog_fd),
1444 "BPF_PROG_BIND_MAP_struct.prog_fd offset mismatch");
1445 # endif /* HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_PROG_FD */
1446
1447 # ifdef HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_MAP_FD
1448 static_assert(sizeof_field(struct BPF_PROG_BIND_MAP_struct, map_fd) == sizeof_field(union bpf_attr, prog_bind_map.map_fd),
1449 "BPF_PROG_BIND_MAP_struct.map_fd size mismatch");
1450 static_assert(offsetof(struct BPF_PROG_BIND_MAP_struct, map_fd) == offsetof(union bpf_attr, prog_bind_map.map_fd),
1451 "BPF_PROG_BIND_MAP_struct.map_fd offset mismatch");
1452 # endif /* HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_MAP_FD */
1453
1454 # ifdef HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_FLAGS
1455 static_assert(sizeof_field(struct BPF_PROG_BIND_MAP_struct, flags) == sizeof_field(union bpf_attr, prog_bind_map.flags),
1456 "BPF_PROG_BIND_MAP_struct.flags size mismatch");
1457 static_assert(offsetof(struct BPF_PROG_BIND_MAP_struct, flags) == offsetof(union bpf_attr, prog_bind_map.flags),
1458 "BPF_PROG_BIND_MAP_struct.flags offset mismatch");
1459 # endif /* HAVE_UNION_BPF_ATTR_PROG_BIND_MAP_FLAGS */
1460
1461 static_assert(BPF_PROG_BIND_MAP_struct_size == expected_BPF_PROG_BIND_MAP_struct_size,
1462 "BPF_PROG_BIND_MAP_struct_size mismatch");
1463
1464 #endif /* HAVE_LINUX_BPF_H */