1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* Copyright (c) 2018 Facebook */
3
4 #include <linux/bpf.h>
5 #include <linux/btf.h>
6 #include <linux/err.h>
7 #include <linux/kernel.h>
8 #include <linux/filter.h>
9 #include <linux/unistd.h>
10 #include <bpf/bpf.h>
11 #include <libelf.h>
12 #include <gelf.h>
13 #include <string.h>
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include <stdarg.h>
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <errno.h>
20 #include <assert.h>
21 #include <bpf/libbpf.h>
22 #include <bpf/btf.h>
23
24 #include "bpf_util.h"
25 #include "../test_btf.h"
26 #include "test_progs.h"
27
28 #define MAX_INSNS 512
29 #define MAX_SUBPROGS 16
30
31 static int duration = 0;
32 static bool always_log;
33
34 #undef CHECK
35 #define CHECK(condition, format...) _CHECK(condition, "check", duration, format)
36
37 #define NAME_TBD 0xdeadb33f
38
39 #define NAME_NTH(N) (0xfffe0000 | N)
40 #define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xfffe0000)
41 #define GET_NAME_NTH_IDX(X) (X & 0x0000ffff)
42
43 #define MAX_NR_RAW_U32 1024
44 #define BTF_LOG_BUF_SIZE 65535
45
46 static char btf_log_buf[BTF_LOG_BUF_SIZE];
47
48 static struct btf_header hdr_tmpl = {
49 .magic = BTF_MAGIC,
50 .version = BTF_VERSION,
51 .hdr_len = sizeof(struct btf_header),
52 };
53
54 /* several different mapv kinds(types) supported by pprint */
55 enum pprint_mapv_kind_t {
56 PPRINT_MAPV_KIND_BASIC = 0,
57 PPRINT_MAPV_KIND_INT128,
58 };
59
60 struct btf_raw_test {
61 const char *descr;
62 const char *str_sec;
63 const char *map_name;
64 const char *err_str;
65 __u32 raw_types[MAX_NR_RAW_U32];
66 __u32 str_sec_size;
67 enum bpf_map_type map_type;
68 __u32 key_size;
69 __u32 value_size;
70 __u32 key_type_id;
71 __u32 value_type_id;
72 __u32 max_entries;
73 bool btf_load_err;
74 bool map_create_err;
75 bool ordered_map;
76 bool lossless_map;
77 bool percpu_map;
78 int hdr_len_delta;
79 int type_off_delta;
80 int str_off_delta;
81 int str_len_delta;
82 enum pprint_mapv_kind_t mapv_kind;
83 };
84
85 #define BTF_STR_SEC(str) \
86 .str_sec = str, .str_sec_size = sizeof(str)
87
88 static struct btf_raw_test raw_tests[] = {
89 /* enum E {
90 * E0,
91 * E1,
92 * };
93 *
94 * struct A {
95 * unsigned long long m;
96 * int n;
97 * char o;
98 * [3 bytes hole]
99 * int p[8];
100 * int q[4][8];
101 * enum E r;
102 * };
103 */
104 {
105 .descr = "struct test #1",
106 .raw_types = {
107 /* int */
108 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
109 /* unsigned long long */
110 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
111 /* char */
112 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
113 /* int[8] */
114 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
115 /* struct A { */ /* [5] */
116 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 6), 180),
117 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
118 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
119 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
120 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
121 BTF_MEMBER_ENC(NAME_TBD, 6, 384),/* int q[4][8] */
122 BTF_MEMBER_ENC(NAME_TBD, 7, 1408), /* enum E r */
123 /* } */
124 /* int[4][8] */
125 BTF_TYPE_ARRAY_ENC(4, 1, 4), /* [6] */
126 /* enum E */ /* [7] */
127 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
128 BTF_ENUM_ENC(NAME_TBD, 0),
129 BTF_ENUM_ENC(NAME_TBD, 1),
130 BTF_END_RAW,
131 },
132 .str_sec = "\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1",
133 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1"),
134 .map_type = BPF_MAP_TYPE_ARRAY,
135 .map_name = "struct_test1_map",
136 .key_size = sizeof(int),
137 .value_size = 180,
138 .key_type_id = 1,
139 .value_type_id = 5,
140 .max_entries = 4,
141 },
142
143 /* typedef struct b Struct_B;
144 *
145 * struct A {
146 * int m;
147 * struct b n[4];
148 * const Struct_B o[4];
149 * };
150 *
151 * struct B {
152 * int m;
153 * int n;
154 * };
155 */
156 {
157 .descr = "struct test #2",
158 .raw_types = {
159 /* int */ /* [1] */
160 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
161 /* struct b [4] */ /* [2] */
162 BTF_TYPE_ARRAY_ENC(4, 1, 4),
163
164 /* struct A { */ /* [3] */
165 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 3), 68),
166 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
167 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct B n[4] */
168 BTF_MEMBER_ENC(NAME_TBD, 8, 288),/* const Struct_B o[4];*/
169 /* } */
170
171 /* struct B { */ /* [4] */
172 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
173 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
174 BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
175 /* } */
176
177 /* const int */ /* [5] */
178 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
179 /* typedef struct b Struct_B */ /* [6] */
180 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 4),
181 /* const Struct_B */ /* [7] */
182 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 6),
183 /* const Struct_B [4] */ /* [8] */
184 BTF_TYPE_ARRAY_ENC(7, 1, 4),
185 BTF_END_RAW,
186 },
187 .str_sec = "\0A\0m\0n\0o\0B\0m\0n\0Struct_B",
188 .str_sec_size = sizeof("\0A\0m\0n\0o\0B\0m\0n\0Struct_B"),
189 .map_type = BPF_MAP_TYPE_ARRAY,
190 .map_name = "struct_test2_map",
191 .key_size = sizeof(int),
192 .value_size = 68,
193 .key_type_id = 1,
194 .value_type_id = 3,
195 .max_entries = 4,
196 },
197 {
198 .descr = "struct test #3 Invalid member offset",
199 .raw_types = {
200 /* int */ /* [1] */
201 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
202 /* int64 */ /* [2] */
203 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8),
204
205 /* struct A { */ /* [3] */
206 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 16),
207 BTF_MEMBER_ENC(NAME_TBD, 1, 64), /* int m; */
208 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* int64 n; */
209 /* } */
210 BTF_END_RAW,
211 },
212 .str_sec = "\0A\0m\0n\0",
213 .str_sec_size = sizeof("\0A\0m\0n\0"),
214 .map_type = BPF_MAP_TYPE_ARRAY,
215 .map_name = "struct_test3_map",
216 .key_size = sizeof(int),
217 .value_size = 16,
218 .key_type_id = 1,
219 .value_type_id = 3,
220 .max_entries = 4,
221 .btf_load_err = true,
222 .err_str = "Invalid member bits_offset",
223 },
224 /*
225 * struct A {
226 * unsigned long long m;
227 * int n;
228 * char o;
229 * [3 bytes hole]
230 * int p[8];
231 * };
232 */
233 {
234 .descr = "global data test #1",
235 .raw_types = {
236 /* int */
237 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
238 /* unsigned long long */
239 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
240 /* char */
241 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
242 /* int[8] */
243 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
244 /* struct A { */ /* [5] */
245 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
246 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
247 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
248 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
249 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
250 /* } */
251 BTF_END_RAW,
252 },
253 .str_sec = "\0A\0m\0n\0o\0p",
254 .str_sec_size = sizeof("\0A\0m\0n\0o\0p"),
255 .map_type = BPF_MAP_TYPE_ARRAY,
256 .map_name = "struct_test1_map",
257 .key_size = sizeof(int),
258 .value_size = 48,
259 .key_type_id = 1,
260 .value_type_id = 5,
261 .max_entries = 4,
262 },
263 /*
264 * struct A {
265 * unsigned long long m;
266 * int n;
267 * char o;
268 * [3 bytes hole]
269 * int p[8];
270 * };
271 * static struct A t; <- in .bss
272 */
273 {
274 .descr = "global data test #2",
275 .raw_types = {
276 /* int */
277 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
278 /* unsigned long long */
279 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
280 /* char */
281 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
282 /* int[8] */
283 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
284 /* struct A { */ /* [5] */
285 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
286 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
287 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
288 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
289 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
290 /* } */
291 /* static struct A t */
292 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
293 /* .bss section */ /* [7] */
294 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 48),
295 BTF_VAR_SECINFO_ENC(6, 0, 48),
296 BTF_END_RAW,
297 },
298 .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
299 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
300 .map_type = BPF_MAP_TYPE_ARRAY,
301 .map_name = ".bss",
302 .key_size = sizeof(int),
303 .value_size = 48,
304 .key_type_id = 0,
305 .value_type_id = 7,
306 .max_entries = 1,
307 },
308 {
309 .descr = "global data test #3",
310 .raw_types = {
311 /* int */
312 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
313 /* static int t */
314 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
315 /* .bss section */ /* [3] */
316 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
317 BTF_VAR_SECINFO_ENC(2, 0, 4),
318 BTF_END_RAW,
319 },
320 .str_sec = "\0t\0.bss",
321 .str_sec_size = sizeof("\0t\0.bss"),
322 .map_type = BPF_MAP_TYPE_ARRAY,
323 .map_name = ".bss",
324 .key_size = sizeof(int),
325 .value_size = 4,
326 .key_type_id = 0,
327 .value_type_id = 3,
328 .max_entries = 1,
329 },
330 {
331 .descr = "global data test #4, unsupported linkage",
332 .raw_types = {
333 /* int */
334 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
335 /* static int t */
336 BTF_VAR_ENC(NAME_TBD, 1, 2), /* [2] */
337 /* .bss section */ /* [3] */
338 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
339 BTF_VAR_SECINFO_ENC(2, 0, 4),
340 BTF_END_RAW,
341 },
342 .str_sec = "\0t\0.bss",
343 .str_sec_size = sizeof("\0t\0.bss"),
344 .map_type = BPF_MAP_TYPE_ARRAY,
345 .map_name = ".bss",
346 .key_size = sizeof(int),
347 .value_size = 4,
348 .key_type_id = 0,
349 .value_type_id = 3,
350 .max_entries = 1,
351 .btf_load_err = true,
352 .err_str = "Linkage not supported",
353 },
354 {
355 .descr = "global data test #5, invalid var type",
356 .raw_types = {
357 /* static void t */
358 BTF_VAR_ENC(NAME_TBD, 0, 0), /* [1] */
359 /* .bss section */ /* [2] */
360 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
361 BTF_VAR_SECINFO_ENC(1, 0, 4),
362 BTF_END_RAW,
363 },
364 .str_sec = "\0t\0.bss",
365 .str_sec_size = sizeof("\0t\0.bss"),
366 .map_type = BPF_MAP_TYPE_ARRAY,
367 .map_name = ".bss",
368 .key_size = sizeof(int),
369 .value_size = 4,
370 .key_type_id = 0,
371 .value_type_id = 2,
372 .max_entries = 1,
373 .btf_load_err = true,
374 .err_str = "Invalid type_id",
375 },
376 {
377 .descr = "global data test #6, invalid var type (fwd type)",
378 .raw_types = {
379 /* union A */
380 BTF_TYPE_ENC(NAME_TBD,
381 BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [1] */
382 /* static union A t */
383 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
384 /* .bss section */ /* [3] */
385 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
386 BTF_VAR_SECINFO_ENC(2, 0, 4),
387 BTF_END_RAW,
388 },
389 .str_sec = "\0A\0t\0.bss",
390 .str_sec_size = sizeof("\0A\0t\0.bss"),
391 .map_type = BPF_MAP_TYPE_ARRAY,
392 .map_name = ".bss",
393 .key_size = sizeof(int),
394 .value_size = 4,
395 .key_type_id = 0,
396 .value_type_id = 2,
397 .max_entries = 1,
398 .btf_load_err = true,
399 .err_str = "Invalid type",
400 },
401 {
402 .descr = "global data test #7, invalid var type (fwd type)",
403 .raw_types = {
404 /* union A */
405 BTF_TYPE_ENC(NAME_TBD,
406 BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [1] */
407 /* static union A t */
408 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
409 /* .bss section */ /* [3] */
410 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
411 BTF_VAR_SECINFO_ENC(1, 0, 4),
412 BTF_END_RAW,
413 },
414 .str_sec = "\0A\0t\0.bss",
415 .str_sec_size = sizeof("\0A\0t\0.bss"),
416 .map_type = BPF_MAP_TYPE_ARRAY,
417 .map_name = ".bss",
418 .key_size = sizeof(int),
419 .value_size = 4,
420 .key_type_id = 0,
421 .value_type_id = 2,
422 .max_entries = 1,
423 .btf_load_err = true,
424 .err_str = "Invalid type",
425 },
426 {
427 .descr = "global data test #8, invalid var size",
428 .raw_types = {
429 /* int */
430 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
431 /* unsigned long long */
432 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
433 /* char */
434 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
435 /* int[8] */
436 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
437 /* struct A { */ /* [5] */
438 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
439 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
440 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
441 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
442 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
443 /* } */
444 /* static struct A t */
445 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
446 /* .bss section */ /* [7] */
447 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 48),
448 BTF_VAR_SECINFO_ENC(6, 0, 47),
449 BTF_END_RAW,
450 },
451 .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
452 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
453 .map_type = BPF_MAP_TYPE_ARRAY,
454 .map_name = ".bss",
455 .key_size = sizeof(int),
456 .value_size = 48,
457 .key_type_id = 0,
458 .value_type_id = 7,
459 .max_entries = 1,
460 .btf_load_err = true,
461 .err_str = "Invalid size",
462 },
463 {
464 .descr = "global data test #9, invalid var size",
465 .raw_types = {
466 /* int */
467 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
468 /* unsigned long long */
469 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
470 /* char */
471 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
472 /* int[8] */
473 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
474 /* struct A { */ /* [5] */
475 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
476 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
477 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
478 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
479 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
480 /* } */
481 /* static struct A t */
482 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
483 /* .bss section */ /* [7] */
484 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 46),
485 BTF_VAR_SECINFO_ENC(6, 0, 48),
486 BTF_END_RAW,
487 },
488 .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
489 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
490 .map_type = BPF_MAP_TYPE_ARRAY,
491 .map_name = ".bss",
492 .key_size = sizeof(int),
493 .value_size = 48,
494 .key_type_id = 0,
495 .value_type_id = 7,
496 .max_entries = 1,
497 .btf_load_err = true,
498 .err_str = "Invalid size",
499 },
500 {
501 .descr = "global data test #10, invalid var size",
502 .raw_types = {
503 /* int */
504 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
505 /* unsigned long long */
506 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
507 /* char */
508 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
509 /* int[8] */
510 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
511 /* struct A { */ /* [5] */
512 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
513 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
514 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
515 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
516 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
517 /* } */
518 /* static struct A t */
519 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
520 /* .bss section */ /* [7] */
521 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 46),
522 BTF_VAR_SECINFO_ENC(6, 0, 46),
523 BTF_END_RAW,
524 },
525 .str_sec = "\0A\0m\0n\0o\0p\0t\0.bss",
526 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0.bss"),
527 .map_type = BPF_MAP_TYPE_ARRAY,
528 .map_name = ".bss",
529 .key_size = sizeof(int),
530 .value_size = 48,
531 .key_type_id = 0,
532 .value_type_id = 7,
533 .max_entries = 1,
534 .btf_load_err = true,
535 .err_str = "Invalid size",
536 },
537 {
538 .descr = "global data test #11, multiple section members",
539 .raw_types = {
540 /* int */
541 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
542 /* unsigned long long */
543 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
544 /* char */
545 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
546 /* int[8] */
547 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
548 /* struct A { */ /* [5] */
549 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
550 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
551 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
552 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
553 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
554 /* } */
555 /* static struct A t */
556 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
557 /* static int u */
558 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [7] */
559 /* .bss section */ /* [8] */
560 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
561 BTF_VAR_SECINFO_ENC(6, 10, 48),
562 BTF_VAR_SECINFO_ENC(7, 58, 4),
563 BTF_END_RAW,
564 },
565 .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
566 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
567 .map_type = BPF_MAP_TYPE_ARRAY,
568 .map_name = ".bss",
569 .key_size = sizeof(int),
570 .value_size = 62,
571 .key_type_id = 0,
572 .value_type_id = 8,
573 .max_entries = 1,
574 },
575 {
576 .descr = "global data test #12, invalid offset",
577 .raw_types = {
578 /* int */
579 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
580 /* unsigned long long */
581 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
582 /* char */
583 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
584 /* int[8] */
585 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
586 /* struct A { */ /* [5] */
587 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
588 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
589 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
590 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
591 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
592 /* } */
593 /* static struct A t */
594 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
595 /* static int u */
596 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [7] */
597 /* .bss section */ /* [8] */
598 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
599 BTF_VAR_SECINFO_ENC(6, 10, 48),
600 BTF_VAR_SECINFO_ENC(7, 60, 4),
601 BTF_END_RAW,
602 },
603 .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
604 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
605 .map_type = BPF_MAP_TYPE_ARRAY,
606 .map_name = ".bss",
607 .key_size = sizeof(int),
608 .value_size = 62,
609 .key_type_id = 0,
610 .value_type_id = 8,
611 .max_entries = 1,
612 .btf_load_err = true,
613 .err_str = "Invalid offset+size",
614 },
615 {
616 .descr = "global data test #13, invalid offset",
617 .raw_types = {
618 /* int */
619 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
620 /* unsigned long long */
621 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
622 /* char */
623 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
624 /* int[8] */
625 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
626 /* struct A { */ /* [5] */
627 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
628 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
629 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
630 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
631 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
632 /* } */
633 /* static struct A t */
634 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
635 /* static int u */
636 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [7] */
637 /* .bss section */ /* [8] */
638 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
639 BTF_VAR_SECINFO_ENC(6, 10, 48),
640 BTF_VAR_SECINFO_ENC(7, 12, 4),
641 BTF_END_RAW,
642 },
643 .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
644 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
645 .map_type = BPF_MAP_TYPE_ARRAY,
646 .map_name = ".bss",
647 .key_size = sizeof(int),
648 .value_size = 62,
649 .key_type_id = 0,
650 .value_type_id = 8,
651 .max_entries = 1,
652 .btf_load_err = true,
653 .err_str = "Invalid offset",
654 },
655 {
656 .descr = "global data test #14, invalid offset",
657 .raw_types = {
658 /* int */
659 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
660 /* unsigned long long */
661 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8), /* [2] */
662 /* char */
663 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1), /* [3] */
664 /* int[8] */
665 BTF_TYPE_ARRAY_ENC(1, 1, 8), /* [4] */
666 /* struct A { */ /* [5] */
667 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 4), 48),
668 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
669 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n; */
670 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o; */
671 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8] */
672 /* } */
673 /* static struct A t */
674 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
675 /* static int u */
676 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [7] */
677 /* .bss section */ /* [8] */
678 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2), 62),
679 BTF_VAR_SECINFO_ENC(7, 58, 4),
680 BTF_VAR_SECINFO_ENC(6, 10, 48),
681 BTF_END_RAW,
682 },
683 .str_sec = "\0A\0m\0n\0o\0p\0t\0u\0.bss",
684 .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0t\0u\0.bss"),
685 .map_type = BPF_MAP_TYPE_ARRAY,
686 .map_name = ".bss",
687 .key_size = sizeof(int),
688 .value_size = 62,
689 .key_type_id = 0,
690 .value_type_id = 8,
691 .max_entries = 1,
692 .btf_load_err = true,
693 .err_str = "Invalid offset",
694 },
695 {
696 .descr = "global data test #15, not var kind",
697 .raw_types = {
698 /* int */
699 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
700 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
701 /* .bss section */ /* [3] */
702 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
703 BTF_VAR_SECINFO_ENC(1, 0, 4),
704 BTF_END_RAW,
705 },
706 .str_sec = "\0A\0t\0.bss",
707 .str_sec_size = sizeof("\0A\0t\0.bss"),
708 .map_type = BPF_MAP_TYPE_ARRAY,
709 .map_name = ".bss",
710 .key_size = sizeof(int),
711 .value_size = 4,
712 .key_type_id = 0,
713 .value_type_id = 3,
714 .max_entries = 1,
715 .btf_load_err = true,
716 .err_str = "Not a VAR kind member",
717 },
718 {
719 .descr = "global data test #16, invalid var referencing sec",
720 .raw_types = {
721 /* int */
722 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
723 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [2] */
724 BTF_VAR_ENC(NAME_TBD, 2, 0), /* [3] */
725 /* a section */ /* [4] */
726 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
727 BTF_VAR_SECINFO_ENC(3, 0, 4),
728 /* a section */ /* [5] */
729 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
730 BTF_VAR_SECINFO_ENC(6, 0, 4),
731 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [6] */
732 BTF_END_RAW,
733 },
734 .str_sec = "\0A\0t\0s\0a\0a",
735 .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
736 .map_type = BPF_MAP_TYPE_ARRAY,
737 .map_name = ".bss",
738 .key_size = sizeof(int),
739 .value_size = 4,
740 .key_type_id = 0,
741 .value_type_id = 4,
742 .max_entries = 1,
743 .btf_load_err = true,
744 .err_str = "Invalid type_id",
745 },
746 {
747 .descr = "global data test #17, invalid var referencing var",
748 .raw_types = {
749 /* int */
750 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
751 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
752 BTF_VAR_ENC(NAME_TBD, 2, 0), /* [3] */
753 /* a section */ /* [4] */
754 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
755 BTF_VAR_SECINFO_ENC(3, 0, 4),
756 BTF_END_RAW,
757 },
758 .str_sec = "\0A\0t\0s\0a\0a",
759 .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
760 .map_type = BPF_MAP_TYPE_ARRAY,
761 .map_name = ".bss",
762 .key_size = sizeof(int),
763 .value_size = 4,
764 .key_type_id = 0,
765 .value_type_id = 4,
766 .max_entries = 1,
767 .btf_load_err = true,
768 .err_str = "Invalid type_id",
769 },
770 {
771 .descr = "global data test #18, invalid var loop",
772 .raw_types = {
773 /* int */
774 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
775 BTF_VAR_ENC(NAME_TBD, 2, 0), /* [2] */
776 /* .bss section */ /* [3] */
777 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
778 BTF_VAR_SECINFO_ENC(2, 0, 4),
779 BTF_END_RAW,
780 },
781 .str_sec = "\0A\0t\0aaa",
782 .str_sec_size = sizeof("\0A\0t\0aaa"),
783 .map_type = BPF_MAP_TYPE_ARRAY,
784 .map_name = ".bss",
785 .key_size = sizeof(int),
786 .value_size = 4,
787 .key_type_id = 0,
788 .value_type_id = 4,
789 .max_entries = 1,
790 .btf_load_err = true,
791 .err_str = "Invalid type_id",
792 },
793 {
794 .descr = "global data test #19, invalid var referencing var",
795 .raw_types = {
796 /* int */
797 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
798 BTF_VAR_ENC(NAME_TBD, 3, 0), /* [2] */
799 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [3] */
800 BTF_END_RAW,
801 },
802 .str_sec = "\0A\0t\0s\0a\0a",
803 .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
804 .map_type = BPF_MAP_TYPE_ARRAY,
805 .map_name = ".bss",
806 .key_size = sizeof(int),
807 .value_size = 4,
808 .key_type_id = 0,
809 .value_type_id = 4,
810 .max_entries = 1,
811 .btf_load_err = true,
812 .err_str = "Invalid type_id",
813 },
814 {
815 .descr = "global data test #20, invalid ptr referencing var",
816 .raw_types = {
817 /* int */
818 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
819 /* PTR type_id=3 */ /* [2] */
820 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 3),
821 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [3] */
822 BTF_END_RAW,
823 },
824 .str_sec = "\0A\0t\0s\0a\0a",
825 .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
826 .map_type = BPF_MAP_TYPE_ARRAY,
827 .map_name = ".bss",
828 .key_size = sizeof(int),
829 .value_size = 4,
830 .key_type_id = 0,
831 .value_type_id = 4,
832 .max_entries = 1,
833 .btf_load_err = true,
834 .err_str = "Invalid type_id",
835 },
836 {
837 .descr = "global data test #21, var included in struct",
838 .raw_types = {
839 /* int */
840 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
841 /* struct A { */ /* [2] */
842 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2),
843 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
844 BTF_MEMBER_ENC(NAME_TBD, 3, 32),/* VAR type_id=3; */
845 /* } */
846 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [3] */
847 BTF_END_RAW,
848 },
849 .str_sec = "\0A\0t\0s\0a\0a",
850 .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
851 .map_type = BPF_MAP_TYPE_ARRAY,
852 .map_name = ".bss",
853 .key_size = sizeof(int),
854 .value_size = 4,
855 .key_type_id = 0,
856 .value_type_id = 4,
857 .max_entries = 1,
858 .btf_load_err = true,
859 .err_str = "Invalid member",
860 },
861 {
862 .descr = "global data test #22, array of var",
863 .raw_types = {
864 /* int */
865 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
866 BTF_TYPE_ARRAY_ENC(3, 1, 4), /* [2] */
867 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [3] */
868 BTF_END_RAW,
869 },
870 .str_sec = "\0A\0t\0s\0a\0a",
871 .str_sec_size = sizeof("\0A\0t\0s\0a\0a"),
872 .map_type = BPF_MAP_TYPE_ARRAY,
873 .map_name = ".bss",
874 .key_size = sizeof(int),
875 .value_size = 4,
876 .key_type_id = 0,
877 .value_type_id = 4,
878 .max_entries = 1,
879 .btf_load_err = true,
880 .err_str = "Invalid elem",
881 },
882 {
883 .descr = "var after datasec, ptr followed by modifier",
884 .raw_types = {
885 /* .bss section */ /* [1] */
886 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 2),
887 sizeof(void*)+4),
888 BTF_VAR_SECINFO_ENC(4, 0, sizeof(void*)),
889 BTF_VAR_SECINFO_ENC(6, sizeof(void*), 4),
890 /* int */ /* [2] */
891 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
892 /* int* */ /* [3] */
893 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
894 BTF_VAR_ENC(NAME_TBD, 3, 0), /* [4] */
895 /* const int */ /* [5] */
896 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
897 BTF_VAR_ENC(NAME_TBD, 5, 0), /* [6] */
898 BTF_END_RAW,
899 },
900 .str_sec = "\0a\0b\0c\0",
901 .str_sec_size = sizeof("\0a\0b\0c\0"),
902 .map_type = BPF_MAP_TYPE_ARRAY,
903 .map_name = ".bss",
904 .key_size = sizeof(int),
905 .value_size = sizeof(void*)+4,
906 .key_type_id = 0,
907 .value_type_id = 1,
908 .max_entries = 1,
909 },
910 /* Test member exceeds the size of struct.
911 *
912 * struct A {
913 * int m;
914 * int n;
915 * };
916 */
917 {
918 .descr = "size check test #1",
919 .raw_types = {
920 /* int */ /* [1] */
921 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
922 /* struct A { */ /* [2] */
923 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 - 1),
924 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
925 BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
926 /* } */
927 BTF_END_RAW,
928 },
929 .str_sec = "\0A\0m\0n",
930 .str_sec_size = sizeof("\0A\0m\0n"),
931 .map_type = BPF_MAP_TYPE_ARRAY,
932 .map_name = "size_check1_map",
933 .key_size = sizeof(int),
934 .value_size = 1,
935 .key_type_id = 1,
936 .value_type_id = 2,
937 .max_entries = 4,
938 .btf_load_err = true,
939 .err_str = "Member exceeds struct_size",
940 },
941
942 /* Test member exceeds the size of struct
943 *
944 * struct A {
945 * int m;
946 * int n[2];
947 * };
948 */
949 {
950 .descr = "size check test #2",
951 .raw_types = {
952 /* int */ /* [1] */
953 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
954 /* int[2] */ /* [2] */
955 BTF_TYPE_ARRAY_ENC(1, 1, 2),
956 /* struct A { */ /* [3] */
957 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 3 - 1),
958 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
959 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* int n[2]; */
960 /* } */
961 BTF_END_RAW,
962 },
963 .str_sec = "\0A\0m\0n",
964 .str_sec_size = sizeof("\0A\0m\0n"),
965 .map_type = BPF_MAP_TYPE_ARRAY,
966 .map_name = "size_check2_map",
967 .key_size = sizeof(int),
968 .value_size = 1,
969 .key_type_id = 1,
970 .value_type_id = 3,
971 .max_entries = 4,
972 .btf_load_err = true,
973 .err_str = "Member exceeds struct_size",
974 },
975
976 /* Test member exceeds the size of struct
977 *
978 * struct A {
979 * int m;
980 * void *n;
981 * };
982 */
983 {
984 .descr = "size check test #3",
985 .raw_types = {
986 /* int */ /* [1] */
987 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
988 /* void* */ /* [2] */
989 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
990 /* struct A { */ /* [3] */
991 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) + sizeof(void *) - 1),
992 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
993 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* void *n; */
994 /* } */
995 BTF_END_RAW,
996 },
997 .str_sec = "\0A\0m\0n",
998 .str_sec_size = sizeof("\0A\0m\0n"),
999 .map_type = BPF_MAP_TYPE_ARRAY,
1000 .map_name = "size_check3_map",
1001 .key_size = sizeof(int),
1002 .value_size = 1,
1003 .key_type_id = 1,
1004 .value_type_id = 3,
1005 .max_entries = 4,
1006 .btf_load_err = true,
1007 .err_str = "Member exceeds struct_size",
1008 },
1009
1010 /* Test member exceeds the size of struct
1011 *
1012 * enum E {
1013 * E0,
1014 * E1,
1015 * };
1016 *
1017 * struct A {
1018 * int m;
1019 * enum E n;
1020 * };
1021 */
1022 {
1023 .descr = "size check test #4",
1024 .raw_types = {
1025 /* int */ /* [1] */
1026 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
1027 /* enum E { */ /* [2] */
1028 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
1029 BTF_ENUM_ENC(NAME_TBD, 0),
1030 BTF_ENUM_ENC(NAME_TBD, 1),
1031 /* } */
1032 /* struct A { */ /* [3] */
1033 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 - 1),
1034 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
1035 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* enum E n; */
1036 /* } */
1037 BTF_END_RAW,
1038 },
1039 .str_sec = "\0E\0E0\0E1\0A\0m\0n",
1040 .str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
1041 .map_type = BPF_MAP_TYPE_ARRAY,
1042 .map_name = "size_check4_map",
1043 .key_size = sizeof(int),
1044 .value_size = 1,
1045 .key_type_id = 1,
1046 .value_type_id = 3,
1047 .max_entries = 4,
1048 .btf_load_err = true,
1049 .err_str = "Member exceeds struct_size",
1050 },
1051
1052 /* Test member unexceeds the size of struct
1053 *
1054 * enum E {
1055 * E0,
1056 * E1,
1057 * };
1058 *
1059 * struct A {
1060 * char m;
1061 * enum E __attribute__((packed)) n;
1062 * };
1063 */
1064 {
1065 .descr = "size check test #5",
1066 .raw_types = {
1067 /* int */ /* [1] */
1068 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
1069 /* char */ /* [2] */
1070 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),
1071 /* enum E { */ /* [3] */
1072 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 1),
1073 BTF_ENUM_ENC(NAME_TBD, 0),
1074 BTF_ENUM_ENC(NAME_TBD, 1),
1075 /* } */
1076 /* struct A { */ /* [4] */
1077 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 2),
1078 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* char m; */
1079 BTF_MEMBER_ENC(NAME_TBD, 3, 8),/* enum E __attribute__((packed)) n; */
1080 /* } */
1081 BTF_END_RAW,
1082 },
1083 .str_sec = "\0E\0E0\0E1\0A\0m\0n",
1084 .str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
1085 .map_type = BPF_MAP_TYPE_ARRAY,
1086 .map_name = "size_check5_map",
1087 .key_size = sizeof(int),
1088 .value_size = 2,
1089 .key_type_id = 1,
1090 .value_type_id = 4,
1091 .max_entries = 4,
1092 },
1093
1094 /* typedef const void * const_void_ptr;
1095 * struct A {
1096 * const_void_ptr m;
1097 * };
1098 */
1099 {
1100 .descr = "void test #1",
1101 .raw_types = {
1102 /* int */ /* [1] */
1103 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1104 /* const void */ /* [2] */
1105 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1106 /* const void* */ /* [3] */
1107 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
1108 /* typedef const void * const_void_ptr */
1109 BTF_TYPEDEF_ENC(NAME_TBD, 3), /* [4] */
1110 /* struct A { */ /* [5] */
1111 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1112 /* const_void_ptr m; */
1113 BTF_MEMBER_ENC(NAME_TBD, 4, 0),
1114 /* } */
1115 BTF_END_RAW,
1116 },
1117 .str_sec = "\0const_void_ptr\0A\0m",
1118 .str_sec_size = sizeof("\0const_void_ptr\0A\0m"),
1119 .map_type = BPF_MAP_TYPE_ARRAY,
1120 .map_name = "void_test1_map",
1121 .key_size = sizeof(int),
1122 .value_size = sizeof(void *),
1123 .key_type_id = 1,
1124 .value_type_id = 4,
1125 .max_entries = 4,
1126 },
1127
1128 /* struct A {
1129 * const void m;
1130 * };
1131 */
1132 {
1133 .descr = "void test #2",
1134 .raw_types = {
1135 /* int */ /* [1] */
1136 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1137 /* const void */ /* [2] */
1138 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1139 /* struct A { */ /* [3] */
1140 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 8),
1141 /* const void m; */
1142 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
1143 /* } */
1144 BTF_END_RAW,
1145 },
1146 .str_sec = "\0A\0m",
1147 .str_sec_size = sizeof("\0A\0m"),
1148 .map_type = BPF_MAP_TYPE_ARRAY,
1149 .map_name = "void_test2_map",
1150 .key_size = sizeof(int),
1151 .value_size = sizeof(void *),
1152 .key_type_id = 1,
1153 .value_type_id = 3,
1154 .max_entries = 4,
1155 .btf_load_err = true,
1156 .err_str = "Invalid member",
1157 },
1158
1159 /* typedef const void * const_void_ptr;
1160 * const_void_ptr[4]
1161 */
1162 {
1163 .descr = "void test #3",
1164 .raw_types = {
1165 /* int */ /* [1] */
1166 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1167 /* const void */ /* [2] */
1168 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1169 /* const void* */ /* [3] */
1170 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
1171 /* typedef const void * const_void_ptr */
1172 BTF_TYPEDEF_ENC(NAME_TBD, 3), /* [4] */
1173 /* const_void_ptr[4] */
1174 BTF_TYPE_ARRAY_ENC(4, 1, 4), /* [5] */
1175 BTF_END_RAW,
1176 },
1177 .str_sec = "\0const_void_ptr",
1178 .str_sec_size = sizeof("\0const_void_ptr"),
1179 .map_type = BPF_MAP_TYPE_ARRAY,
1180 .map_name = "void_test3_map",
1181 .key_size = sizeof(int),
1182 .value_size = sizeof(void *) * 4,
1183 .key_type_id = 1,
1184 .value_type_id = 5,
1185 .max_entries = 4,
1186 },
1187
1188 /* const void[4] */
1189 {
1190 .descr = "void test #4",
1191 .raw_types = {
1192 /* int */ /* [1] */
1193 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1194 /* const void */ /* [2] */
1195 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1196 /* const void[4] */ /* [3] */
1197 BTF_TYPE_ARRAY_ENC(2, 1, 4),
1198 BTF_END_RAW,
1199 },
1200 .str_sec = "\0A\0m",
1201 .str_sec_size = sizeof("\0A\0m"),
1202 .map_type = BPF_MAP_TYPE_ARRAY,
1203 .map_name = "void_test4_map",
1204 .key_size = sizeof(int),
1205 .value_size = sizeof(void *) * 4,
1206 .key_type_id = 1,
1207 .value_type_id = 3,
1208 .max_entries = 4,
1209 .btf_load_err = true,
1210 .err_str = "Invalid elem",
1211 },
1212
1213 /* Array_A <------------------+
1214 * elem_type == Array_B |
1215 * | |
1216 * | |
1217 * Array_B <-------- + |
1218 * elem_type == Array A --+
1219 */
1220 {
1221 .descr = "loop test #1",
1222 .raw_types = {
1223 /* int */ /* [1] */
1224 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1225 /* Array_A */ /* [2] */
1226 BTF_TYPE_ARRAY_ENC(3, 1, 8),
1227 /* Array_B */ /* [3] */
1228 BTF_TYPE_ARRAY_ENC(2, 1, 8),
1229 BTF_END_RAW,
1230 },
1231 .str_sec = "",
1232 .str_sec_size = sizeof(""),
1233 .map_type = BPF_MAP_TYPE_ARRAY,
1234 .map_name = "loop_test1_map",
1235 .key_size = sizeof(int),
1236 .value_size = sizeof(sizeof(int) * 8),
1237 .key_type_id = 1,
1238 .value_type_id = 2,
1239 .max_entries = 4,
1240 .btf_load_err = true,
1241 .err_str = "Loop detected",
1242 },
1243
1244 /* typedef is _before_ the BTF type of Array_A and Array_B
1245 *
1246 * typedef Array_B int_array;
1247 *
1248 * Array_A <------------------+
1249 * elem_type == int_array |
1250 * | |
1251 * | |
1252 * Array_B <-------- + |
1253 * elem_type == Array_A --+
1254 */
1255 {
1256 .descr = "loop test #2",
1257 .raw_types = {
1258 /* int */
1259 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
1260 /* typedef Array_B int_array */
1261 BTF_TYPEDEF_ENC(1, 4), /* [2] */
1262 /* Array_A */
1263 BTF_TYPE_ARRAY_ENC(2, 1, 8), /* [3] */
1264 /* Array_B */
1265 BTF_TYPE_ARRAY_ENC(3, 1, 8), /* [4] */
1266 BTF_END_RAW,
1267 },
1268 .str_sec = "\0int_array\0",
1269 .str_sec_size = sizeof("\0int_array"),
1270 .map_type = BPF_MAP_TYPE_ARRAY,
1271 .map_name = "loop_test2_map",
1272 .key_size = sizeof(int),
1273 .value_size = sizeof(sizeof(int) * 8),
1274 .key_type_id = 1,
1275 .value_type_id = 2,
1276 .max_entries = 4,
1277 .btf_load_err = true,
1278 .err_str = "Loop detected",
1279 },
1280
1281 /* Array_A <------------------+
1282 * elem_type == Array_B |
1283 * | |
1284 * | |
1285 * Array_B <-------- + |
1286 * elem_type == Array_A --+
1287 */
1288 {
1289 .descr = "loop test #3",
1290 .raw_types = {
1291 /* int */ /* [1] */
1292 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1293 /* Array_A */ /* [2] */
1294 BTF_TYPE_ARRAY_ENC(3, 1, 8),
1295 /* Array_B */ /* [3] */
1296 BTF_TYPE_ARRAY_ENC(2, 1, 8),
1297 BTF_END_RAW,
1298 },
1299 .str_sec = "",
1300 .str_sec_size = sizeof(""),
1301 .map_type = BPF_MAP_TYPE_ARRAY,
1302 .map_name = "loop_test3_map",
1303 .key_size = sizeof(int),
1304 .value_size = sizeof(sizeof(int) * 8),
1305 .key_type_id = 1,
1306 .value_type_id = 2,
1307 .max_entries = 4,
1308 .btf_load_err = true,
1309 .err_str = "Loop detected",
1310 },
1311
1312 /* typedef is _between_ the BTF type of Array_A and Array_B
1313 *
1314 * typedef Array_B int_array;
1315 *
1316 * Array_A <------------------+
1317 * elem_type == int_array |
1318 * | |
1319 * | |
1320 * Array_B <-------- + |
1321 * elem_type == Array_A --+
1322 */
1323 {
1324 .descr = "loop test #4",
1325 .raw_types = {
1326 /* int */ /* [1] */
1327 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1328 /* Array_A */ /* [2] */
1329 BTF_TYPE_ARRAY_ENC(3, 1, 8),
1330 /* typedef Array_B int_array */ /* [3] */
1331 BTF_TYPEDEF_ENC(NAME_TBD, 4),
1332 /* Array_B */ /* [4] */
1333 BTF_TYPE_ARRAY_ENC(2, 1, 8),
1334 BTF_END_RAW,
1335 },
1336 .str_sec = "\0int_array\0",
1337 .str_sec_size = sizeof("\0int_array"),
1338 .map_type = BPF_MAP_TYPE_ARRAY,
1339 .map_name = "loop_test4_map",
1340 .key_size = sizeof(int),
1341 .value_size = sizeof(sizeof(int) * 8),
1342 .key_type_id = 1,
1343 .value_type_id = 2,
1344 .max_entries = 4,
1345 .btf_load_err = true,
1346 .err_str = "Loop detected",
1347 },
1348
1349 /* typedef struct B Struct_B
1350 *
1351 * struct A {
1352 * int x;
1353 * Struct_B y;
1354 * };
1355 *
1356 * struct B {
1357 * int x;
1358 * struct A y;
1359 * };
1360 */
1361 {
1362 .descr = "loop test #5",
1363 .raw_types = {
1364 /* int */
1365 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
1366 /* struct A */ /* [2] */
1367 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
1368 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x; */
1369 BTF_MEMBER_ENC(NAME_TBD, 3, 32),/* Struct_B y; */
1370 /* typedef struct B Struct_B */
1371 BTF_TYPEDEF_ENC(NAME_TBD, 4), /* [3] */
1372 /* struct B */ /* [4] */
1373 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
1374 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x; */
1375 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A y; */
1376 BTF_END_RAW,
1377 },
1378 .str_sec = "\0A\0x\0y\0Struct_B\0B\0x\0y",
1379 .str_sec_size = sizeof("\0A\0x\0y\0Struct_B\0B\0x\0y"),
1380 .map_type = BPF_MAP_TYPE_ARRAY,
1381 .map_name = "loop_test5_map",
1382 .key_size = sizeof(int),
1383 .value_size = 8,
1384 .key_type_id = 1,
1385 .value_type_id = 2,
1386 .max_entries = 4,
1387 .btf_load_err = true,
1388 .err_str = "Loop detected",
1389 },
1390
1391 /* struct A {
1392 * int x;
1393 * struct A array_a[4];
1394 * };
1395 */
1396 {
1397 .descr = "loop test #6",
1398 .raw_types = {
1399 /* int */
1400 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
1401 BTF_TYPE_ARRAY_ENC(3, 1, 4), /* [2] */
1402 /* struct A */ /* [3] */
1403 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
1404 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x; */
1405 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A array_a[4]; */
1406 BTF_END_RAW,
1407 },
1408 .str_sec = "\0A\0x\0y",
1409 .str_sec_size = sizeof("\0A\0x\0y"),
1410 .map_type = BPF_MAP_TYPE_ARRAY,
1411 .map_name = "loop_test6_map",
1412 .key_size = sizeof(int),
1413 .value_size = 8,
1414 .key_type_id = 1,
1415 .value_type_id = 2,
1416 .max_entries = 4,
1417 .btf_load_err = true,
1418 .err_str = "Loop detected",
1419 },
1420
1421 {
1422 .descr = "loop test #7",
1423 .raw_types = {
1424 /* int */ /* [1] */
1425 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1426 /* struct A { */ /* [2] */
1427 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1428 /* const void *m; */
1429 BTF_MEMBER_ENC(NAME_TBD, 3, 0),
1430 /* CONST type_id=3 */ /* [3] */
1431 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1432 /* PTR type_id=2 */ /* [4] */
1433 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 3),
1434 BTF_END_RAW,
1435 },
1436 .str_sec = "\0A\0m",
1437 .str_sec_size = sizeof("\0A\0m"),
1438 .map_type = BPF_MAP_TYPE_ARRAY,
1439 .map_name = "loop_test7_map",
1440 .key_size = sizeof(int),
1441 .value_size = sizeof(void *),
1442 .key_type_id = 1,
1443 .value_type_id = 2,
1444 .max_entries = 4,
1445 .btf_load_err = true,
1446 .err_str = "Loop detected",
1447 },
1448
1449 {
1450 .descr = "loop test #8",
1451 .raw_types = {
1452 /* int */ /* [1] */
1453 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1454 /* struct A { */ /* [2] */
1455 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1456 /* const void *m; */
1457 BTF_MEMBER_ENC(NAME_TBD, 4, 0),
1458 /* struct B { */ /* [3] */
1459 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
1460 /* const void *n; */
1461 BTF_MEMBER_ENC(NAME_TBD, 6, 0),
1462 /* CONST type_id=5 */ /* [4] */
1463 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 5),
1464 /* PTR type_id=6 */ /* [5] */
1465 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 6),
1466 /* CONST type_id=7 */ /* [6] */
1467 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 7),
1468 /* PTR type_id=4 */ /* [7] */
1469 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 4),
1470 BTF_END_RAW,
1471 },
1472 .str_sec = "\0A\0m\0B\0n",
1473 .str_sec_size = sizeof("\0A\0m\0B\0n"),
1474 .map_type = BPF_MAP_TYPE_ARRAY,
1475 .map_name = "loop_test8_map",
1476 .key_size = sizeof(int),
1477 .value_size = sizeof(void *),
1478 .key_type_id = 1,
1479 .value_type_id = 2,
1480 .max_entries = 4,
1481 .btf_load_err = true,
1482 .err_str = "Loop detected",
1483 },
1484
1485 {
1486 .descr = "string section does not end with null",
1487 .raw_types = {
1488 /* int */ /* [1] */
1489 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1490 BTF_END_RAW,
1491 },
1492 .str_sec = "\0int",
1493 .str_sec_size = sizeof("\0int") - 1,
1494 .map_type = BPF_MAP_TYPE_ARRAY,
1495 .map_name = "hdr_test_map",
1496 .key_size = sizeof(int),
1497 .value_size = sizeof(int),
1498 .key_type_id = 1,
1499 .value_type_id = 1,
1500 .max_entries = 4,
1501 .btf_load_err = true,
1502 .err_str = "Invalid string section",
1503 },
1504
1505 {
1506 .descr = "empty string section",
1507 .raw_types = {
1508 /* int */ /* [1] */
1509 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1510 BTF_END_RAW,
1511 },
1512 .str_sec = "",
1513 .str_sec_size = 0,
1514 .map_type = BPF_MAP_TYPE_ARRAY,
1515 .map_name = "hdr_test_map",
1516 .key_size = sizeof(int),
1517 .value_size = sizeof(int),
1518 .key_type_id = 1,
1519 .value_type_id = 1,
1520 .max_entries = 4,
1521 .btf_load_err = true,
1522 .err_str = "Invalid string section",
1523 },
1524
1525 {
1526 .descr = "empty type section",
1527 .raw_types = {
1528 BTF_END_RAW,
1529 },
1530 .str_sec = "\0int",
1531 .str_sec_size = sizeof("\0int"),
1532 .map_type = BPF_MAP_TYPE_ARRAY,
1533 .map_name = "hdr_test_map",
1534 .key_size = sizeof(int),
1535 .value_size = sizeof(int),
1536 .key_type_id = 1,
1537 .value_type_id = 1,
1538 .max_entries = 4,
1539 .btf_load_err = true,
1540 .err_str = "No type found",
1541 },
1542
1543 {
1544 .descr = "btf_header test. Longer hdr_len",
1545 .raw_types = {
1546 /* int */ /* [1] */
1547 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1548 BTF_END_RAW,
1549 },
1550 .str_sec = "\0int",
1551 .str_sec_size = sizeof("\0int"),
1552 .map_type = BPF_MAP_TYPE_ARRAY,
1553 .map_name = "hdr_test_map",
1554 .key_size = sizeof(int),
1555 .value_size = sizeof(int),
1556 .key_type_id = 1,
1557 .value_type_id = 1,
1558 .max_entries = 4,
1559 .btf_load_err = true,
1560 .hdr_len_delta = 4,
1561 .err_str = "Unsupported btf_header",
1562 },
1563
1564 {
1565 .descr = "btf_header test. Gap between hdr and type",
1566 .raw_types = {
1567 /* int */ /* [1] */
1568 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1569 BTF_END_RAW,
1570 },
1571 .str_sec = "\0int",
1572 .str_sec_size = sizeof("\0int"),
1573 .map_type = BPF_MAP_TYPE_ARRAY,
1574 .map_name = "hdr_test_map",
1575 .key_size = sizeof(int),
1576 .value_size = sizeof(int),
1577 .key_type_id = 1,
1578 .value_type_id = 1,
1579 .max_entries = 4,
1580 .btf_load_err = true,
1581 .type_off_delta = 4,
1582 .err_str = "Unsupported section found",
1583 },
1584
1585 {
1586 .descr = "btf_header test. Gap between type and str",
1587 .raw_types = {
1588 /* int */ /* [1] */
1589 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1590 BTF_END_RAW,
1591 },
1592 .str_sec = "\0int",
1593 .str_sec_size = sizeof("\0int"),
1594 .map_type = BPF_MAP_TYPE_ARRAY,
1595 .map_name = "hdr_test_map",
1596 .key_size = sizeof(int),
1597 .value_size = sizeof(int),
1598 .key_type_id = 1,
1599 .value_type_id = 1,
1600 .max_entries = 4,
1601 .btf_load_err = true,
1602 .str_off_delta = 4,
1603 .err_str = "Unsupported section found",
1604 },
1605
1606 {
1607 .descr = "btf_header test. Overlap between type and str",
1608 .raw_types = {
1609 /* int */ /* [1] */
1610 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1611 BTF_END_RAW,
1612 },
1613 .str_sec = "\0int",
1614 .str_sec_size = sizeof("\0int"),
1615 .map_type = BPF_MAP_TYPE_ARRAY,
1616 .map_name = "hdr_test_map",
1617 .key_size = sizeof(int),
1618 .value_size = sizeof(int),
1619 .key_type_id = 1,
1620 .value_type_id = 1,
1621 .max_entries = 4,
1622 .btf_load_err = true,
1623 .str_off_delta = -4,
1624 .err_str = "Section overlap found",
1625 },
1626
1627 {
1628 .descr = "btf_header test. Larger BTF size",
1629 .raw_types = {
1630 /* int */ /* [1] */
1631 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1632 BTF_END_RAW,
1633 },
1634 .str_sec = "\0int",
1635 .str_sec_size = sizeof("\0int"),
1636 .map_type = BPF_MAP_TYPE_ARRAY,
1637 .map_name = "hdr_test_map",
1638 .key_size = sizeof(int),
1639 .value_size = sizeof(int),
1640 .key_type_id = 1,
1641 .value_type_id = 1,
1642 .max_entries = 4,
1643 .btf_load_err = true,
1644 .str_len_delta = -4,
1645 .err_str = "Unsupported section found",
1646 },
1647
1648 {
1649 .descr = "btf_header test. Smaller BTF size",
1650 .raw_types = {
1651 /* int */ /* [1] */
1652 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
1653 BTF_END_RAW,
1654 },
1655 .str_sec = "\0int",
1656 .str_sec_size = sizeof("\0int"),
1657 .map_type = BPF_MAP_TYPE_ARRAY,
1658 .map_name = "hdr_test_map",
1659 .key_size = sizeof(int),
1660 .value_size = sizeof(int),
1661 .key_type_id = 1,
1662 .value_type_id = 1,
1663 .max_entries = 4,
1664 .btf_load_err = true,
1665 .str_len_delta = 4,
1666 .err_str = "Total section length too long",
1667 },
1668
1669 {
1670 .descr = "array test. index_type/elem_type \"int\"",
1671 .raw_types = {
1672 /* int */ /* [1] */
1673 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1674 /* int[16] */ /* [2] */
1675 BTF_TYPE_ARRAY_ENC(1, 1, 16),
1676 BTF_END_RAW,
1677 },
1678 .str_sec = "",
1679 .str_sec_size = sizeof(""),
1680 .map_type = BPF_MAP_TYPE_ARRAY,
1681 .map_name = "array_test_map",
1682 .key_size = sizeof(int),
1683 .value_size = sizeof(int),
1684 .key_type_id = 1,
1685 .value_type_id = 1,
1686 .max_entries = 4,
1687 },
1688
1689 {
1690 .descr = "array test. index_type/elem_type \"const int\"",
1691 .raw_types = {
1692 /* int */ /* [1] */
1693 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1694 /* int[16] */ /* [2] */
1695 BTF_TYPE_ARRAY_ENC(3, 3, 16),
1696 /* CONST type_id=1 */ /* [3] */
1697 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
1698 BTF_END_RAW,
1699 },
1700 .str_sec = "",
1701 .str_sec_size = sizeof(""),
1702 .map_type = BPF_MAP_TYPE_ARRAY,
1703 .map_name = "array_test_map",
1704 .key_size = sizeof(int),
1705 .value_size = sizeof(int),
1706 .key_type_id = 1,
1707 .value_type_id = 1,
1708 .max_entries = 4,
1709 },
1710
1711 {
1712 .descr = "array test. index_type \"const int:31\"",
1713 .raw_types = {
1714 /* int */ /* [1] */
1715 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1716 /* int:31 */ /* [2] */
1717 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
1718 /* int[16] */ /* [3] */
1719 BTF_TYPE_ARRAY_ENC(1, 4, 16),
1720 /* CONST type_id=2 */ /* [4] */
1721 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
1722 BTF_END_RAW,
1723 },
1724 .str_sec = "",
1725 .str_sec_size = sizeof(""),
1726 .map_type = BPF_MAP_TYPE_ARRAY,
1727 .map_name = "array_test_map",
1728 .key_size = sizeof(int),
1729 .value_size = sizeof(int),
1730 .key_type_id = 1,
1731 .value_type_id = 1,
1732 .max_entries = 4,
1733 .btf_load_err = true,
1734 .err_str = "Invalid index",
1735 },
1736
1737 {
1738 .descr = "array test. elem_type \"const int:31\"",
1739 .raw_types = {
1740 /* int */ /* [1] */
1741 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1742 /* int:31 */ /* [2] */
1743 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
1744 /* int[16] */ /* [3] */
1745 BTF_TYPE_ARRAY_ENC(4, 1, 16),
1746 /* CONST type_id=2 */ /* [4] */
1747 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
1748 BTF_END_RAW,
1749 },
1750 .str_sec = "",
1751 .str_sec_size = sizeof(""),
1752 .map_type = BPF_MAP_TYPE_ARRAY,
1753 .map_name = "array_test_map",
1754 .key_size = sizeof(int),
1755 .value_size = sizeof(int),
1756 .key_type_id = 1,
1757 .value_type_id = 1,
1758 .max_entries = 4,
1759 .btf_load_err = true,
1760 .err_str = "Invalid array of int",
1761 },
1762
1763 {
1764 .descr = "array test. index_type \"void\"",
1765 .raw_types = {
1766 /* int */ /* [1] */
1767 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1768 /* int[16] */ /* [2] */
1769 BTF_TYPE_ARRAY_ENC(1, 0, 16),
1770 BTF_END_RAW,
1771 },
1772 .str_sec = "",
1773 .str_sec_size = sizeof(""),
1774 .map_type = BPF_MAP_TYPE_ARRAY,
1775 .map_name = "array_test_map",
1776 .key_size = sizeof(int),
1777 .value_size = sizeof(int),
1778 .key_type_id = 1,
1779 .value_type_id = 1,
1780 .max_entries = 4,
1781 .btf_load_err = true,
1782 .err_str = "Invalid index",
1783 },
1784
1785 {
1786 .descr = "array test. index_type \"const void\"",
1787 .raw_types = {
1788 /* int */ /* [1] */
1789 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1790 /* int[16] */ /* [2] */
1791 BTF_TYPE_ARRAY_ENC(1, 3, 16),
1792 /* CONST type_id=0 (void) */ /* [3] */
1793 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1794 BTF_END_RAW,
1795 },
1796 .str_sec = "",
1797 .str_sec_size = sizeof(""),
1798 .map_type = BPF_MAP_TYPE_ARRAY,
1799 .map_name = "array_test_map",
1800 .key_size = sizeof(int),
1801 .value_size = sizeof(int),
1802 .key_type_id = 1,
1803 .value_type_id = 1,
1804 .max_entries = 4,
1805 .btf_load_err = true,
1806 .err_str = "Invalid index",
1807 },
1808
1809 {
1810 .descr = "array test. elem_type \"const void\"",
1811 .raw_types = {
1812 /* int */ /* [1] */
1813 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1814 /* int[16] */ /* [2] */
1815 BTF_TYPE_ARRAY_ENC(3, 1, 16),
1816 /* CONST type_id=0 (void) */ /* [3] */
1817 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1818 BTF_END_RAW,
1819 },
1820 .str_sec = "",
1821 .str_sec_size = sizeof(""),
1822 .map_type = BPF_MAP_TYPE_ARRAY,
1823 .map_name = "array_test_map",
1824 .key_size = sizeof(int),
1825 .value_size = sizeof(int),
1826 .key_type_id = 1,
1827 .value_type_id = 1,
1828 .max_entries = 4,
1829 .btf_load_err = true,
1830 .err_str = "Invalid elem",
1831 },
1832
1833 {
1834 .descr = "array test. elem_type \"const void *\"",
1835 .raw_types = {
1836 /* int */ /* [1] */
1837 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1838 /* const void *[16] */ /* [2] */
1839 BTF_TYPE_ARRAY_ENC(3, 1, 16),
1840 /* CONST type_id=4 */ /* [3] */
1841 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1842 /* void* */ /* [4] */
1843 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
1844 BTF_END_RAW,
1845 },
1846 .str_sec = "",
1847 .str_sec_size = sizeof(""),
1848 .map_type = BPF_MAP_TYPE_ARRAY,
1849 .map_name = "array_test_map",
1850 .key_size = sizeof(int),
1851 .value_size = sizeof(int),
1852 .key_type_id = 1,
1853 .value_type_id = 1,
1854 .max_entries = 4,
1855 },
1856
1857 {
1858 .descr = "array test. index_type \"const void *\"",
1859 .raw_types = {
1860 /* int */ /* [1] */
1861 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1862 /* const void *[16] */ /* [2] */
1863 BTF_TYPE_ARRAY_ENC(3, 3, 16),
1864 /* CONST type_id=4 */ /* [3] */
1865 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1866 /* void* */ /* [4] */
1867 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
1868 BTF_END_RAW,
1869 },
1870 .str_sec = "",
1871 .str_sec_size = sizeof(""),
1872 .map_type = BPF_MAP_TYPE_ARRAY,
1873 .map_name = "array_test_map",
1874 .key_size = sizeof(int),
1875 .value_size = sizeof(int),
1876 .key_type_id = 1,
1877 .value_type_id = 1,
1878 .max_entries = 4,
1879 .btf_load_err = true,
1880 .err_str = "Invalid index",
1881 },
1882
1883 {
1884 .descr = "array test. t->size != 0\"",
1885 .raw_types = {
1886 /* int */ /* [1] */
1887 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1888 /* int[16] */ /* [2] */
1889 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 1),
1890 BTF_ARRAY_ENC(1, 1, 16),
1891 BTF_END_RAW,
1892 },
1893 .str_sec = "",
1894 .str_sec_size = sizeof(""),
1895 .map_type = BPF_MAP_TYPE_ARRAY,
1896 .map_name = "array_test_map",
1897 .key_size = sizeof(int),
1898 .value_size = sizeof(int),
1899 .key_type_id = 1,
1900 .value_type_id = 1,
1901 .max_entries = 4,
1902 .btf_load_err = true,
1903 .err_str = "size != 0",
1904 },
1905
1906 {
1907 .descr = "int test. invalid int_data",
1908 .raw_types = {
1909 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), 4),
1910 0x10000000,
1911 BTF_END_RAW,
1912 },
1913 .str_sec = "",
1914 .str_sec_size = sizeof(""),
1915 .map_type = BPF_MAP_TYPE_ARRAY,
1916 .map_name = "array_test_map",
1917 .key_size = sizeof(int),
1918 .value_size = sizeof(int),
1919 .key_type_id = 1,
1920 .value_type_id = 1,
1921 .max_entries = 4,
1922 .btf_load_err = true,
1923 .err_str = "Invalid int_data",
1924 },
1925
1926 {
1927 .descr = "invalid BTF kind",
1928 .raw_types = {
1929 /* int */ /* [1] */
1930 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1931 BTF_TYPE_ENC(0, 0x7f000000, 4),
1932 BTF_END_RAW,
1933 },
1934 .str_sec = "",
1935 .str_sec_size = sizeof(""),
1936 .map_type = BPF_MAP_TYPE_ARRAY,
1937 .map_name = "array_test_map",
1938 .key_size = sizeof(int),
1939 .value_size = sizeof(int),
1940 .key_type_id = 1,
1941 .value_type_id = 1,
1942 .max_entries = 4,
1943 .btf_load_err = true,
1944 .err_str = "Invalid kind",
1945 },
1946
1947 {
1948 .descr = "fwd test. t->type != 0\"",
1949 .raw_types = {
1950 /* int */ /* [1] */
1951 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1952 /* fwd type */ /* [2] */
1953 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 1),
1954 BTF_END_RAW,
1955 },
1956 .str_sec = "",
1957 .str_sec_size = sizeof(""),
1958 .map_type = BPF_MAP_TYPE_ARRAY,
1959 .map_name = "fwd_test_map",
1960 .key_size = sizeof(int),
1961 .value_size = sizeof(int),
1962 .key_type_id = 1,
1963 .value_type_id = 1,
1964 .max_entries = 4,
1965 .btf_load_err = true,
1966 .err_str = "type != 0",
1967 },
1968
1969 {
1970 .descr = "typedef (invalid name, name_off = 0)",
1971 .raw_types = {
1972 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
1973 BTF_TYPEDEF_ENC(0, 1), /* [2] */
1974 BTF_END_RAW,
1975 },
1976 .str_sec = "\0__int",
1977 .str_sec_size = sizeof("\0__int"),
1978 .map_type = BPF_MAP_TYPE_ARRAY,
1979 .map_name = "typedef_check_btf",
1980 .key_size = sizeof(int),
1981 .value_size = sizeof(int),
1982 .key_type_id = 1,
1983 .value_type_id = 1,
1984 .max_entries = 4,
1985 .btf_load_err = true,
1986 .err_str = "Invalid name",
1987 },
1988
1989 {
1990 .descr = "typedef (invalid name, invalid identifier)",
1991 .raw_types = {
1992 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
1993 BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [2] */
1994 BTF_END_RAW,
1995 },
1996 .str_sec = "\0__!int",
1997 .str_sec_size = sizeof("\0__!int"),
1998 .map_type = BPF_MAP_TYPE_ARRAY,
1999 .map_name = "typedef_check_btf",
2000 .key_size = sizeof(int),
2001 .value_size = sizeof(int),
2002 .key_type_id = 1,
2003 .value_type_id = 1,
2004 .max_entries = 4,
2005 .btf_load_err = true,
2006 .err_str = "Invalid name",
2007 },
2008
2009 {
2010 .descr = "ptr type (invalid name, name_off <> 0)",
2011 .raw_types = {
2012 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2013 BTF_TYPE_ENC(NAME_TBD,
2014 BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1), /* [2] */
2015 BTF_END_RAW,
2016 },
2017 .str_sec = "\0__int",
2018 .str_sec_size = sizeof("\0__int"),
2019 .map_type = BPF_MAP_TYPE_ARRAY,
2020 .map_name = "ptr_type_check_btf",
2021 .key_size = sizeof(int),
2022 .value_size = sizeof(int),
2023 .key_type_id = 1,
2024 .value_type_id = 1,
2025 .max_entries = 4,
2026 .btf_load_err = true,
2027 .err_str = "Invalid name",
2028 },
2029
2030 {
2031 .descr = "volatile type (invalid name, name_off <> 0)",
2032 .raw_types = {
2033 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2034 BTF_TYPE_ENC(NAME_TBD,
2035 BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), 1), /* [2] */
2036 BTF_END_RAW,
2037 },
2038 .str_sec = "\0__int",
2039 .str_sec_size = sizeof("\0__int"),
2040 .map_type = BPF_MAP_TYPE_ARRAY,
2041 .map_name = "volatile_type_check_btf",
2042 .key_size = sizeof(int),
2043 .value_size = sizeof(int),
2044 .key_type_id = 1,
2045 .value_type_id = 1,
2046 .max_entries = 4,
2047 .btf_load_err = true,
2048 .err_str = "Invalid name",
2049 },
2050
2051 {
2052 .descr = "const type (invalid name, name_off <> 0)",
2053 .raw_types = {
2054 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2055 BTF_TYPE_ENC(NAME_TBD,
2056 BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1), /* [2] */
2057 BTF_END_RAW,
2058 },
2059 .str_sec = "\0__int",
2060 .str_sec_size = sizeof("\0__int"),
2061 .map_type = BPF_MAP_TYPE_ARRAY,
2062 .map_name = "const_type_check_btf",
2063 .key_size = sizeof(int),
2064 .value_size = sizeof(int),
2065 .key_type_id = 1,
2066 .value_type_id = 1,
2067 .max_entries = 4,
2068 .btf_load_err = true,
2069 .err_str = "Invalid name",
2070 },
2071
2072 {
2073 .descr = "restrict type (invalid name, name_off <> 0)",
2074 .raw_types = {
2075 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2076 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1), /* [2] */
2077 BTF_TYPE_ENC(NAME_TBD,
2078 BTF_INFO_ENC(BTF_KIND_RESTRICT, 0, 0), 2), /* [3] */
2079 BTF_END_RAW,
2080 },
2081 .str_sec = "\0__int",
2082 .str_sec_size = sizeof("\0__int"),
2083 .map_type = BPF_MAP_TYPE_ARRAY,
2084 .map_name = "restrict_type_check_btf",
2085 .key_size = sizeof(int),
2086 .value_size = sizeof(int),
2087 .key_type_id = 1,
2088 .value_type_id = 1,
2089 .max_entries = 4,
2090 .btf_load_err = true,
2091 .err_str = "Invalid name",
2092 },
2093
2094 {
2095 .descr = "fwd type (invalid name, name_off = 0)",
2096 .raw_types = {
2097 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2098 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0), /* [2] */
2099 BTF_END_RAW,
2100 },
2101 .str_sec = "\0__skb",
2102 .str_sec_size = sizeof("\0__skb"),
2103 .map_type = BPF_MAP_TYPE_ARRAY,
2104 .map_name = "fwd_type_check_btf",
2105 .key_size = sizeof(int),
2106 .value_size = sizeof(int),
2107 .key_type_id = 1,
2108 .value_type_id = 1,
2109 .max_entries = 4,
2110 .btf_load_err = true,
2111 .err_str = "Invalid name",
2112 },
2113
2114 {
2115 .descr = "fwd type (invalid name, invalid identifier)",
2116 .raw_types = {
2117 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2118 BTF_TYPE_ENC(NAME_TBD,
2119 BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0), /* [2] */
2120 BTF_END_RAW,
2121 },
2122 .str_sec = "\0__!skb",
2123 .str_sec_size = sizeof("\0__!skb"),
2124 .map_type = BPF_MAP_TYPE_ARRAY,
2125 .map_name = "fwd_type_check_btf",
2126 .key_size = sizeof(int),
2127 .value_size = sizeof(int),
2128 .key_type_id = 1,
2129 .value_type_id = 1,
2130 .max_entries = 4,
2131 .btf_load_err = true,
2132 .err_str = "Invalid name",
2133 },
2134
2135 {
2136 .descr = "array type (invalid name, name_off <> 0)",
2137 .raw_types = {
2138 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2139 BTF_TYPE_ENC(NAME_TBD,
2140 BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 0), /* [2] */
2141 BTF_ARRAY_ENC(1, 1, 4),
2142 BTF_END_RAW,
2143 },
2144 .str_sec = "\0__skb",
2145 .str_sec_size = sizeof("\0__skb"),
2146 .map_type = BPF_MAP_TYPE_ARRAY,
2147 .map_name = "array_type_check_btf",
2148 .key_size = sizeof(int),
2149 .value_size = sizeof(int),
2150 .key_type_id = 1,
2151 .value_type_id = 1,
2152 .max_entries = 4,
2153 .btf_load_err = true,
2154 .err_str = "Invalid name",
2155 },
2156
2157 {
2158 .descr = "struct type (name_off = 0)",
2159 .raw_types = {
2160 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2161 BTF_TYPE_ENC(0,
2162 BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4), /* [2] */
2163 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2164 BTF_END_RAW,
2165 },
2166 .str_sec = "\0A",
2167 .str_sec_size = sizeof("\0A"),
2168 .map_type = BPF_MAP_TYPE_ARRAY,
2169 .map_name = "struct_type_check_btf",
2170 .key_size = sizeof(int),
2171 .value_size = sizeof(int),
2172 .key_type_id = 1,
2173 .value_type_id = 1,
2174 .max_entries = 4,
2175 },
2176
2177 {
2178 .descr = "struct type (invalid name, invalid identifier)",
2179 .raw_types = {
2180 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2181 BTF_TYPE_ENC(NAME_TBD,
2182 BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4), /* [2] */
2183 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2184 BTF_END_RAW,
2185 },
2186 .str_sec = "\0A!\0B",
2187 .str_sec_size = sizeof("\0A!\0B"),
2188 .map_type = BPF_MAP_TYPE_ARRAY,
2189 .map_name = "struct_type_check_btf",
2190 .key_size = sizeof(int),
2191 .value_size = sizeof(int),
2192 .key_type_id = 1,
2193 .value_type_id = 1,
2194 .max_entries = 4,
2195 .btf_load_err = true,
2196 .err_str = "Invalid name",
2197 },
2198
2199 {
2200 .descr = "struct member (name_off = 0)",
2201 .raw_types = {
2202 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2203 BTF_TYPE_ENC(0,
2204 BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4), /* [2] */
2205 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2206 BTF_END_RAW,
2207 },
2208 .str_sec = "\0A",
2209 .str_sec_size = sizeof("\0A"),
2210 .map_type = BPF_MAP_TYPE_ARRAY,
2211 .map_name = "struct_type_check_btf",
2212 .key_size = sizeof(int),
2213 .value_size = sizeof(int),
2214 .key_type_id = 1,
2215 .value_type_id = 1,
2216 .max_entries = 4,
2217 },
2218
2219 {
2220 .descr = "struct member (invalid name, invalid identifier)",
2221 .raw_types = {
2222 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2223 BTF_TYPE_ENC(NAME_TBD,
2224 BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4), /* [2] */
2225 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
2226 BTF_END_RAW,
2227 },
2228 .str_sec = "\0A\0B*",
2229 .str_sec_size = sizeof("\0A\0B*"),
2230 .map_type = BPF_MAP_TYPE_ARRAY,
2231 .map_name = "struct_type_check_btf",
2232 .key_size = sizeof(int),
2233 .value_size = sizeof(int),
2234 .key_type_id = 1,
2235 .value_type_id = 1,
2236 .max_entries = 4,
2237 .btf_load_err = true,
2238 .err_str = "Invalid name",
2239 },
2240
2241 {
2242 .descr = "enum type (name_off = 0)",
2243 .raw_types = {
2244 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2245 BTF_TYPE_ENC(0,
2246 BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2247 sizeof(int)), /* [2] */
2248 BTF_ENUM_ENC(NAME_TBD, 0),
2249 BTF_END_RAW,
2250 },
2251 .str_sec = "\0A\0B",
2252 .str_sec_size = sizeof("\0A\0B"),
2253 .map_type = BPF_MAP_TYPE_ARRAY,
2254 .map_name = "enum_type_check_btf",
2255 .key_size = sizeof(int),
2256 .value_size = sizeof(int),
2257 .key_type_id = 1,
2258 .value_type_id = 1,
2259 .max_entries = 4,
2260 },
2261
2262 {
2263 .descr = "enum type (invalid name, invalid identifier)",
2264 .raw_types = {
2265 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2266 BTF_TYPE_ENC(NAME_TBD,
2267 BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2268 sizeof(int)), /* [2] */
2269 BTF_ENUM_ENC(NAME_TBD, 0),
2270 BTF_END_RAW,
2271 },
2272 .str_sec = "\0A!\0B",
2273 .str_sec_size = sizeof("\0A!\0B"),
2274 .map_type = BPF_MAP_TYPE_ARRAY,
2275 .map_name = "enum_type_check_btf",
2276 .key_size = sizeof(int),
2277 .value_size = sizeof(int),
2278 .key_type_id = 1,
2279 .value_type_id = 1,
2280 .max_entries = 4,
2281 .btf_load_err = true,
2282 .err_str = "Invalid name",
2283 },
2284
2285 {
2286 .descr = "enum member (invalid name, name_off = 0)",
2287 .raw_types = {
2288 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2289 BTF_TYPE_ENC(0,
2290 BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2291 sizeof(int)), /* [2] */
2292 BTF_ENUM_ENC(0, 0),
2293 BTF_END_RAW,
2294 },
2295 .str_sec = "",
2296 .str_sec_size = sizeof(""),
2297 .map_type = BPF_MAP_TYPE_ARRAY,
2298 .map_name = "enum_type_check_btf",
2299 .key_size = sizeof(int),
2300 .value_size = sizeof(int),
2301 .key_type_id = 1,
2302 .value_type_id = 1,
2303 .max_entries = 4,
2304 .btf_load_err = true,
2305 .err_str = "Invalid name",
2306 },
2307
2308 {
2309 .descr = "enum member (invalid name, invalid identifier)",
2310 .raw_types = {
2311 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2312 BTF_TYPE_ENC(0,
2313 BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
2314 sizeof(int)), /* [2] */
2315 BTF_ENUM_ENC(NAME_TBD, 0),
2316 BTF_END_RAW,
2317 },
2318 .str_sec = "\0A!",
2319 .str_sec_size = sizeof("\0A!"),
2320 .map_type = BPF_MAP_TYPE_ARRAY,
2321 .map_name = "enum_type_check_btf",
2322 .key_size = sizeof(int),
2323 .value_size = sizeof(int),
2324 .key_type_id = 1,
2325 .value_type_id = 1,
2326 .max_entries = 4,
2327 .btf_load_err = true,
2328 .err_str = "Invalid name",
2329 },
2330 {
2331 .descr = "arraymap invalid btf key (a bit field)",
2332 .raw_types = {
2333 /* int */ /* [1] */
2334 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2335 /* 32 bit int with 32 bit offset */ /* [2] */
2336 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 32, 32, 8),
2337 BTF_END_RAW,
2338 },
2339 .str_sec = "",
2340 .str_sec_size = sizeof(""),
2341 .map_type = BPF_MAP_TYPE_ARRAY,
2342 .map_name = "array_map_check_btf",
2343 .key_size = sizeof(int),
2344 .value_size = sizeof(int),
2345 .key_type_id = 2,
2346 .value_type_id = 1,
2347 .max_entries = 4,
2348 .map_create_err = true,
2349 },
2350
2351 {
2352 .descr = "arraymap invalid btf key (!= 32 bits)",
2353 .raw_types = {
2354 /* int */ /* [1] */
2355 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2356 /* 16 bit int with 0 bit offset */ /* [2] */
2357 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 16, 2),
2358 BTF_END_RAW,
2359 },
2360 .str_sec = "",
2361 .str_sec_size = sizeof(""),
2362 .map_type = BPF_MAP_TYPE_ARRAY,
2363 .map_name = "array_map_check_btf",
2364 .key_size = sizeof(int),
2365 .value_size = sizeof(int),
2366 .key_type_id = 2,
2367 .value_type_id = 1,
2368 .max_entries = 4,
2369 .map_create_err = true,
2370 },
2371
2372 {
2373 .descr = "arraymap invalid btf value (too small)",
2374 .raw_types = {
2375 /* int */ /* [1] */
2376 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2377 BTF_END_RAW,
2378 },
2379 .str_sec = "",
2380 .str_sec_size = sizeof(""),
2381 .map_type = BPF_MAP_TYPE_ARRAY,
2382 .map_name = "array_map_check_btf",
2383 .key_size = sizeof(int),
2384 /* btf_value_size < map->value_size */
2385 .value_size = sizeof(__u64),
2386 .key_type_id = 1,
2387 .value_type_id = 1,
2388 .max_entries = 4,
2389 .map_create_err = true,
2390 },
2391
2392 {
2393 .descr = "arraymap invalid btf value (too big)",
2394 .raw_types = {
2395 /* int */ /* [1] */
2396 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
2397 BTF_END_RAW,
2398 },
2399 .str_sec = "",
2400 .str_sec_size = sizeof(""),
2401 .map_type = BPF_MAP_TYPE_ARRAY,
2402 .map_name = "array_map_check_btf",
2403 .key_size = sizeof(int),
2404 /* btf_value_size > map->value_size */
2405 .value_size = sizeof(__u16),
2406 .key_type_id = 1,
2407 .value_type_id = 1,
2408 .max_entries = 4,
2409 .map_create_err = true,
2410 },
2411
2412 {
2413 .descr = "func proto (int (*)(int, unsigned int))",
2414 .raw_types = {
2415 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2416 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2417 /* int (*)(int, unsigned int) */
2418 BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
2419 BTF_FUNC_PROTO_ARG_ENC(0, 1),
2420 BTF_FUNC_PROTO_ARG_ENC(0, 2),
2421 BTF_END_RAW,
2422 },
2423 .str_sec = "",
2424 .str_sec_size = sizeof(""),
2425 .map_type = BPF_MAP_TYPE_ARRAY,
2426 .map_name = "func_proto_type_check_btf",
2427 .key_size = sizeof(int),
2428 .value_size = sizeof(int),
2429 .key_type_id = 1,
2430 .value_type_id = 1,
2431 .max_entries = 4,
2432 },
2433
2434 {
2435 .descr = "func proto (vararg)",
2436 .raw_types = {
2437 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2438 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2439 /* void (*)(int, unsigned int, ...) */
2440 BTF_FUNC_PROTO_ENC(0, 3), /* [3] */
2441 BTF_FUNC_PROTO_ARG_ENC(0, 1),
2442 BTF_FUNC_PROTO_ARG_ENC(0, 2),
2443 BTF_FUNC_PROTO_ARG_ENC(0, 0),
2444 BTF_END_RAW,
2445 },
2446 .str_sec = "",
2447 .str_sec_size = sizeof(""),
2448 .map_type = BPF_MAP_TYPE_ARRAY,
2449 .map_name = "func_proto_type_check_btf",
2450 .key_size = sizeof(int),
2451 .value_size = sizeof(int),
2452 .key_type_id = 1,
2453 .value_type_id = 1,
2454 .max_entries = 4,
2455 },
2456
2457 {
2458 .descr = "func proto (vararg with name)",
2459 .raw_types = {
2460 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2461 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2462 /* void (*)(int a, unsigned int b, ... c) */
2463 BTF_FUNC_PROTO_ENC(0, 3), /* [3] */
2464 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2465 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2466 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 0),
2467 BTF_END_RAW,
2468 },
2469 .str_sec = "\0a\0b\0c",
2470 .str_sec_size = sizeof("\0a\0b\0c"),
2471 .map_type = BPF_MAP_TYPE_ARRAY,
2472 .map_name = "func_proto_type_check_btf",
2473 .key_size = sizeof(int),
2474 .value_size = sizeof(int),
2475 .key_type_id = 1,
2476 .value_type_id = 1,
2477 .max_entries = 4,
2478 .btf_load_err = true,
2479 .err_str = "Invalid arg#3",
2480 },
2481
2482 {
2483 .descr = "func proto (arg after vararg)",
2484 .raw_types = {
2485 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2486 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2487 /* void (*)(int a, ..., unsigned int b) */
2488 BTF_FUNC_PROTO_ENC(0, 3), /* [3] */
2489 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2490 BTF_FUNC_PROTO_ARG_ENC(0, 0),
2491 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2492 BTF_END_RAW,
2493 },
2494 .str_sec = "\0a\0b",
2495 .str_sec_size = sizeof("\0a\0b"),
2496 .map_type = BPF_MAP_TYPE_ARRAY,
2497 .map_name = "func_proto_type_check_btf",
2498 .key_size = sizeof(int),
2499 .value_size = sizeof(int),
2500 .key_type_id = 1,
2501 .value_type_id = 1,
2502 .max_entries = 4,
2503 .btf_load_err = true,
2504 .err_str = "Invalid arg#2",
2505 },
2506
2507 {
2508 .descr = "func proto (CONST=>TYPEDEF=>PTR=>FUNC_PROTO)",
2509 .raw_types = {
2510 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2511 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2512 /* typedef void (*func_ptr)(int, unsigned int) */
2513 BTF_TYPEDEF_ENC(NAME_TBD, 5), /* [3] */
2514 /* const func_ptr */
2515 BTF_CONST_ENC(3), /* [4] */
2516 BTF_PTR_ENC(6), /* [5] */
2517 BTF_FUNC_PROTO_ENC(0, 2), /* [6] */
2518 BTF_FUNC_PROTO_ARG_ENC(0, 1),
2519 BTF_FUNC_PROTO_ARG_ENC(0, 2),
2520 BTF_END_RAW,
2521 },
2522 .str_sec = "\0func_ptr",
2523 .str_sec_size = sizeof("\0func_ptr"),
2524 .map_type = BPF_MAP_TYPE_ARRAY,
2525 .map_name = "func_proto_type_check_btf",
2526 .key_size = sizeof(int),
2527 .value_size = sizeof(int),
2528 .key_type_id = 1,
2529 .value_type_id = 1,
2530 .max_entries = 4,
2531 },
2532
2533 {
2534 .descr = "func proto (TYPEDEF=>FUNC_PROTO)",
2535 .raw_types = {
2536 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2537 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2538 BTF_TYPEDEF_ENC(NAME_TBD, 4), /* [3] */
2539 BTF_FUNC_PROTO_ENC(0, 2), /* [4] */
2540 BTF_FUNC_PROTO_ARG_ENC(0, 1),
2541 BTF_FUNC_PROTO_ARG_ENC(0, 2),
2542 BTF_END_RAW,
2543 },
2544 .str_sec = "\0func_typedef",
2545 .str_sec_size = sizeof("\0func_typedef"),
2546 .map_type = BPF_MAP_TYPE_ARRAY,
2547 .map_name = "func_proto_type_check_btf",
2548 .key_size = sizeof(int),
2549 .value_size = sizeof(int),
2550 .key_type_id = 1,
2551 .value_type_id = 1,
2552 .max_entries = 4,
2553 },
2554
2555 {
2556 .descr = "func proto (btf_resolve(arg))",
2557 .raw_types = {
2558 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2559 /* void (*)(const void *) */
2560 BTF_FUNC_PROTO_ENC(0, 1), /* [2] */
2561 BTF_FUNC_PROTO_ARG_ENC(0, 3),
2562 BTF_CONST_ENC(4), /* [3] */
2563 BTF_PTR_ENC(0), /* [4] */
2564 BTF_END_RAW,
2565 },
2566 .str_sec = "",
2567 .str_sec_size = sizeof(""),
2568 .map_type = BPF_MAP_TYPE_ARRAY,
2569 .map_name = "func_proto_type_check_btf",
2570 .key_size = sizeof(int),
2571 .value_size = sizeof(int),
2572 .key_type_id = 1,
2573 .value_type_id = 1,
2574 .max_entries = 4,
2575 },
2576
2577 {
2578 .descr = "func proto (Not all arg has name)",
2579 .raw_types = {
2580 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2581 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2582 /* void (*)(int, unsigned int b) */
2583 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2584 BTF_FUNC_PROTO_ARG_ENC(0, 1),
2585 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2586 BTF_END_RAW,
2587 },
2588 .str_sec = "\0b",
2589 .str_sec_size = sizeof("\0b"),
2590 .map_type = BPF_MAP_TYPE_ARRAY,
2591 .map_name = "func_proto_type_check_btf",
2592 .key_size = sizeof(int),
2593 .value_size = sizeof(int),
2594 .key_type_id = 1,
2595 .value_type_id = 1,
2596 .max_entries = 4,
2597 },
2598
2599 {
2600 .descr = "func proto (Bad arg name_off)",
2601 .raw_types = {
2602 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2603 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2604 /* void (*)(int a, unsigned int <bad_name_off>) */
2605 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2606 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2607 BTF_FUNC_PROTO_ARG_ENC(0x0fffffff, 2),
2608 BTF_END_RAW,
2609 },
2610 .str_sec = "\0a",
2611 .str_sec_size = sizeof("\0a"),
2612 .map_type = BPF_MAP_TYPE_ARRAY,
2613 .map_name = "func_proto_type_check_btf",
2614 .key_size = sizeof(int),
2615 .value_size = sizeof(int),
2616 .key_type_id = 1,
2617 .value_type_id = 1,
2618 .max_entries = 4,
2619 .btf_load_err = true,
2620 .err_str = "Invalid arg#2",
2621 },
2622
2623 {
2624 .descr = "func proto (Bad arg name)",
2625 .raw_types = {
2626 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2627 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2628 /* void (*)(int a, unsigned int !!!) */
2629 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2630 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2631 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2632 BTF_END_RAW,
2633 },
2634 .str_sec = "\0a\0!!!",
2635 .str_sec_size = sizeof("\0a\0!!!"),
2636 .map_type = BPF_MAP_TYPE_ARRAY,
2637 .map_name = "func_proto_type_check_btf",
2638 .key_size = sizeof(int),
2639 .value_size = sizeof(int),
2640 .key_type_id = 1,
2641 .value_type_id = 1,
2642 .max_entries = 4,
2643 .btf_load_err = true,
2644 .err_str = "Invalid arg#2",
2645 },
2646
2647 {
2648 .descr = "func proto (Invalid return type)",
2649 .raw_types = {
2650 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2651 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2652 /* <bad_ret_type> (*)(int, unsigned int) */
2653 BTF_FUNC_PROTO_ENC(100, 2), /* [3] */
2654 BTF_FUNC_PROTO_ARG_ENC(0, 1),
2655 BTF_FUNC_PROTO_ARG_ENC(0, 2),
2656 BTF_END_RAW,
2657 },
2658 .str_sec = "",
2659 .str_sec_size = sizeof(""),
2660 .map_type = BPF_MAP_TYPE_ARRAY,
2661 .map_name = "func_proto_type_check_btf",
2662 .key_size = sizeof(int),
2663 .value_size = sizeof(int),
2664 .key_type_id = 1,
2665 .value_type_id = 1,
2666 .max_entries = 4,
2667 .btf_load_err = true,
2668 .err_str = "Invalid return type",
2669 },
2670
2671 {
2672 .descr = "func proto (with func name)",
2673 .raw_types = {
2674 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2675 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2676 /* void func_proto(int, unsigned int) */
2677 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 2), 0), /* [3] */
2678 BTF_FUNC_PROTO_ARG_ENC(0, 1),
2679 BTF_FUNC_PROTO_ARG_ENC(0, 2),
2680 BTF_END_RAW,
2681 },
2682 .str_sec = "\0func_proto",
2683 .str_sec_size = sizeof("\0func_proto"),
2684 .map_type = BPF_MAP_TYPE_ARRAY,
2685 .map_name = "func_proto_type_check_btf",
2686 .key_size = sizeof(int),
2687 .value_size = sizeof(int),
2688 .key_type_id = 1,
2689 .value_type_id = 1,
2690 .max_entries = 4,
2691 .btf_load_err = true,
2692 .err_str = "Invalid name",
2693 },
2694
2695 {
2696 .descr = "func proto (const void arg)",
2697 .raw_types = {
2698 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2699 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2700 /* void (*)(const void) */
2701 BTF_FUNC_PROTO_ENC(0, 1), /* [3] */
2702 BTF_FUNC_PROTO_ARG_ENC(0, 4),
2703 BTF_CONST_ENC(0), /* [4] */
2704 BTF_END_RAW,
2705 },
2706 .str_sec = "",
2707 .str_sec_size = sizeof(""),
2708 .map_type = BPF_MAP_TYPE_ARRAY,
2709 .map_name = "func_proto_type_check_btf",
2710 .key_size = sizeof(int),
2711 .value_size = sizeof(int),
2712 .key_type_id = 1,
2713 .value_type_id = 1,
2714 .max_entries = 4,
2715 .btf_load_err = true,
2716 .err_str = "Invalid arg#1",
2717 },
2718
2719 {
2720 .descr = "func (void func(int a, unsigned int b))",
2721 .raw_types = {
2722 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2723 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2724 /* void (*)(int a, unsigned int b) */
2725 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2726 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2727 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2728 /* void func(int a, unsigned int b) */
2729 BTF_FUNC_ENC(NAME_TBD, 3), /* [4] */
2730 BTF_END_RAW,
2731 },
2732 .str_sec = "\0a\0b\0func",
2733 .str_sec_size = sizeof("\0a\0b\0func"),
2734 .map_type = BPF_MAP_TYPE_ARRAY,
2735 .map_name = "func_type_check_btf",
2736 .key_size = sizeof(int),
2737 .value_size = sizeof(int),
2738 .key_type_id = 1,
2739 .value_type_id = 1,
2740 .max_entries = 4,
2741 },
2742
2743 {
2744 .descr = "func (No func name)",
2745 .raw_types = {
2746 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2747 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2748 /* void (*)(int a, unsigned int b) */
2749 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2750 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2751 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2752 /* void <no_name>(int a, unsigned int b) */
2753 BTF_FUNC_ENC(0, 3), /* [4] */
2754 BTF_END_RAW,
2755 },
2756 .str_sec = "\0a\0b",
2757 .str_sec_size = sizeof("\0a\0b"),
2758 .map_type = BPF_MAP_TYPE_ARRAY,
2759 .map_name = "func_type_check_btf",
2760 .key_size = sizeof(int),
2761 .value_size = sizeof(int),
2762 .key_type_id = 1,
2763 .value_type_id = 1,
2764 .max_entries = 4,
2765 .btf_load_err = true,
2766 .err_str = "Invalid name",
2767 },
2768
2769 {
2770 .descr = "func (Invalid func name)",
2771 .raw_types = {
2772 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2773 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2774 /* void (*)(int a, unsigned int b) */
2775 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2776 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2777 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2778 /* void !!!(int a, unsigned int b) */
2779 BTF_FUNC_ENC(NAME_TBD, 3), /* [4] */
2780 BTF_END_RAW,
2781 },
2782 .str_sec = "\0a\0b\0!!!",
2783 .str_sec_size = sizeof("\0a\0b\0!!!"),
2784 .map_type = BPF_MAP_TYPE_ARRAY,
2785 .map_name = "func_type_check_btf",
2786 .key_size = sizeof(int),
2787 .value_size = sizeof(int),
2788 .key_type_id = 1,
2789 .value_type_id = 1,
2790 .max_entries = 4,
2791 .btf_load_err = true,
2792 .err_str = "Invalid name",
2793 },
2794
2795 {
2796 .descr = "func (Some arg has no name)",
2797 .raw_types = {
2798 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2799 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2800 /* void (*)(int a, unsigned int) */
2801 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2802 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2803 BTF_FUNC_PROTO_ARG_ENC(0, 2),
2804 /* void func(int a, unsigned int) */
2805 BTF_FUNC_ENC(NAME_TBD, 3), /* [4] */
2806 BTF_END_RAW,
2807 },
2808 .str_sec = "\0a\0func",
2809 .str_sec_size = sizeof("\0a\0func"),
2810 .map_type = BPF_MAP_TYPE_ARRAY,
2811 .map_name = "func_type_check_btf",
2812 .key_size = sizeof(int),
2813 .value_size = sizeof(int),
2814 .key_type_id = 1,
2815 .value_type_id = 1,
2816 .max_entries = 4,
2817 .btf_load_err = true,
2818 .err_str = "Invalid arg#2",
2819 },
2820
2821 {
2822 .descr = "func (Non zero vlen)",
2823 .raw_types = {
2824 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2825 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */
2826 /* void (*)(int a, unsigned int b) */
2827 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
2828 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
2829 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
2830 /* void func(int a, unsigned int b) */
2831 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC, 0, 2), 3), /* [4] */
2832 BTF_END_RAW,
2833 },
2834 .str_sec = "\0a\0b\0func",
2835 .str_sec_size = sizeof("\0a\0b\0func"),
2836 .map_type = BPF_MAP_TYPE_ARRAY,
2837 .map_name = "func_type_check_btf",
2838 .key_size = sizeof(int),
2839 .value_size = sizeof(int),
2840 .key_type_id = 1,
2841 .value_type_id = 1,
2842 .max_entries = 4,
2843 .btf_load_err = true,
2844 .err_str = "Invalid func linkage",
2845 },
2846
2847 {
2848 .descr = "func (Not referring to FUNC_PROTO)",
2849 .raw_types = {
2850 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2851 BTF_FUNC_ENC(NAME_TBD, 1), /* [2] */
2852 BTF_END_RAW,
2853 },
2854 .str_sec = "\0func",
2855 .str_sec_size = sizeof("\0func"),
2856 .map_type = BPF_MAP_TYPE_ARRAY,
2857 .map_name = "func_type_check_btf",
2858 .key_size = sizeof(int),
2859 .value_size = sizeof(int),
2860 .key_type_id = 1,
2861 .value_type_id = 1,
2862 .max_entries = 4,
2863 .btf_load_err = true,
2864 .err_str = "Invalid type_id",
2865 },
2866
2867 {
2868 .descr = "invalid int kind_flag",
2869 .raw_types = {
2870 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2871 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 1, 0), 4), /* [2] */
2872 BTF_INT_ENC(0, 0, 32),
2873 BTF_END_RAW,
2874 },
2875 BTF_STR_SEC(""),
2876 .map_type = BPF_MAP_TYPE_ARRAY,
2877 .map_name = "int_type_check_btf",
2878 .key_size = sizeof(int),
2879 .value_size = sizeof(int),
2880 .key_type_id = 1,
2881 .value_type_id = 1,
2882 .max_entries = 4,
2883 .btf_load_err = true,
2884 .err_str = "Invalid btf_info kind_flag",
2885 },
2886
2887 {
2888 .descr = "invalid ptr kind_flag",
2889 .raw_types = {
2890 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2891 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 1, 0), 1), /* [2] */
2892 BTF_END_RAW,
2893 },
2894 BTF_STR_SEC(""),
2895 .map_type = BPF_MAP_TYPE_ARRAY,
2896 .map_name = "ptr_type_check_btf",
2897 .key_size = sizeof(int),
2898 .value_size = sizeof(int),
2899 .key_type_id = 1,
2900 .value_type_id = 1,
2901 .max_entries = 4,
2902 .btf_load_err = true,
2903 .err_str = "Invalid btf_info kind_flag",
2904 },
2905
2906 {
2907 .descr = "invalid array kind_flag",
2908 .raw_types = {
2909 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2910 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 1, 0), 0), /* [2] */
2911 BTF_ARRAY_ENC(1, 1, 1),
2912 BTF_END_RAW,
2913 },
2914 BTF_STR_SEC(""),
2915 .map_type = BPF_MAP_TYPE_ARRAY,
2916 .map_name = "array_type_check_btf",
2917 .key_size = sizeof(int),
2918 .value_size = sizeof(int),
2919 .key_type_id = 1,
2920 .value_type_id = 1,
2921 .max_entries = 4,
2922 .btf_load_err = true,
2923 .err_str = "Invalid btf_info kind_flag",
2924 },
2925
2926 {
2927 .descr = "valid fwd kind_flag",
2928 .raw_types = {
2929 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2930 BTF_TYPE_ENC(NAME_TBD,
2931 BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [2] */
2932 BTF_END_RAW,
2933 },
2934 BTF_STR_SEC("\0A"),
2935 .map_type = BPF_MAP_TYPE_ARRAY,
2936 .map_name = "fwd_type_check_btf",
2937 .key_size = sizeof(int),
2938 .value_size = sizeof(int),
2939 .key_type_id = 1,
2940 .value_type_id = 1,
2941 .max_entries = 4,
2942 },
2943
2944 {
2945 .descr = "invalid typedef kind_flag",
2946 .raw_types = {
2947 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2948 BTF_TYPE_ENC(NAME_TBD,
2949 BTF_INFO_ENC(BTF_KIND_TYPEDEF, 1, 0), 1), /* [2] */
2950 BTF_END_RAW,
2951 },
2952 BTF_STR_SEC("\0A"),
2953 .map_type = BPF_MAP_TYPE_ARRAY,
2954 .map_name = "typedef_type_check_btf",
2955 .key_size = sizeof(int),
2956 .value_size = sizeof(int),
2957 .key_type_id = 1,
2958 .value_type_id = 1,
2959 .max_entries = 4,
2960 .btf_load_err = true,
2961 .err_str = "Invalid btf_info kind_flag",
2962 },
2963
2964 {
2965 .descr = "invalid volatile kind_flag",
2966 .raw_types = {
2967 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2968 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 1, 0), 1), /* [2] */
2969 BTF_END_RAW,
2970 },
2971 BTF_STR_SEC(""),
2972 .map_type = BPF_MAP_TYPE_ARRAY,
2973 .map_name = "volatile_type_check_btf",
2974 .key_size = sizeof(int),
2975 .value_size = sizeof(int),
2976 .key_type_id = 1,
2977 .value_type_id = 1,
2978 .max_entries = 4,
2979 .btf_load_err = true,
2980 .err_str = "Invalid btf_info kind_flag",
2981 },
2982
2983 {
2984 .descr = "invalid const kind_flag",
2985 .raw_types = {
2986 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
2987 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 1, 0), 1), /* [2] */
2988 BTF_END_RAW,
2989 },
2990 BTF_STR_SEC(""),
2991 .map_type = BPF_MAP_TYPE_ARRAY,
2992 .map_name = "const_type_check_btf",
2993 .key_size = sizeof(int),
2994 .value_size = sizeof(int),
2995 .key_type_id = 1,
2996 .value_type_id = 1,
2997 .max_entries = 4,
2998 .btf_load_err = true,
2999 .err_str = "Invalid btf_info kind_flag",
3000 },
3001
3002 {
3003 .descr = "invalid restrict kind_flag",
3004 .raw_types = {
3005 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3006 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_RESTRICT, 1, 0), 1), /* [2] */
3007 BTF_END_RAW,
3008 },
3009 BTF_STR_SEC(""),
3010 .map_type = BPF_MAP_TYPE_ARRAY,
3011 .map_name = "restrict_type_check_btf",
3012 .key_size = sizeof(int),
3013 .value_size = sizeof(int),
3014 .key_type_id = 1,
3015 .value_type_id = 1,
3016 .max_entries = 4,
3017 .btf_load_err = true,
3018 .err_str = "Invalid btf_info kind_flag",
3019 },
3020
3021 {
3022 .descr = "invalid func kind_flag",
3023 .raw_types = {
3024 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3025 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 0), 0), /* [2] */
3026 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FUNC, 1, 0), 2), /* [3] */
3027 BTF_END_RAW,
3028 },
3029 BTF_STR_SEC("\0A"),
3030 .map_type = BPF_MAP_TYPE_ARRAY,
3031 .map_name = "func_type_check_btf",
3032 .key_size = sizeof(int),
3033 .value_size = sizeof(int),
3034 .key_type_id = 1,
3035 .value_type_id = 1,
3036 .max_entries = 4,
3037 .btf_load_err = true,
3038 .err_str = "Invalid btf_info kind_flag",
3039 },
3040
3041 {
3042 .descr = "invalid func_proto kind_flag",
3043 .raw_types = {
3044 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3045 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 1, 0), 0), /* [2] */
3046 BTF_END_RAW,
3047 },
3048 BTF_STR_SEC(""),
3049 .map_type = BPF_MAP_TYPE_ARRAY,
3050 .map_name = "func_proto_type_check_btf",
3051 .key_size = sizeof(int),
3052 .value_size = sizeof(int),
3053 .key_type_id = 1,
3054 .value_type_id = 1,
3055 .max_entries = 4,
3056 .btf_load_err = true,
3057 .err_str = "Invalid btf_info kind_flag",
3058 },
3059
3060 {
3061 .descr = "valid struct, kind_flag, bitfield_size = 0",
3062 .raw_types = {
3063 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3064 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 8), /* [2] */
3065 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 0)),
3066 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(0, 32)),
3067 BTF_END_RAW,
3068 },
3069 BTF_STR_SEC("\0A\0B"),
3070 .map_type = BPF_MAP_TYPE_ARRAY,
3071 .map_name = "struct_type_check_btf",
3072 .key_size = sizeof(int),
3073 .value_size = sizeof(int),
3074 .key_type_id = 1,
3075 .value_type_id = 1,
3076 .max_entries = 4,
3077 },
3078
3079 {
3080 .descr = "valid struct, kind_flag, int member, bitfield_size != 0",
3081 .raw_types = {
3082 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3083 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4), /* [2] */
3084 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
3085 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 4)),
3086 BTF_END_RAW,
3087 },
3088 BTF_STR_SEC("\0A\0B"),
3089 .map_type = BPF_MAP_TYPE_ARRAY,
3090 .map_name = "struct_type_check_btf",
3091 .key_size = sizeof(int),
3092 .value_size = sizeof(int),
3093 .key_type_id = 1,
3094 .value_type_id = 1,
3095 .max_entries = 4,
3096 },
3097
3098 {
3099 .descr = "valid union, kind_flag, int member, bitfield_size != 0",
3100 .raw_types = {
3101 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3102 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [2] */
3103 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
3104 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(4, 0)),
3105 BTF_END_RAW,
3106 },
3107 BTF_STR_SEC("\0A\0B"),
3108 .map_type = BPF_MAP_TYPE_ARRAY,
3109 .map_name = "union_type_check_btf",
3110 .key_size = sizeof(int),
3111 .value_size = sizeof(int),
3112 .key_type_id = 1,
3113 .value_type_id = 1,
3114 .max_entries = 4,
3115 },
3116
3117 {
3118 .descr = "valid struct, kind_flag, enum member, bitfield_size != 0",
3119 .raw_types = {
3120 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3121 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4), /* [2] */
3122 BTF_ENUM_ENC(NAME_TBD, 0),
3123 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
3124 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
3125 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 4)),
3126 BTF_END_RAW,
3127 },
3128 BTF_STR_SEC("\0A\0B\0C"),
3129 .map_type = BPF_MAP_TYPE_ARRAY,
3130 .map_name = "struct_type_check_btf",
3131 .key_size = sizeof(int),
3132 .value_size = sizeof(int),
3133 .key_type_id = 1,
3134 .value_type_id = 1,
3135 .max_entries = 4,
3136 },
3137
3138 {
3139 .descr = "valid union, kind_flag, enum member, bitfield_size != 0",
3140 .raw_types = {
3141 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3142 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4), /* [2] */
3143 BTF_ENUM_ENC(NAME_TBD, 0),
3144 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [3] */
3145 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
3146 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(4, 0)),
3147 BTF_END_RAW,
3148 },
3149 BTF_STR_SEC("\0A\0B\0C"),
3150 .map_type = BPF_MAP_TYPE_ARRAY,
3151 .map_name = "union_type_check_btf",
3152 .key_size = sizeof(int),
3153 .value_size = sizeof(int),
3154 .key_type_id = 1,
3155 .value_type_id = 1,
3156 .max_entries = 4,
3157 },
3158
3159 {
3160 .descr = "valid struct, kind_flag, typedef member, bitfield_size != 0",
3161 .raw_types = {
3162 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3163 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4), /* [2] */
3164 BTF_ENUM_ENC(NAME_TBD, 0),
3165 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4),/* [3] */
3166 BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
3167 BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 4)),
3168 BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [4] */
3169 BTF_TYPEDEF_ENC(NAME_TBD, 2), /* [5] */
3170 BTF_END_RAW,
3171 },
3172 BTF_STR_SEC("\0A\0B\0C\0D\0E"),
3173 .map_type = BPF_MAP_TYPE_ARRAY,
3174 .map_name = "struct_type_check_btf",
3175 .key_size = sizeof(int),
3176 .value_size = sizeof(int),
3177 .key_type_id = 1,
3178 .value_type_id = 1,
3179 .max_entries = 4,
3180 },
3181
3182 {
3183 .descr = "valid union, kind_flag, typedef member, bitfield_size != 0",
3184 .raw_types = {
3185 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3186 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4), /* [2] */
3187 BTF_ENUM_ENC(NAME_TBD, 0),
3188 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 4), /* [3] */
3189 BTF_MEMBER_ENC(NAME_TBD, 4, BTF_MEMBER_OFFSET(4, 0)),
3190 BTF_MEMBER_ENC(NAME_TBD, 5, BTF_MEMBER_OFFSET(4, 0)),
3191 BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [4] */
3192 BTF_TYPEDEF_ENC(NAME_TBD, 2), /* [5] */
3193 BTF_END_RAW,
3194 },
3195 BTF_STR_SEC("\0A\0B\0C\0D\0E"),
3196 .map_type = BPF_MAP_TYPE_ARRAY,
3197 .map_name = "union_type_check_btf",
3198 .key_size = sizeof(int),
3199 .value_size = sizeof(int),
3200 .key_type_id = 1,
3201 .value_type_id = 1,
3202 .max_entries = 4,
3203 },
3204
3205 {
3206 .descr = "invalid struct, kind_flag, bitfield_size greater than struct size",
3207 .raw_types = {
3208 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3209 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4), /* [2] */
3210 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
3211 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 20)),
3212 BTF_END_RAW,
3213 },
3214 BTF_STR_SEC("\0A\0B"),
3215 .map_type = BPF_MAP_TYPE_ARRAY,
3216 .map_name = "struct_type_check_btf",
3217 .key_size = sizeof(int),
3218 .value_size = sizeof(int),
3219 .key_type_id = 1,
3220 .value_type_id = 1,
3221 .max_entries = 4,
3222 .btf_load_err = true,
3223 .err_str = "Member exceeds struct_size",
3224 },
3225
3226 {
3227 .descr = "invalid struct, kind_flag, bitfield base_type int not regular",
3228 .raw_types = {
3229 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3230 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 20, 4), /* [2] */
3231 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4), /* [3] */
3232 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 0)),
3233 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(20, 20)),
3234 BTF_END_RAW,
3235 },
3236 BTF_STR_SEC("\0A\0B"),
3237 .map_type = BPF_MAP_TYPE_ARRAY,
3238 .map_name = "struct_type_check_btf",
3239 .key_size = sizeof(int),
3240 .value_size = sizeof(int),
3241 .key_type_id = 1,
3242 .value_type_id = 1,
3243 .max_entries = 4,
3244 .btf_load_err = true,
3245 .err_str = "Invalid member base type",
3246 },
3247
3248 {
3249 .descr = "invalid struct, kind_flag, base_type int not regular",
3250 .raw_types = {
3251 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3252 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 12, 4), /* [2] */
3253 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 4), /* [3] */
3254 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 0)),
3255 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(8, 8)),
3256 BTF_END_RAW,
3257 },
3258 BTF_STR_SEC("\0A\0B"),
3259 .map_type = BPF_MAP_TYPE_ARRAY,
3260 .map_name = "struct_type_check_btf",
3261 .key_size = sizeof(int),
3262 .value_size = sizeof(int),
3263 .key_type_id = 1,
3264 .value_type_id = 1,
3265 .max_entries = 4,
3266 .btf_load_err = true,
3267 .err_str = "Invalid member base type",
3268 },
3269
3270 {
3271 .descr = "invalid union, kind_flag, bitfield_size greater than struct size",
3272 .raw_types = {
3273 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3274 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 1, 2), 2), /* [2] */
3275 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(8, 0)),
3276 BTF_MEMBER_ENC(NAME_TBD, 1, BTF_MEMBER_OFFSET(20, 0)),
3277 BTF_END_RAW,
3278 },
3279 BTF_STR_SEC("\0A\0B"),
3280 .map_type = BPF_MAP_TYPE_ARRAY,
3281 .map_name = "union_type_check_btf",
3282 .key_size = sizeof(int),
3283 .value_size = sizeof(int),
3284 .key_type_id = 1,
3285 .value_type_id = 1,
3286 .max_entries = 4,
3287 .btf_load_err = true,
3288 .err_str = "Member exceeds struct_size",
3289 },
3290
3291 {
3292 .descr = "invalid struct, kind_flag, int member, bitfield_size = 0, wrong byte alignment",
3293 .raw_types = {
3294 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3295 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
3296 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12), /* [3] */
3297 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
3298 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
3299 BTF_END_RAW,
3300 },
3301 BTF_STR_SEC("\0A\0B"),
3302 .map_type = BPF_MAP_TYPE_ARRAY,
3303 .map_name = "struct_type_check_btf",
3304 .key_size = sizeof(int),
3305 .value_size = sizeof(int),
3306 .key_type_id = 1,
3307 .value_type_id = 1,
3308 .max_entries = 4,
3309 .btf_load_err = true,
3310 .err_str = "Invalid member offset",
3311 },
3312
3313 {
3314 .descr = "invalid struct, kind_flag, enum member, bitfield_size = 0, wrong byte alignment",
3315 .raw_types = {
3316 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3317 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
3318 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4), /* [2] */
3319 BTF_ENUM_ENC(NAME_TBD, 0),
3320 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 2), 12), /* [3] */
3321 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
3322 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 36)),
3323 BTF_END_RAW,
3324 },
3325 BTF_STR_SEC("\0A\0B\0C"),
3326 .map_type = BPF_MAP_TYPE_ARRAY,
3327 .map_name = "struct_type_check_btf",
3328 .key_size = sizeof(int),
3329 .value_size = sizeof(int),
3330 .key_type_id = 1,
3331 .value_type_id = 1,
3332 .max_entries = 4,
3333 .btf_load_err = true,
3334 .err_str = "Invalid member offset",
3335 },
3336
3337 {
3338 .descr = "128-bit int",
3339 .raw_types = {
3340 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3341 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16), /* [2] */
3342 BTF_END_RAW,
3343 },
3344 BTF_STR_SEC("\0A"),
3345 .map_type = BPF_MAP_TYPE_ARRAY,
3346 .map_name = "int_type_check_btf",
3347 .key_size = sizeof(int),
3348 .value_size = sizeof(int),
3349 .key_type_id = 1,
3350 .value_type_id = 1,
3351 .max_entries = 4,
3352 },
3353
3354 {
3355 .descr = "struct, 128-bit int member",
3356 .raw_types = {
3357 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3358 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16), /* [2] */
3359 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 16), /* [3] */
3360 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3361 BTF_END_RAW,
3362 },
3363 BTF_STR_SEC("\0A"),
3364 .map_type = BPF_MAP_TYPE_ARRAY,
3365 .map_name = "struct_type_check_btf",
3366 .key_size = sizeof(int),
3367 .value_size = sizeof(int),
3368 .key_type_id = 1,
3369 .value_type_id = 1,
3370 .max_entries = 4,
3371 },
3372
3373 {
3374 .descr = "struct, 120-bit int member bitfield",
3375 .raw_types = {
3376 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3377 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 120, 16), /* [2] */
3378 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 16), /* [3] */
3379 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3380 BTF_END_RAW,
3381 },
3382 BTF_STR_SEC("\0A"),
3383 .map_type = BPF_MAP_TYPE_ARRAY,
3384 .map_name = "struct_type_check_btf",
3385 .key_size = sizeof(int),
3386 .value_size = sizeof(int),
3387 .key_type_id = 1,
3388 .value_type_id = 1,
3389 .max_entries = 4,
3390 },
3391
3392 {
3393 .descr = "struct, kind_flag, 128-bit int member",
3394 .raw_types = {
3395 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3396 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16), /* [2] */
3397 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 16), /* [3] */
3398 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)),
3399 BTF_END_RAW,
3400 },
3401 BTF_STR_SEC("\0A"),
3402 .map_type = BPF_MAP_TYPE_ARRAY,
3403 .map_name = "struct_type_check_btf",
3404 .key_size = sizeof(int),
3405 .value_size = sizeof(int),
3406 .key_type_id = 1,
3407 .value_type_id = 1,
3408 .max_entries = 4,
3409 },
3410
3411 {
3412 .descr = "struct, kind_flag, 120-bit int member bitfield",
3413 .raw_types = {
3414 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3415 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 128, 16), /* [2] */
3416 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 16), /* [3] */
3417 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(120, 0)),
3418 BTF_END_RAW,
3419 },
3420 BTF_STR_SEC("\0A"),
3421 .map_type = BPF_MAP_TYPE_ARRAY,
3422 .map_name = "struct_type_check_btf",
3423 .key_size = sizeof(int),
3424 .value_size = sizeof(int),
3425 .key_type_id = 1,
3426 .value_type_id = 1,
3427 .max_entries = 4,
3428 },
3429 /*
3430 * typedef int arr_t[16];
3431 * struct s {
3432 * arr_t *a;
3433 * };
3434 */
3435 {
3436 .descr = "struct->ptr->typedef->array->int size resolution",
3437 .raw_types = {
3438 BTF_STRUCT_ENC(NAME_TBD, 1, 8), /* [1] */
3439 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3440 BTF_PTR_ENC(3), /* [2] */
3441 BTF_TYPEDEF_ENC(NAME_TBD, 4), /* [3] */
3442 BTF_TYPE_ARRAY_ENC(5, 5, 16), /* [4] */
3443 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [5] */
3444 BTF_END_RAW,
3445 },
3446 BTF_STR_SEC("\0s\0a\0arr_t"),
3447 .map_type = BPF_MAP_TYPE_ARRAY,
3448 .map_name = "ptr_mod_chain_size_resolve_map",
3449 .key_size = sizeof(int),
3450 .value_size = sizeof(int) * 16,
3451 .key_type_id = 5 /* int */,
3452 .value_type_id = 3 /* arr_t */,
3453 .max_entries = 4,
3454 },
3455 /*
3456 * typedef int arr_t[16][8][4];
3457 * struct s {
3458 * arr_t *a;
3459 * };
3460 */
3461 {
3462 .descr = "struct->ptr->typedef->multi-array->int size resolution",
3463 .raw_types = {
3464 BTF_STRUCT_ENC(NAME_TBD, 1, 8), /* [1] */
3465 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3466 BTF_PTR_ENC(3), /* [2] */
3467 BTF_TYPEDEF_ENC(NAME_TBD, 4), /* [3] */
3468 BTF_TYPE_ARRAY_ENC(5, 7, 16), /* [4] */
3469 BTF_TYPE_ARRAY_ENC(6, 7, 8), /* [5] */
3470 BTF_TYPE_ARRAY_ENC(7, 7, 4), /* [6] */
3471 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [7] */
3472 BTF_END_RAW,
3473 },
3474 BTF_STR_SEC("\0s\0a\0arr_t"),
3475 .map_type = BPF_MAP_TYPE_ARRAY,
3476 .map_name = "multi_arr_size_resolve_map",
3477 .key_size = sizeof(int),
3478 .value_size = sizeof(int) * 16 * 8 * 4,
3479 .key_type_id = 7 /* int */,
3480 .value_type_id = 3 /* arr_t */,
3481 .max_entries = 4,
3482 },
3483 /*
3484 * typedef int int_t;
3485 * typedef int_t arr3_t[4];
3486 * typedef arr3_t arr2_t[8];
3487 * typedef arr2_t arr1_t[16];
3488 * struct s {
3489 * arr1_t *a;
3490 * };
3491 */
3492 {
3493 .descr = "typedef/multi-arr mix size resolution",
3494 .raw_types = {
3495 BTF_STRUCT_ENC(NAME_TBD, 1, 8), /* [1] */
3496 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3497 BTF_PTR_ENC(3), /* [2] */
3498 BTF_TYPEDEF_ENC(NAME_TBD, 4), /* [3] */
3499 BTF_TYPE_ARRAY_ENC(5, 10, 16), /* [4] */
3500 BTF_TYPEDEF_ENC(NAME_TBD, 6), /* [5] */
3501 BTF_TYPE_ARRAY_ENC(7, 10, 8), /* [6] */
3502 BTF_TYPEDEF_ENC(NAME_TBD, 8), /* [7] */
3503 BTF_TYPE_ARRAY_ENC(9, 10, 4), /* [8] */
3504 BTF_TYPEDEF_ENC(NAME_TBD, 10), /* [9] */
3505 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [10] */
3506 BTF_END_RAW,
3507 },
3508 BTF_STR_SEC("\0s\0a\0arr1_t\0arr2_t\0arr3_t\0int_t"),
3509 .map_type = BPF_MAP_TYPE_ARRAY,
3510 .map_name = "typedef_arra_mix_size_resolve_map",
3511 .key_size = sizeof(int),
3512 .value_size = sizeof(int) * 16 * 8 * 4,
3513 .key_type_id = 10 /* int */,
3514 .value_type_id = 3 /* arr_t */,
3515 .max_entries = 4,
3516 },
3517 /*
3518 * elf .rodata section size 4 and btf .rodata section vlen 0.
3519 */
3520 {
3521 .descr = "datasec: vlen == 0",
3522 .raw_types = {
3523 /* int */
3524 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3525 /* .rodata section */
3526 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 0), 4),
3527 /* [2] */
3528 BTF_END_RAW,
3529 },
3530 BTF_STR_SEC("\0.rodata"),
3531 .map_type = BPF_MAP_TYPE_ARRAY,
3532 .key_size = sizeof(int),
3533 .value_size = sizeof(int),
3534 .key_type_id = 1,
3535 .value_type_id = 1,
3536 .max_entries = 1,
3537 },
3538 {
3539 .descr = "datasec: name '?.foo bar:buz' is ok",
3540 .raw_types = {
3541 /* int */
3542 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3543 /* VAR x */ /* [2] */
3544 BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
3545 BTF_VAR_STATIC,
3546 /* DATASEC ?.data */ /* [3] */
3547 BTF_TYPE_ENC(3, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
3548 BTF_VAR_SECINFO_ENC(2, 0, 4),
3549 BTF_END_RAW,
3550 },
3551 BTF_STR_SEC("\0x\0?.foo bar:buz"),
3552 },
3553 {
3554 .descr = "datasec: name with non-printable first char not is ok",
3555 .raw_types = {
3556 /* int */
3557 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3558 /* VAR x */ /* [2] */
3559 BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
3560 BTF_VAR_STATIC,
3561 /* DATASEC ?.data */ /* [3] */
3562 BTF_TYPE_ENC(3, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
3563 BTF_VAR_SECINFO_ENC(2, 0, 4),
3564 BTF_END_RAW,
3565 },
3566 BTF_STR_SEC("\0x\0\7foo"),
3567 .err_str = "Invalid name",
3568 .btf_load_err = true,
3569 },
3570 {
3571 .descr = "datasec: name '\\0' is not ok",
3572 .raw_types = {
3573 /* int */
3574 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3575 /* VAR x */ /* [2] */
3576 BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
3577 BTF_VAR_STATIC,
3578 /* DATASEC \0 */ /* [3] */
3579 BTF_TYPE_ENC(3, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
3580 BTF_VAR_SECINFO_ENC(2, 0, 4),
3581 BTF_END_RAW,
3582 },
3583 BTF_STR_SEC("\0x\0"),
3584 .err_str = "Invalid name",
3585 .btf_load_err = true,
3586 },
3587 {
3588 .descr = "type name '?foo' is not ok",
3589 .raw_types = {
3590 /* union ?foo; */
3591 BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_FWD, 1, 0), 0), /* [1] */
3592 BTF_END_RAW,
3593 },
3594 BTF_STR_SEC("\0?foo"),
3595 .err_str = "Invalid name",
3596 .btf_load_err = true,
3597 },
3598
3599 {
3600 .descr = "float test #1, well-formed",
3601 .raw_types = {
3602 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3603 /* [1] */
3604 BTF_TYPE_FLOAT_ENC(NAME_TBD, 2), /* [2] */
3605 BTF_TYPE_FLOAT_ENC(NAME_TBD, 4), /* [3] */
3606 BTF_TYPE_FLOAT_ENC(NAME_TBD, 8), /* [4] */
3607 BTF_TYPE_FLOAT_ENC(NAME_TBD, 12), /* [5] */
3608 BTF_TYPE_FLOAT_ENC(NAME_TBD, 16), /* [6] */
3609 BTF_STRUCT_ENC(NAME_TBD, 5, 48), /* [7] */
3610 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3611 BTF_MEMBER_ENC(NAME_TBD, 3, 32),
3612 BTF_MEMBER_ENC(NAME_TBD, 4, 64),
3613 BTF_MEMBER_ENC(NAME_TBD, 5, 128),
3614 BTF_MEMBER_ENC(NAME_TBD, 6, 256),
3615 BTF_END_RAW,
3616 },
3617 BTF_STR_SEC("\0int\0_Float16\0float\0double\0_Float80\0long_double"
3618 "\0floats\0a\0b\0c\0d\0e"),
3619 .map_type = BPF_MAP_TYPE_ARRAY,
3620 .map_name = "float_type_check_btf",
3621 .key_size = sizeof(int),
3622 .value_size = 48,
3623 .key_type_id = 1,
3624 .value_type_id = 7,
3625 .max_entries = 1,
3626 },
3627 {
3628 .descr = "float test #2, invalid vlen",
3629 .raw_types = {
3630 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3631 /* [1] */
3632 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 1), 4),
3633 /* [2] */
3634 BTF_END_RAW,
3635 },
3636 BTF_STR_SEC("\0int\0float"),
3637 .map_type = BPF_MAP_TYPE_ARRAY,
3638 .map_name = "float_type_check_btf",
3639 .key_size = sizeof(int),
3640 .value_size = 4,
3641 .key_type_id = 1,
3642 .value_type_id = 2,
3643 .max_entries = 1,
3644 .btf_load_err = true,
3645 .err_str = "vlen != 0",
3646 },
3647 {
3648 .descr = "float test #3, invalid kind_flag",
3649 .raw_types = {
3650 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3651 /* [1] */
3652 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_FLOAT, 1, 0), 4),
3653 /* [2] */
3654 BTF_END_RAW,
3655 },
3656 BTF_STR_SEC("\0int\0float"),
3657 .map_type = BPF_MAP_TYPE_ARRAY,
3658 .map_name = "float_type_check_btf",
3659 .key_size = sizeof(int),
3660 .value_size = 4,
3661 .key_type_id = 1,
3662 .value_type_id = 2,
3663 .max_entries = 1,
3664 .btf_load_err = true,
3665 .err_str = "Invalid btf_info kind_flag",
3666 },
3667 {
3668 .descr = "float test #4, member does not fit",
3669 .raw_types = {
3670 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3671 /* [1] */
3672 BTF_TYPE_FLOAT_ENC(NAME_TBD, 4), /* [2] */
3673 BTF_STRUCT_ENC(NAME_TBD, 1, 2), /* [3] */
3674 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
3675 BTF_END_RAW,
3676 },
3677 BTF_STR_SEC("\0int\0float\0floats\0x"),
3678 .map_type = BPF_MAP_TYPE_ARRAY,
3679 .map_name = "float_type_check_btf",
3680 .key_size = sizeof(int),
3681 .value_size = 4,
3682 .key_type_id = 1,
3683 .value_type_id = 3,
3684 .max_entries = 1,
3685 .btf_load_err = true,
3686 .err_str = "Member exceeds struct_size",
3687 },
3688 {
3689 .descr = "float test #5, member is not properly aligned",
3690 .raw_types = {
3691 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3692 /* [1] */
3693 BTF_TYPE_FLOAT_ENC(NAME_TBD, 4), /* [2] */
3694 BTF_STRUCT_ENC(NAME_TBD, 1, 8), /* [3] */
3695 BTF_MEMBER_ENC(NAME_TBD, 2, 8),
3696 BTF_END_RAW,
3697 },
3698 BTF_STR_SEC("\0int\0float\0floats\0x"),
3699 .map_type = BPF_MAP_TYPE_ARRAY,
3700 .map_name = "float_type_check_btf",
3701 .key_size = sizeof(int),
3702 .value_size = 4,
3703 .key_type_id = 1,
3704 .value_type_id = 3,
3705 .max_entries = 1,
3706 .btf_load_err = true,
3707 .err_str = "Member is not properly aligned",
3708 },
3709 {
3710 .descr = "float test #6, invalid size",
3711 .raw_types = {
3712 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
3713 /* [1] */
3714 BTF_TYPE_FLOAT_ENC(NAME_TBD, 6), /* [2] */
3715 BTF_END_RAW,
3716 },
3717 BTF_STR_SEC("\0int\0float"),
3718 .map_type = BPF_MAP_TYPE_ARRAY,
3719 .map_name = "float_type_check_btf",
3720 .key_size = sizeof(int),
3721 .value_size = 6,
3722 .key_type_id = 1,
3723 .value_type_id = 2,
3724 .max_entries = 1,
3725 .btf_load_err = true,
3726 .err_str = "Invalid type_size",
3727 },
3728
3729 {
3730 .descr = "decl_tag test #1, struct/member, well-formed",
3731 .raw_types = {
3732 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3733 BTF_STRUCT_ENC(0, 2, 8), /* [2] */
3734 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3735 BTF_MEMBER_ENC(NAME_TBD, 1, 32),
3736 BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3737 BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3738 BTF_DECL_TAG_ENC(NAME_TBD, 2, 1),
3739 BTF_END_RAW,
3740 },
3741 BTF_STR_SEC("\0m1\0m2\0tag1\0tag2\0tag3"),
3742 .map_type = BPF_MAP_TYPE_ARRAY,
3743 .map_name = "tag_type_check_btf",
3744 .key_size = sizeof(int),
3745 .value_size = 8,
3746 .key_type_id = 1,
3747 .value_type_id = 2,
3748 .max_entries = 1,
3749 },
3750 {
3751 .descr = "decl_tag test #2, union/member, well-formed",
3752 .raw_types = {
3753 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3754 BTF_UNION_ENC(NAME_TBD, 2, 4), /* [2] */
3755 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3756 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3757 BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3758 BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3759 BTF_DECL_TAG_ENC(NAME_TBD, 2, 1),
3760 BTF_END_RAW,
3761 },
3762 BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
3763 .map_type = BPF_MAP_TYPE_ARRAY,
3764 .map_name = "tag_type_check_btf",
3765 .key_size = sizeof(int),
3766 .value_size = 4,
3767 .key_type_id = 1,
3768 .value_type_id = 2,
3769 .max_entries = 1,
3770 },
3771 {
3772 .descr = "decl_tag test #3, variable, well-formed",
3773 .raw_types = {
3774 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3775 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
3776 BTF_VAR_ENC(NAME_TBD, 1, 1), /* [3] */
3777 BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3778 BTF_DECL_TAG_ENC(NAME_TBD, 3, -1),
3779 BTF_END_RAW,
3780 },
3781 BTF_STR_SEC("\0local\0global\0tag1\0tag2"),
3782 .map_type = BPF_MAP_TYPE_ARRAY,
3783 .map_name = "tag_type_check_btf",
3784 .key_size = sizeof(int),
3785 .value_size = 4,
3786 .key_type_id = 1,
3787 .value_type_id = 1,
3788 .max_entries = 1,
3789 },
3790 {
3791 .descr = "decl_tag test #4, func/parameter, well-formed",
3792 .raw_types = {
3793 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3794 BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
3795 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3796 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3797 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
3798 BTF_DECL_TAG_ENC(NAME_TBD, 3, -1),
3799 BTF_DECL_TAG_ENC(NAME_TBD, 3, 0),
3800 BTF_DECL_TAG_ENC(NAME_TBD, 3, 1),
3801 BTF_END_RAW,
3802 },
3803 BTF_STR_SEC("\0arg1\0arg2\0f\0tag1\0tag2\0tag3"),
3804 .map_type = BPF_MAP_TYPE_ARRAY,
3805 .map_name = "tag_type_check_btf",
3806 .key_size = sizeof(int),
3807 .value_size = 4,
3808 .key_type_id = 1,
3809 .value_type_id = 1,
3810 .max_entries = 1,
3811 },
3812 {
3813 .descr = "decl_tag test #5, invalid value",
3814 .raw_types = {
3815 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3816 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
3817 BTF_DECL_TAG_ENC(0, 2, -1),
3818 BTF_END_RAW,
3819 },
3820 BTF_STR_SEC("\0local\0tag"),
3821 .map_type = BPF_MAP_TYPE_ARRAY,
3822 .map_name = "tag_type_check_btf",
3823 .key_size = sizeof(int),
3824 .value_size = 4,
3825 .key_type_id = 1,
3826 .value_type_id = 1,
3827 .max_entries = 1,
3828 .btf_load_err = true,
3829 .err_str = "Invalid value",
3830 },
3831 {
3832 .descr = "decl_tag test #6, invalid target type",
3833 .raw_types = {
3834 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3835 BTF_DECL_TAG_ENC(NAME_TBD, 1, -1),
3836 BTF_END_RAW,
3837 },
3838 BTF_STR_SEC("\0tag1"),
3839 .map_type = BPF_MAP_TYPE_ARRAY,
3840 .map_name = "tag_type_check_btf",
3841 .key_size = sizeof(int),
3842 .value_size = 4,
3843 .key_type_id = 1,
3844 .value_type_id = 1,
3845 .max_entries = 1,
3846 .btf_load_err = true,
3847 .err_str = "Invalid type",
3848 },
3849 {
3850 .descr = "decl_tag test #7, invalid vlen",
3851 .raw_types = {
3852 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3853 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
3854 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 1), 2), (0),
3855 BTF_END_RAW,
3856 },
3857 BTF_STR_SEC("\0local\0tag1"),
3858 .map_type = BPF_MAP_TYPE_ARRAY,
3859 .map_name = "tag_type_check_btf",
3860 .key_size = sizeof(int),
3861 .value_size = 4,
3862 .key_type_id = 1,
3863 .value_type_id = 1,
3864 .max_entries = 1,
3865 .btf_load_err = true,
3866 .err_str = "vlen != 0",
3867 },
3868 {
3869 .descr = "decl_tag test #8, tag with kflag",
3870 .raw_types = {
3871 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3872 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
3873 BTF_DECL_ATTR_ENC(NAME_TBD, 2, -1),
3874 BTF_END_RAW,
3875 },
3876 BTF_STR_SEC("\0local\0tag1"),
3877 .map_type = BPF_MAP_TYPE_ARRAY,
3878 .map_name = "tag_type_check_btf",
3879 .key_size = sizeof(int),
3880 .value_size = 4,
3881 .key_type_id = 1,
3882 .value_type_id = 1,
3883 .max_entries = 1,
3884 },
3885 {
3886 .descr = "decl_tag test #9, var, invalid component_idx",
3887 .raw_types = {
3888 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3889 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
3890 BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3891 BTF_END_RAW,
3892 },
3893 BTF_STR_SEC("\0local\0tag"),
3894 .map_type = BPF_MAP_TYPE_ARRAY,
3895 .map_name = "tag_type_check_btf",
3896 .key_size = sizeof(int),
3897 .value_size = 4,
3898 .key_type_id = 1,
3899 .value_type_id = 1,
3900 .max_entries = 1,
3901 .btf_load_err = true,
3902 .err_str = "Invalid component_idx",
3903 },
3904 {
3905 .descr = "decl_tag test #10, struct member, invalid component_idx",
3906 .raw_types = {
3907 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3908 BTF_STRUCT_ENC(0, 2, 8), /* [2] */
3909 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
3910 BTF_MEMBER_ENC(NAME_TBD, 1, 32),
3911 BTF_DECL_TAG_ENC(NAME_TBD, 2, 2),
3912 BTF_END_RAW,
3913 },
3914 BTF_STR_SEC("\0m1\0m2\0tag"),
3915 .map_type = BPF_MAP_TYPE_ARRAY,
3916 .map_name = "tag_type_check_btf",
3917 .key_size = sizeof(int),
3918 .value_size = 8,
3919 .key_type_id = 1,
3920 .value_type_id = 2,
3921 .max_entries = 1,
3922 .btf_load_err = true,
3923 .err_str = "Invalid component_idx",
3924 },
3925 {
3926 .descr = "decl_tag test #11, func parameter, invalid component_idx",
3927 .raw_types = {
3928 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3929 BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
3930 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3931 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3932 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
3933 BTF_DECL_TAG_ENC(NAME_TBD, 3, 2),
3934 BTF_END_RAW,
3935 },
3936 BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
3937 .map_type = BPF_MAP_TYPE_ARRAY,
3938 .map_name = "tag_type_check_btf",
3939 .key_size = sizeof(int),
3940 .value_size = 4,
3941 .key_type_id = 1,
3942 .value_type_id = 1,
3943 .max_entries = 1,
3944 .btf_load_err = true,
3945 .err_str = "Invalid component_idx",
3946 },
3947 {
3948 .descr = "decl_tag test #12, < -1 component_idx",
3949 .raw_types = {
3950 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3951 BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
3952 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3953 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
3954 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
3955 BTF_DECL_TAG_ENC(NAME_TBD, 3, -2),
3956 BTF_END_RAW,
3957 },
3958 BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
3959 .map_type = BPF_MAP_TYPE_ARRAY,
3960 .map_name = "tag_type_check_btf",
3961 .key_size = sizeof(int),
3962 .value_size = 4,
3963 .key_type_id = 1,
3964 .value_type_id = 1,
3965 .max_entries = 1,
3966 .btf_load_err = true,
3967 .err_str = "Invalid component_idx",
3968 },
3969 {
3970 .descr = "decl_tag test #13, typedef, well-formed",
3971 .raw_types = {
3972 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3973 BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [2] */
3974 BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
3975 BTF_END_RAW,
3976 },
3977 BTF_STR_SEC("\0t\0tag"),
3978 .map_type = BPF_MAP_TYPE_ARRAY,
3979 .map_name = "tag_type_check_btf",
3980 .key_size = sizeof(int),
3981 .value_size = 4,
3982 .key_type_id = 1,
3983 .value_type_id = 1,
3984 .max_entries = 1,
3985 },
3986 {
3987 .descr = "decl_tag test #14, typedef, invalid component_idx",
3988 .raw_types = {
3989 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
3990 BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [2] */
3991 BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
3992 BTF_END_RAW,
3993 },
3994 BTF_STR_SEC("\0local\0tag"),
3995 .map_type = BPF_MAP_TYPE_ARRAY,
3996 .map_name = "tag_type_check_btf",
3997 .key_size = sizeof(int),
3998 .value_size = 4,
3999 .key_type_id = 1,
4000 .value_type_id = 1,
4001 .max_entries = 1,
4002 .btf_load_err = true,
4003 .err_str = "Invalid component_idx",
4004 },
4005 {
4006 .descr = "decl_tag test #15, func, invalid func proto",
4007 .raw_types = {
4008 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4009 BTF_DECL_TAG_ENC(NAME_TBD, 3, 0), /* [2] */
4010 BTF_FUNC_ENC(NAME_TBD, 8), /* [3] */
4011 BTF_END_RAW,
4012 },
4013 BTF_STR_SEC("\0tag\0func"),
4014 .map_type = BPF_MAP_TYPE_ARRAY,
4015 .map_name = "tag_type_check_btf",
4016 .key_size = sizeof(int),
4017 .value_size = 4,
4018 .key_type_id = 1,
4019 .value_type_id = 1,
4020 .max_entries = 1,
4021 .btf_load_err = true,
4022 .err_str = "Invalid type_id",
4023 },
4024 {
4025 .descr = "decl_tag test #16, func proto, return type",
4026 .raw_types = {
4027 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4028 BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
4029 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), 2), (-1), /* [3] */
4030 BTF_FUNC_PROTO_ENC(3, 0), /* [4] */
4031 BTF_END_RAW,
4032 },
4033 BTF_STR_SEC("\0local\0tag1"),
4034 .btf_load_err = true,
4035 .err_str = "Invalid return type",
4036 },
4037 {
4038 .descr = "decl_tag test #17, func proto, argument",
4039 .raw_types = {
4040 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), 4), (-1), /* [1] */
4041 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0), /* [2] */
4042 BTF_FUNC_PROTO_ENC(0, 1), /* [3] */
4043 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
4044 BTF_VAR_ENC(NAME_TBD, 2, 0), /* [4] */
4045 BTF_END_RAW,
4046 },
4047 BTF_STR_SEC("\0local\0tag1\0var"),
4048 .btf_load_err = true,
4049 .err_str = "Invalid arg#1",
4050 },
4051 {
4052 .descr = "decl_tag test #18, decl_tag as the map key type",
4053 .raw_types = {
4054 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4055 BTF_STRUCT_ENC(0, 2, 8), /* [2] */
4056 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
4057 BTF_MEMBER_ENC(NAME_TBD, 1, 32),
4058 BTF_DECL_TAG_ENC(NAME_TBD, 2, -1), /* [3] */
4059 BTF_END_RAW,
4060 },
4061 BTF_STR_SEC("\0m1\0m2\0tag"),
4062 .map_type = BPF_MAP_TYPE_HASH,
4063 .map_name = "tag_type_check_btf",
4064 .key_size = 8,
4065 .value_size = 4,
4066 .key_type_id = 3,
4067 .value_type_id = 1,
4068 .max_entries = 1,
4069 .map_create_err = true,
4070 },
4071 {
4072 .descr = "decl_tag test #19, decl_tag as the map value type",
4073 .raw_types = {
4074 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4075 BTF_STRUCT_ENC(0, 2, 8), /* [2] */
4076 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
4077 BTF_MEMBER_ENC(NAME_TBD, 1, 32),
4078 BTF_DECL_TAG_ENC(NAME_TBD, 2, -1), /* [3] */
4079 BTF_END_RAW,
4080 },
4081 BTF_STR_SEC("\0m1\0m2\0tag"),
4082 .map_type = BPF_MAP_TYPE_HASH,
4083 .map_name = "tag_type_check_btf",
4084 .key_size = 4,
4085 .value_size = 8,
4086 .key_type_id = 1,
4087 .value_type_id = 3,
4088 .max_entries = 1,
4089 .map_create_err = true,
4090 },
4091 {
4092 .descr = "type_tag test #1",
4093 .raw_types = {
4094 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4095 BTF_TYPE_TAG_ENC(NAME_TBD, 1), /* [2] */
4096 BTF_PTR_ENC(2), /* [3] */
4097 BTF_END_RAW,
4098 },
4099 BTF_STR_SEC("\0tag"),
4100 .map_type = BPF_MAP_TYPE_ARRAY,
4101 .map_name = "tag_type_check_btf",
4102 .key_size = sizeof(int),
4103 .value_size = 4,
4104 .key_type_id = 1,
4105 .value_type_id = 1,
4106 .max_entries = 1,
4107 },
4108 {
4109 .descr = "type_tag test #2, type tag order",
4110 .raw_types = {
4111 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4112 BTF_CONST_ENC(3), /* [2] */
4113 BTF_TYPE_TAG_ENC(NAME_TBD, 1), /* [3] */
4114 BTF_END_RAW,
4115 },
4116 BTF_STR_SEC("\0tag"),
4117 .map_type = BPF_MAP_TYPE_ARRAY,
4118 .map_name = "tag_type_check_btf",
4119 .key_size = sizeof(int),
4120 .value_size = 4,
4121 .key_type_id = 1,
4122 .value_type_id = 1,
4123 .max_entries = 1,
4124 },
4125 {
4126 .descr = "type_tag test #3, type tag order",
4127 .raw_types = {
4128 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4129 BTF_TYPE_TAG_ENC(NAME_TBD, 3), /* [2] */
4130 BTF_CONST_ENC(4), /* [3] */
4131 BTF_TYPE_TAG_ENC(NAME_TBD, 1), /* [4] */
4132 BTF_END_RAW,
4133 },
4134 BTF_STR_SEC("\0tag\0tag"),
4135 .map_type = BPF_MAP_TYPE_ARRAY,
4136 .map_name = "tag_type_check_btf",
4137 .key_size = sizeof(int),
4138 .value_size = 4,
4139 .key_type_id = 1,
4140 .value_type_id = 1,
4141 .max_entries = 1,
4142 },
4143 {
4144 .descr = "type_tag test #4, type tag order",
4145 .raw_types = {
4146 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4147 BTF_TYPEDEF_ENC(NAME_TBD, 3), /* [2] */
4148 BTF_CONST_ENC(4), /* [3] */
4149 BTF_TYPE_TAG_ENC(NAME_TBD, 1), /* [4] */
4150 BTF_END_RAW,
4151 },
4152 BTF_STR_SEC("\0tag\0tag"),
4153 .map_type = BPF_MAP_TYPE_ARRAY,
4154 .map_name = "tag_type_check_btf",
4155 .key_size = sizeof(int),
4156 .value_size = 4,
4157 .key_type_id = 1,
4158 .value_type_id = 1,
4159 .max_entries = 1,
4160 },
4161 {
4162 .descr = "type_tag test #5, type tag order",
4163 .raw_types = {
4164 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4165 BTF_TYPE_TAG_ENC(NAME_TBD, 3), /* [2] */
4166 BTF_CONST_ENC(1), /* [3] */
4167 BTF_TYPE_TAG_ENC(NAME_TBD, 2), /* [4] */
4168 BTF_END_RAW,
4169 },
4170 BTF_STR_SEC("\0tag\0tag"),
4171 .map_type = BPF_MAP_TYPE_ARRAY,
4172 .map_name = "tag_type_check_btf",
4173 .key_size = sizeof(int),
4174 .value_size = 4,
4175 .key_type_id = 1,
4176 .value_type_id = 1,
4177 .max_entries = 1,
4178 },
4179 {
4180 .descr = "type_tag test #6, type tag order",
4181 .raw_types = {
4182 BTF_PTR_ENC(2), /* [1] */
4183 BTF_TYPE_TAG_ENC(NAME_TBD, 3), /* [2] */
4184 BTF_CONST_ENC(4), /* [3] */
4185 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [4] */
4186 BTF_PTR_ENC(6), /* [5] */
4187 BTF_CONST_ENC(2), /* [6] */
4188 BTF_END_RAW,
4189 },
4190 BTF_STR_SEC("\0tag"),
4191 .map_type = BPF_MAP_TYPE_ARRAY,
4192 .map_name = "tag_type_check_btf",
4193 .key_size = sizeof(int),
4194 .value_size = 4,
4195 .key_type_id = 4,
4196 .value_type_id = 4,
4197 .max_entries = 1,
4198 },
4199 {
4200 .descr = "type_tag test #7, tag with kflag",
4201 .raw_types = {
4202 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4203 BTF_TYPE_ATTR_ENC(NAME_TBD, 1), /* [2] */
4204 BTF_PTR_ENC(2), /* [3] */
4205 BTF_END_RAW,
4206 },
4207 BTF_STR_SEC("\0tag"),
4208 .map_type = BPF_MAP_TYPE_ARRAY,
4209 .map_name = "tag_type_check_btf",
4210 .key_size = sizeof(int),
4211 .value_size = 4,
4212 .key_type_id = 1,
4213 .value_type_id = 1,
4214 .max_entries = 1,
4215 },
4216 {
4217 .descr = "enum64 test #1, unsigned, size 8",
4218 .raw_types = {
4219 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4220 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 2), 8), /* [2] */
4221 BTF_ENUM64_ENC(NAME_TBD, 0, 0),
4222 BTF_ENUM64_ENC(NAME_TBD, 1, 1),
4223 BTF_END_RAW,
4224 },
4225 BTF_STR_SEC("\0a\0b\0c"),
4226 .map_type = BPF_MAP_TYPE_ARRAY,
4227 .map_name = "tag_type_check_btf",
4228 .key_size = sizeof(int),
4229 .value_size = 8,
4230 .key_type_id = 1,
4231 .value_type_id = 2,
4232 .max_entries = 1,
4233 },
4234 {
4235 .descr = "enum64 test #2, signed, size 4",
4236 .raw_types = {
4237 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4238 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 1, 2), 4), /* [2] */
4239 BTF_ENUM64_ENC(NAME_TBD, -1, 0),
4240 BTF_ENUM64_ENC(NAME_TBD, 1, 0),
4241 BTF_END_RAW,
4242 },
4243 BTF_STR_SEC("\0a\0b\0c"),
4244 .map_type = BPF_MAP_TYPE_ARRAY,
4245 .map_name = "tag_type_check_btf",
4246 .key_size = sizeof(int),
4247 .value_size = 4,
4248 .key_type_id = 1,
4249 .value_type_id = 2,
4250 .max_entries = 1,
4251 },
4252
4253 /*
4254 * struct inner {
4255 * struct bpf_spin_lock lock;
4256 * };
4257 *
4258 * struct value {
4259 * struct bpf_spin_lock lock;
4260 * struct inner nested;
4261 * };
4262 */
4263 {
4264 .descr = "struct test duplicate nested unique fields",
4265 .raw_types = {
4266 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4267 BTF_STRUCT_ENC(NAME_TBD, 1, 4), /* [2] */
4268 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
4269 BTF_STRUCT_ENC(NAME_TBD, 1, 4), /* [3] */
4270 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
4271 BTF_STRUCT_ENC(NAME_TBD, 2, 8), /* [4] */
4272 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
4273 BTF_MEMBER_ENC(NAME_TBD, 3, 32),
4274 BTF_END_RAW,
4275 },
4276 BTF_STR_SEC("\0int\0bpf_spin_lock\0val\0inner\0lock\0value\0lock\0nested"),
4277 .btf_load_err = true,
4278 },
4279
4280 /*
4281 * struct value {
4282 * struct bpf_refcount a;
4283 * struct bpf_refcount b;
4284 * };
4285 */
4286 {
4287 .descr = "struct test duplicate bpf_refcount fields",
4288 .raw_types = {
4289 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4290 BTF_STRUCT_ENC(NAME_TBD, 1, 4), /* [2] */
4291 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
4292 BTF_STRUCT_ENC(NAME_TBD, 2, 8), /* [3] */
4293 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
4294 BTF_MEMBER_ENC(NAME_TBD, 2, 32),
4295 BTF_END_RAW,
4296 },
4297 BTF_STR_SEC("\0int\0bpf_refcount\0refs\0value\0a\0b"),
4298 .btf_load_err = true,
4299 },
4300
4301 {
4302 .descr = "struct test repeated fields count overflow",
4303 .raw_types = {
4304 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
4305 BTF_STRUCT_ENC(NAME_TBD, 0, 0), /* [2] */
4306 BTF_TYPE_TAG_ENC(NAME_TBD, 2), /* [3] */
4307 BTF_PTR_ENC(3), /* [4] */
4308 BTF_TYPE_ARRAY_ENC(4, 1, 1), /* [5] */
4309 BTF_STRUCT_ENC(NAME_TBD, 10, 8), /* [6] */
4310 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4311 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4312 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4313 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4314 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4315 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4316 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4317 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4318 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4319 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
4320 BTF_TYPE_ARRAY_ENC(6, 1, 0x1999999aU), /* [7] */
4321 BTF_STRUCT_ENC(NAME_TBD, 2, 8 + 8 * 0x1999999aU), /* [8] */
4322 BTF_MEMBER_ENC(NAME_TBD, 4, 0),
4323 BTF_MEMBER_ENC(NAME_TBD, 7, 64),
4324 BTF_END_RAW,
4325 },
4326 BTF_STR_SEC("\0int\0prog_test_ref_kfunc\0kptr_untrusted\0elem"
4327 "\0p0\0p1\0p2\0p3\0p4\0p5\0p6\0p7\0p8\0p9"
4328 "\0outer\0trigger\0elems"),
4329 .map_type = BPF_MAP_TYPE_ARRAY,
4330 .map_name = "repeat_fields",
4331 .key_size = sizeof(int),
4332 .value_size = 8 + 8 * 0x1999999aU,
4333 .key_type_id = 1,
4334 .value_type_id = 8,
4335 .max_entries = 1,
4336 .btf_load_err = true,
4337 },
4338 }; /* struct btf_raw_test raw_tests[] */
4339
get_next_str(const char * start,const char * end)4340 static const char *get_next_str(const char *start, const char *end)
4341 {
4342 return start < end - 1 ? start + 1 : NULL;
4343 }
4344
get_raw_sec_size(const __u32 * raw_types)4345 static int get_raw_sec_size(const __u32 *raw_types)
4346 {
4347 int i;
4348
4349 for (i = MAX_NR_RAW_U32 - 1;
4350 i >= 0 && raw_types[i] != BTF_END_RAW;
4351 i--)
4352 ;
4353
4354 return i < 0 ? i : i * sizeof(raw_types[0]);
4355 }
4356
btf_raw_create(const struct btf_header * hdr,const __u32 * raw_types,const char * str,unsigned int str_sec_size,unsigned int * btf_size,const char ** ret_next_str)4357 static void *btf_raw_create(const struct btf_header *hdr,
4358 const __u32 *raw_types,
4359 const char *str,
4360 unsigned int str_sec_size,
4361 unsigned int *btf_size,
4362 const char **ret_next_str)
4363 {
4364 const char *next_str = str, *end_str = str + str_sec_size;
4365 const char **strs_idx = NULL, **tmp_strs_idx;
4366 int strs_cap = 0, strs_cnt = 0, next_str_idx = 0;
4367 unsigned int size_needed, offset;
4368 struct btf_header *ret_hdr;
4369 int i, type_sec_size, err = 0;
4370 uint32_t *ret_types;
4371 void *raw_btf = NULL;
4372
4373 type_sec_size = get_raw_sec_size(raw_types);
4374 if (CHECK(type_sec_size < 0, "Cannot get nr_raw_types"))
4375 return NULL;
4376
4377 size_needed = sizeof(*hdr) + type_sec_size + str_sec_size;
4378 raw_btf = malloc(size_needed);
4379 if (CHECK(!raw_btf, "Cannot allocate memory for raw_btf"))
4380 return NULL;
4381
4382 /* Copy header */
4383 memcpy(raw_btf, hdr, sizeof(*hdr));
4384 offset = sizeof(*hdr);
4385
4386 /* Index strings */
4387 while ((next_str = get_next_str(next_str, end_str))) {
4388 if (strs_cnt == strs_cap) {
4389 strs_cap += max(16, strs_cap / 2);
4390 tmp_strs_idx = realloc(strs_idx,
4391 sizeof(*strs_idx) * strs_cap);
4392 if (CHECK(!tmp_strs_idx,
4393 "Cannot allocate memory for strs_idx")) {
4394 err = -1;
4395 goto done;
4396 }
4397 strs_idx = tmp_strs_idx;
4398 }
4399 strs_idx[strs_cnt++] = next_str;
4400 next_str += strlen(next_str);
4401 }
4402
4403 /* Copy type section */
4404 ret_types = raw_btf + offset;
4405 for (i = 0; i < type_sec_size / sizeof(raw_types[0]); i++) {
4406 if (raw_types[i] == NAME_TBD) {
4407 if (CHECK(next_str_idx == strs_cnt,
4408 "Error in getting next_str #%d",
4409 next_str_idx)) {
4410 err = -1;
4411 goto done;
4412 }
4413 ret_types[i] = strs_idx[next_str_idx++] - str;
4414 } else if (IS_NAME_NTH(raw_types[i])) {
4415 int idx = GET_NAME_NTH_IDX(raw_types[i]);
4416
4417 if (CHECK(idx <= 0 || idx > strs_cnt,
4418 "Error getting string #%d, strs_cnt:%d",
4419 idx, strs_cnt)) {
4420 err = -1;
4421 goto done;
4422 }
4423 ret_types[i] = strs_idx[idx-1] - str;
4424 } else {
4425 ret_types[i] = raw_types[i];
4426 }
4427 }
4428 offset += type_sec_size;
4429
4430 /* Copy string section */
4431 memcpy(raw_btf + offset, str, str_sec_size);
4432
4433 ret_hdr = (struct btf_header *)raw_btf;
4434 ret_hdr->type_len = type_sec_size;
4435 ret_hdr->str_off = type_sec_size;
4436 ret_hdr->str_len = str_sec_size;
4437
4438 *btf_size = size_needed;
4439 if (ret_next_str)
4440 *ret_next_str =
4441 next_str_idx < strs_cnt ? strs_idx[next_str_idx] : NULL;
4442
4443 done:
4444 free(strs_idx);
4445 if (err) {
4446 free(raw_btf);
4447 return NULL;
4448 }
4449 return raw_btf;
4450 }
4451
load_raw_btf(const void * raw_data,size_t raw_size)4452 static int load_raw_btf(const void *raw_data, size_t raw_size)
4453 {
4454 LIBBPF_OPTS(bpf_btf_load_opts, opts);
4455 int btf_fd;
4456
4457 if (always_log) {
4458 opts.log_buf = btf_log_buf,
4459 opts.log_size = BTF_LOG_BUF_SIZE,
4460 opts.log_level = 1;
4461 }
4462
4463 btf_fd = bpf_btf_load(raw_data, raw_size, &opts);
4464 if (btf_fd < 0 && !always_log) {
4465 opts.log_buf = btf_log_buf,
4466 opts.log_size = BTF_LOG_BUF_SIZE,
4467 opts.log_level = 1;
4468 btf_fd = bpf_btf_load(raw_data, raw_size, &opts);
4469 }
4470
4471 return btf_fd;
4472 }
4473
do_test_raw(unsigned int test_num)4474 static void do_test_raw(unsigned int test_num)
4475 {
4476 struct btf_raw_test *test = &raw_tests[test_num - 1];
4477 LIBBPF_OPTS(bpf_map_create_opts, opts);
4478 int map_fd = -1, btf_fd = -1;
4479 unsigned int raw_btf_size;
4480 struct btf_header *hdr;
4481 void *raw_btf;
4482 int err;
4483
4484 if (!test__start_subtest(test->descr))
4485 return;
4486
4487 raw_btf = btf_raw_create(&hdr_tmpl,
4488 test->raw_types,
4489 test->str_sec,
4490 test->str_sec_size,
4491 &raw_btf_size, NULL);
4492 if (!raw_btf)
4493 return;
4494
4495 hdr = raw_btf;
4496
4497 hdr->hdr_len = (int)hdr->hdr_len + test->hdr_len_delta;
4498 hdr->type_off = (int)hdr->type_off + test->type_off_delta;
4499 hdr->str_off = (int)hdr->str_off + test->str_off_delta;
4500 hdr->str_len = (int)hdr->str_len + test->str_len_delta;
4501
4502 *btf_log_buf = '\0';
4503 btf_fd = load_raw_btf(raw_btf, raw_btf_size);
4504 free(raw_btf);
4505
4506 err = ((btf_fd < 0) != test->btf_load_err);
4507 if (CHECK(err, "btf_fd:%d test->btf_load_err:%u",
4508 btf_fd, test->btf_load_err) ||
4509 CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
4510 "expected err_str:%s\n", test->err_str)) {
4511 err = -1;
4512 goto done;
4513 }
4514
4515 if (err || btf_fd < 0)
4516 goto done;
4517
4518 if (!test->map_type)
4519 goto done;
4520
4521 opts.btf_fd = btf_fd;
4522 opts.btf_key_type_id = test->key_type_id;
4523 opts.btf_value_type_id = test->value_type_id;
4524 map_fd = bpf_map_create(test->map_type, test->map_name,
4525 test->key_size, test->value_size, test->max_entries, &opts);
4526
4527 err = ((map_fd < 0) != test->map_create_err);
4528 CHECK(err, "map_fd:%d test->map_create_err:%u",
4529 map_fd, test->map_create_err);
4530
4531 done:
4532 if (*btf_log_buf && (err || always_log))
4533 fprintf(stderr, "\n%s", btf_log_buf);
4534 if (btf_fd >= 0)
4535 close(btf_fd);
4536 if (map_fd >= 0)
4537 close(map_fd);
4538 }
4539
4540 struct btf_get_info_test {
4541 const char *descr;
4542 const char *str_sec;
4543 __u32 raw_types[MAX_NR_RAW_U32];
4544 __u32 str_sec_size;
4545 int btf_size_delta;
4546 int (*special_test)(unsigned int test_num);
4547 };
4548
4549 static int test_big_btf_info(unsigned int test_num);
4550 static int test_btf_id(unsigned int test_num);
4551
4552 const struct btf_get_info_test get_info_tests[] = {
4553 {
4554 .descr = "== raw_btf_size+1",
4555 .raw_types = {
4556 /* int */ /* [1] */
4557 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4558 BTF_END_RAW,
4559 },
4560 .str_sec = "",
4561 .str_sec_size = sizeof(""),
4562 .btf_size_delta = 1,
4563 },
4564 {
4565 .descr = "== raw_btf_size-3",
4566 .raw_types = {
4567 /* int */ /* [1] */
4568 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4569 BTF_END_RAW,
4570 },
4571 .str_sec = "",
4572 .str_sec_size = sizeof(""),
4573 .btf_size_delta = -3,
4574 },
4575 {
4576 .descr = "Large bpf_btf_info",
4577 .raw_types = {
4578 /* int */ /* [1] */
4579 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4580 BTF_END_RAW,
4581 },
4582 .str_sec = "",
4583 .str_sec_size = sizeof(""),
4584 .special_test = test_big_btf_info,
4585 },
4586 {
4587 .descr = "BTF ID",
4588 .raw_types = {
4589 /* int */ /* [1] */
4590 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
4591 /* unsigned int */ /* [2] */
4592 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),
4593 BTF_END_RAW,
4594 },
4595 .str_sec = "",
4596 .str_sec_size = sizeof(""),
4597 .special_test = test_btf_id,
4598 },
4599 };
4600
test_big_btf_info(unsigned int test_num)4601 static int test_big_btf_info(unsigned int test_num)
4602 {
4603 const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
4604 uint8_t *raw_btf = NULL, *user_btf = NULL;
4605 unsigned int raw_btf_size;
4606 struct {
4607 struct bpf_btf_info info;
4608 uint64_t garbage;
4609 } info_garbage;
4610 struct bpf_btf_info *info;
4611 int btf_fd = -1, err;
4612 uint32_t info_len;
4613
4614 raw_btf = btf_raw_create(&hdr_tmpl,
4615 test->raw_types,
4616 test->str_sec,
4617 test->str_sec_size,
4618 &raw_btf_size, NULL);
4619
4620 if (!raw_btf)
4621 return -1;
4622
4623 *btf_log_buf = '\0';
4624
4625 user_btf = malloc(raw_btf_size);
4626 if (CHECK(!user_btf, "!user_btf")) {
4627 err = -1;
4628 goto done;
4629 }
4630
4631 btf_fd = load_raw_btf(raw_btf, raw_btf_size);
4632 if (CHECK(btf_fd < 0, "errno:%d", errno)) {
4633 err = -1;
4634 goto done;
4635 }
4636
4637 /*
4638 * GET_INFO should error out if the userspace info
4639 * has non zero tailing bytes.
4640 */
4641 info = &info_garbage.info;
4642 memset(info, 0, sizeof(*info));
4643 info_garbage.garbage = 0xdeadbeef;
4644 info_len = sizeof(info_garbage);
4645 info->btf = ptr_to_u64(user_btf);
4646 info->btf_size = raw_btf_size;
4647
4648 err = bpf_btf_get_info_by_fd(btf_fd, info, &info_len);
4649 if (CHECK(!err, "!err")) {
4650 err = -1;
4651 goto done;
4652 }
4653
4654 /*
4655 * GET_INFO should succeed even info_len is larger than
4656 * the kernel supported as long as tailing bytes are zero.
4657 * The kernel supported info len should also be returned
4658 * to userspace.
4659 */
4660 info_garbage.garbage = 0;
4661 err = bpf_btf_get_info_by_fd(btf_fd, info, &info_len);
4662 if (CHECK(err || info_len != sizeof(*info),
4663 "err:%d errno:%d info_len:%u sizeof(*info):%zu",
4664 err, errno, info_len, sizeof(*info))) {
4665 err = -1;
4666 goto done;
4667 }
4668
4669 fprintf(stderr, "OK");
4670
4671 done:
4672 if (*btf_log_buf && (err || always_log))
4673 fprintf(stderr, "\n%s", btf_log_buf);
4674
4675 free(raw_btf);
4676 free(user_btf);
4677
4678 if (btf_fd >= 0)
4679 close(btf_fd);
4680
4681 return err;
4682 }
4683
test_btf_id(unsigned int test_num)4684 static int test_btf_id(unsigned int test_num)
4685 {
4686 const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
4687 LIBBPF_OPTS(bpf_map_create_opts, opts);
4688 uint8_t *raw_btf = NULL, *user_btf[2] = {};
4689 int btf_fd[2] = {-1, -1}, map_fd = -1;
4690 struct bpf_map_info map_info = {};
4691 struct bpf_btf_info info[2] = {};
4692 unsigned int raw_btf_size;
4693 uint32_t info_len;
4694 int err, i, ret;
4695
4696 raw_btf = btf_raw_create(&hdr_tmpl,
4697 test->raw_types,
4698 test->str_sec,
4699 test->str_sec_size,
4700 &raw_btf_size, NULL);
4701
4702 if (!raw_btf)
4703 return -1;
4704
4705 *btf_log_buf = '\0';
4706
4707 for (i = 0; i < 2; i++) {
4708 user_btf[i] = malloc(raw_btf_size);
4709 if (CHECK(!user_btf[i], "!user_btf[%d]", i)) {
4710 err = -1;
4711 goto done;
4712 }
4713 info[i].btf = ptr_to_u64(user_btf[i]);
4714 info[i].btf_size = raw_btf_size;
4715 }
4716
4717 btf_fd[0] = load_raw_btf(raw_btf, raw_btf_size);
4718 if (CHECK(btf_fd[0] < 0, "errno:%d", errno)) {
4719 err = -1;
4720 goto done;
4721 }
4722
4723 /* Test BPF_OBJ_GET_INFO_BY_ID on btf_id */
4724 info_len = sizeof(info[0]);
4725 err = bpf_btf_get_info_by_fd(btf_fd[0], &info[0], &info_len);
4726 if (CHECK(err, "errno:%d", errno)) {
4727 err = -1;
4728 goto done;
4729 }
4730
4731 btf_fd[1] = bpf_btf_get_fd_by_id(info[0].id);
4732 if (CHECK(btf_fd[1] < 0, "errno:%d", errno)) {
4733 err = -1;
4734 goto done;
4735 }
4736
4737 ret = 0;
4738 err = bpf_btf_get_info_by_fd(btf_fd[1], &info[1], &info_len);
4739 if (CHECK(err || info[0].id != info[1].id ||
4740 info[0].btf_size != info[1].btf_size ||
4741 (ret = memcmp(user_btf[0], user_btf[1], info[0].btf_size)),
4742 "err:%d errno:%d id0:%u id1:%u btf_size0:%u btf_size1:%u memcmp:%d",
4743 err, errno, info[0].id, info[1].id,
4744 info[0].btf_size, info[1].btf_size, ret)) {
4745 err = -1;
4746 goto done;
4747 }
4748
4749 /* Test btf members in struct bpf_map_info */
4750 opts.btf_fd = btf_fd[0];
4751 opts.btf_key_type_id = 1;
4752 opts.btf_value_type_id = 2;
4753 map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "test_btf_id",
4754 sizeof(int), sizeof(int), 4, &opts);
4755 if (CHECK(map_fd < 0, "errno:%d", errno)) {
4756 err = -1;
4757 goto done;
4758 }
4759
4760 info_len = sizeof(map_info);
4761 err = bpf_map_get_info_by_fd(map_fd, &map_info, &info_len);
4762 if (CHECK(err || map_info.btf_id != info[0].id ||
4763 map_info.btf_key_type_id != 1 || map_info.btf_value_type_id != 2,
4764 "err:%d errno:%d info.id:%u btf_id:%u btf_key_type_id:%u btf_value_type_id:%u",
4765 err, errno, info[0].id, map_info.btf_id, map_info.btf_key_type_id,
4766 map_info.btf_value_type_id)) {
4767 err = -1;
4768 goto done;
4769 }
4770
4771 for (i = 0; i < 2; i++) {
4772 close(btf_fd[i]);
4773 btf_fd[i] = -1;
4774 }
4775
4776 /* Test BTF ID is removed from the kernel */
4777 btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);
4778 if (CHECK(btf_fd[0] < 0, "errno:%d", errno)) {
4779 err = -1;
4780 goto done;
4781 }
4782 close(btf_fd[0]);
4783 btf_fd[0] = -1;
4784
4785 /* The map holds the last ref to BTF and its btf_id */
4786 close(map_fd);
4787 map_fd = -1;
4788
4789 fprintf(stderr, "OK");
4790
4791 done:
4792 if (*btf_log_buf && (err || always_log))
4793 fprintf(stderr, "\n%s", btf_log_buf);
4794
4795 free(raw_btf);
4796 if (map_fd >= 0)
4797 close(map_fd);
4798 for (i = 0; i < 2; i++) {
4799 free(user_btf[i]);
4800 if (btf_fd[i] >= 0)
4801 close(btf_fd[i]);
4802 }
4803
4804 return err;
4805 }
4806
do_test_get_info(unsigned int test_num)4807 static void do_test_get_info(unsigned int test_num)
4808 {
4809 const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
4810 unsigned int raw_btf_size, user_btf_size, expected_nbytes;
4811 uint8_t *raw_btf = NULL, *user_btf = NULL;
4812 struct bpf_btf_info info = {};
4813 int btf_fd = -1, err, ret;
4814 uint32_t info_len;
4815
4816 if (!test__start_subtest(test->descr))
4817 return;
4818
4819 if (test->special_test) {
4820 err = test->special_test(test_num);
4821 if (CHECK(err, "failed: %d\n", err))
4822 return;
4823 }
4824
4825 raw_btf = btf_raw_create(&hdr_tmpl,
4826 test->raw_types,
4827 test->str_sec,
4828 test->str_sec_size,
4829 &raw_btf_size, NULL);
4830
4831 if (!raw_btf)
4832 return;
4833
4834 *btf_log_buf = '\0';
4835
4836 user_btf = malloc(raw_btf_size);
4837 if (CHECK(!user_btf, "!user_btf")) {
4838 err = -1;
4839 goto done;
4840 }
4841
4842 btf_fd = load_raw_btf(raw_btf, raw_btf_size);
4843 if (CHECK(btf_fd <= 0, "errno:%d", errno)) {
4844 err = -1;
4845 goto done;
4846 }
4847
4848 user_btf_size = (int)raw_btf_size + test->btf_size_delta;
4849 expected_nbytes = min(raw_btf_size, user_btf_size);
4850 if (raw_btf_size > expected_nbytes)
4851 memset(user_btf + expected_nbytes, 0xff,
4852 raw_btf_size - expected_nbytes);
4853
4854 info_len = sizeof(info);
4855 info.btf = ptr_to_u64(user_btf);
4856 info.btf_size = user_btf_size;
4857
4858 ret = 0;
4859 err = bpf_btf_get_info_by_fd(btf_fd, &info, &info_len);
4860 if (CHECK(err || !info.id || info_len != sizeof(info) ||
4861 info.btf_size != raw_btf_size ||
4862 (ret = memcmp(raw_btf, user_btf, expected_nbytes)),
4863 "err:%d errno:%d info.id:%u info_len:%u sizeof(info):%zu raw_btf_size:%u info.btf_size:%u expected_nbytes:%u memcmp:%d",
4864 err, errno, info.id, info_len, sizeof(info),
4865 raw_btf_size, info.btf_size, expected_nbytes, ret)) {
4866 err = -1;
4867 goto done;
4868 }
4869
4870 while (expected_nbytes < raw_btf_size) {
4871 fprintf(stderr, "%u...", expected_nbytes);
4872 if (CHECK(user_btf[expected_nbytes++] != 0xff,
4873 "user_btf[%u]:%x != 0xff", expected_nbytes - 1,
4874 user_btf[expected_nbytes - 1])) {
4875 err = -1;
4876 goto done;
4877 }
4878 }
4879
4880 fprintf(stderr, "OK");
4881
4882 done:
4883 if (*btf_log_buf && (err || always_log))
4884 fprintf(stderr, "\n%s", btf_log_buf);
4885
4886 free(raw_btf);
4887 free(user_btf);
4888
4889 if (btf_fd >= 0)
4890 close(btf_fd);
4891 }
4892
4893 struct btf_file_test {
4894 const char *file;
4895 bool btf_kv_notfound;
4896 };
4897
4898 static struct btf_file_test file_tests[] = {
4899 { .file = "test_btf_newkv.bpf.o", },
4900 { .file = "test_btf_nokv.bpf.o", .btf_kv_notfound = true, },
4901 };
4902
do_test_file(unsigned int test_num)4903 static void do_test_file(unsigned int test_num)
4904 {
4905 const struct btf_file_test *test = &file_tests[test_num - 1];
4906 const char *expected_fnames[] = {"_dummy_tracepoint",
4907 "test_long_fname_1",
4908 "test_long_fname_2"};
4909 struct btf_ext *btf_ext = NULL;
4910 struct bpf_prog_info info = {};
4911 struct bpf_object *obj = NULL;
4912 struct bpf_func_info *finfo;
4913 struct bpf_program *prog;
4914 __u32 info_len, rec_size;
4915 bool has_btf_ext = false;
4916 struct btf *btf = NULL;
4917 void *func_info = NULL;
4918 struct bpf_map *map;
4919 int i, err, prog_fd;
4920
4921 if (!test__start_subtest(test->file))
4922 return;
4923
4924 btf = btf__parse_elf(test->file, &btf_ext);
4925 err = libbpf_get_error(btf);
4926 if (err) {
4927 if (err == -ENOENT) {
4928 printf("%s:SKIP: No ELF %s found", __func__, BTF_ELF_SEC);
4929 test__skip();
4930 return;
4931 }
4932 return;
4933 }
4934 btf__free(btf);
4935
4936 has_btf_ext = btf_ext != NULL;
4937 btf_ext__free(btf_ext);
4938
4939 /* temporary disable LIBBPF_STRICT_MAP_DEFINITIONS to test legacy maps */
4940 libbpf_set_strict_mode(LIBBPF_STRICT_ALL & ~LIBBPF_STRICT_MAP_DEFINITIONS);
4941 obj = bpf_object__open(test->file);
4942 err = libbpf_get_error(obj);
4943 if (CHECK(err, "obj: %d", err))
4944 return;
4945
4946 prog = bpf_object__next_program(obj, NULL);
4947 if (CHECK(!prog, "Cannot find bpf_prog")) {
4948 err = -1;
4949 goto done;
4950 }
4951
4952 bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);
4953 err = bpf_object__load(obj);
4954 if (CHECK(err < 0, "bpf_object__load: %d", err))
4955 goto done;
4956 prog_fd = bpf_program__fd(prog);
4957
4958 map = bpf_object__find_map_by_name(obj, "btf_map");
4959 if (CHECK(!map, "btf_map not found")) {
4960 err = -1;
4961 goto done;
4962 }
4963
4964 err = (bpf_map__btf_key_type_id(map) == 0 || bpf_map__btf_value_type_id(map) == 0)
4965 != test->btf_kv_notfound;
4966 if (CHECK(err, "btf_key_type_id:%u btf_value_type_id:%u test->btf_kv_notfound:%u",
4967 bpf_map__btf_key_type_id(map), bpf_map__btf_value_type_id(map),
4968 test->btf_kv_notfound))
4969 goto done;
4970
4971 if (!has_btf_ext)
4972 goto skip;
4973
4974 /* get necessary program info */
4975 info_len = sizeof(struct bpf_prog_info);
4976 err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
4977
4978 if (CHECK(err < 0, "invalid get info (1st) errno:%d", errno)) {
4979 fprintf(stderr, "%s\n", btf_log_buf);
4980 err = -1;
4981 goto done;
4982 }
4983 if (CHECK(info.nr_func_info != 3,
4984 "incorrect info.nr_func_info (1st) %d",
4985 info.nr_func_info)) {
4986 err = -1;
4987 goto done;
4988 }
4989 rec_size = info.func_info_rec_size;
4990 if (CHECK(rec_size != sizeof(struct bpf_func_info),
4991 "incorrect info.func_info_rec_size (1st) %d\n", rec_size)) {
4992 err = -1;
4993 goto done;
4994 }
4995
4996 func_info = malloc(info.nr_func_info * rec_size);
4997 if (CHECK(!func_info, "out of memory")) {
4998 err = -1;
4999 goto done;
5000 }
5001
5002 /* reset info to only retrieve func_info related data */
5003 memset(&info, 0, sizeof(info));
5004 info.nr_func_info = 3;
5005 info.func_info_rec_size = rec_size;
5006 info.func_info = ptr_to_u64(func_info);
5007
5008 err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
5009
5010 if (CHECK(err < 0, "invalid get info (2nd) errno:%d", errno)) {
5011 fprintf(stderr, "%s\n", btf_log_buf);
5012 err = -1;
5013 goto done;
5014 }
5015 if (CHECK(info.nr_func_info != 3,
5016 "incorrect info.nr_func_info (2nd) %d",
5017 info.nr_func_info)) {
5018 err = -1;
5019 goto done;
5020 }
5021 if (CHECK(info.func_info_rec_size != rec_size,
5022 "incorrect info.func_info_rec_size (2nd) %d",
5023 info.func_info_rec_size)) {
5024 err = -1;
5025 goto done;
5026 }
5027
5028 btf = btf__load_from_kernel_by_id(info.btf_id);
5029 err = libbpf_get_error(btf);
5030 if (CHECK(err, "cannot get btf from kernel, err: %d", err))
5031 goto done;
5032
5033 /* check three functions */
5034 finfo = func_info;
5035 for (i = 0; i < 3; i++) {
5036 const struct btf_type *t;
5037 const char *fname;
5038
5039 t = btf__type_by_id(btf, finfo->type_id);
5040 if (CHECK(!t, "btf__type_by_id failure: id %u",
5041 finfo->type_id)) {
5042 err = -1;
5043 goto done;
5044 }
5045
5046 fname = btf__name_by_offset(btf, t->name_off);
5047 err = strcmp(fname, expected_fnames[i]);
5048 /* for the second and third functions in .text section,
5049 * the compiler may order them either way.
5050 */
5051 if (i && err)
5052 err = strcmp(fname, expected_fnames[3 - i]);
5053 if (CHECK(err, "incorrect fname %s", fname ? : "")) {
5054 err = -1;
5055 goto done;
5056 }
5057
5058 finfo = (void *)finfo + rec_size;
5059 }
5060
5061 skip:
5062 fprintf(stderr, "OK");
5063
5064 done:
5065 libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
5066
5067 btf__free(btf);
5068 free(func_info);
5069 bpf_object__close(obj);
5070 }
5071
5072 const char *pprint_enum_str[] = {
5073 "ENUM_ZERO",
5074 "ENUM_ONE",
5075 "ENUM_TWO",
5076 "ENUM_THREE",
5077 };
5078
5079 struct pprint_mapv {
5080 uint32_t ui32;
5081 uint16_t ui16;
5082 /* 2 bytes hole */
5083 int32_t si32;
5084 uint32_t unused_bits2a:2,
5085 bits28:28,
5086 unused_bits2b:2;
5087 union {
5088 uint64_t ui64;
5089 uint8_t ui8a[8];
5090 };
5091 enum {
5092 ENUM_ZERO,
5093 ENUM_ONE,
5094 ENUM_TWO,
5095 ENUM_THREE,
5096 } aenum;
5097 uint32_t ui32b;
5098 uint32_t bits2c:2;
5099 uint8_t si8_4[2][2];
5100 };
5101
5102 #ifdef __SIZEOF_INT128__
5103 struct pprint_mapv_int128 {
5104 __int128 si128a;
5105 __int128 si128b;
5106 unsigned __int128 bits3:3;
5107 unsigned __int128 bits80:80;
5108 unsigned __int128 ui128;
5109 };
5110 #endif
5111
5112 static struct btf_raw_test pprint_test_template[] = {
5113 {
5114 .raw_types = {
5115 /* unsigned char */ /* [1] */
5116 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
5117 /* unsigned short */ /* [2] */
5118 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
5119 /* unsigned int */ /* [3] */
5120 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
5121 /* int */ /* [4] */
5122 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
5123 /* unsigned long long */ /* [5] */
5124 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
5125 /* 2 bits */ /* [6] */
5126 BTF_TYPE_INT_ENC(0, 0, 0, 2, 2),
5127 /* 28 bits */ /* [7] */
5128 BTF_TYPE_INT_ENC(0, 0, 0, 28, 4),
5129 /* uint8_t[8] */ /* [8] */
5130 BTF_TYPE_ARRAY_ENC(9, 1, 8),
5131 /* typedef unsigned char uint8_t */ /* [9] */
5132 BTF_TYPEDEF_ENC(NAME_TBD, 1),
5133 /* typedef unsigned short uint16_t */ /* [10] */
5134 BTF_TYPEDEF_ENC(NAME_TBD, 2),
5135 /* typedef unsigned int uint32_t */ /* [11] */
5136 BTF_TYPEDEF_ENC(NAME_TBD, 3),
5137 /* typedef int int32_t */ /* [12] */
5138 BTF_TYPEDEF_ENC(NAME_TBD, 4),
5139 /* typedef unsigned long long uint64_t *//* [13] */
5140 BTF_TYPEDEF_ENC(NAME_TBD, 5),
5141 /* union (anon) */ /* [14] */
5142 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
5143 BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
5144 BTF_MEMBER_ENC(NAME_TBD, 8, 0), /* uint8_t ui8a[8]; */
5145 /* enum (anon) */ /* [15] */
5146 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
5147 BTF_ENUM_ENC(NAME_TBD, 0),
5148 BTF_ENUM_ENC(NAME_TBD, 1),
5149 BTF_ENUM_ENC(NAME_TBD, 2),
5150 BTF_ENUM_ENC(NAME_TBD, 3),
5151 /* struct pprint_mapv */ /* [16] */
5152 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 11), 40),
5153 BTF_MEMBER_ENC(NAME_TBD, 11, 0), /* uint32_t ui32 */
5154 BTF_MEMBER_ENC(NAME_TBD, 10, 32), /* uint16_t ui16 */
5155 BTF_MEMBER_ENC(NAME_TBD, 12, 64), /* int32_t si32 */
5156 BTF_MEMBER_ENC(NAME_TBD, 6, 96), /* unused_bits2a */
5157 BTF_MEMBER_ENC(NAME_TBD, 7, 98), /* bits28 */
5158 BTF_MEMBER_ENC(NAME_TBD, 6, 126), /* unused_bits2b */
5159 BTF_MEMBER_ENC(0, 14, 128), /* union (anon) */
5160 BTF_MEMBER_ENC(NAME_TBD, 15, 192), /* aenum */
5161 BTF_MEMBER_ENC(NAME_TBD, 11, 224), /* uint32_t ui32b */
5162 BTF_MEMBER_ENC(NAME_TBD, 6, 256), /* bits2c */
5163 BTF_MEMBER_ENC(NAME_TBD, 17, 264), /* si8_4 */
5164 BTF_TYPE_ARRAY_ENC(18, 1, 2), /* [17] */
5165 BTF_TYPE_ARRAY_ENC(1, 1, 2), /* [18] */
5166 BTF_END_RAW,
5167 },
5168 BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum\0ui32b\0bits2c\0si8_4"),
5169 .key_size = sizeof(unsigned int),
5170 .value_size = sizeof(struct pprint_mapv),
5171 .key_type_id = 3, /* unsigned int */
5172 .value_type_id = 16, /* struct pprint_mapv */
5173 .max_entries = 128,
5174 },
5175
5176 {
5177 /* this type will have the same type as the
5178 * first .raw_types definition, but struct type will
5179 * be encoded with kind_flag set.
5180 */
5181 .raw_types = {
5182 /* unsigned char */ /* [1] */
5183 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
5184 /* unsigned short */ /* [2] */
5185 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
5186 /* unsigned int */ /* [3] */
5187 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
5188 /* int */ /* [4] */
5189 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
5190 /* unsigned long long */ /* [5] */
5191 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
5192 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [6] */
5193 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [7] */
5194 /* uint8_t[8] */ /* [8] */
5195 BTF_TYPE_ARRAY_ENC(9, 1, 8),
5196 /* typedef unsigned char uint8_t */ /* [9] */
5197 BTF_TYPEDEF_ENC(NAME_TBD, 1),
5198 /* typedef unsigned short uint16_t */ /* [10] */
5199 BTF_TYPEDEF_ENC(NAME_TBD, 2),
5200 /* typedef unsigned int uint32_t */ /* [11] */
5201 BTF_TYPEDEF_ENC(NAME_TBD, 3),
5202 /* typedef int int32_t */ /* [12] */
5203 BTF_TYPEDEF_ENC(NAME_TBD, 4),
5204 /* typedef unsigned long long uint64_t *//* [13] */
5205 BTF_TYPEDEF_ENC(NAME_TBD, 5),
5206 /* union (anon) */ /* [14] */
5207 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
5208 BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
5209 BTF_MEMBER_ENC(NAME_TBD, 8, 0), /* uint8_t ui8a[8]; */
5210 /* enum (anon) */ /* [15] */
5211 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
5212 BTF_ENUM_ENC(NAME_TBD, 0),
5213 BTF_ENUM_ENC(NAME_TBD, 1),
5214 BTF_ENUM_ENC(NAME_TBD, 2),
5215 BTF_ENUM_ENC(NAME_TBD, 3),
5216 /* struct pprint_mapv */ /* [16] */
5217 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 11), 40),
5218 BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 0)), /* uint32_t ui32 */
5219 BTF_MEMBER_ENC(NAME_TBD, 10, BTF_MEMBER_OFFSET(0, 32)), /* uint16_t ui16 */
5220 BTF_MEMBER_ENC(NAME_TBD, 12, BTF_MEMBER_OFFSET(0, 64)), /* int32_t si32 */
5221 BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 96)), /* unused_bits2a */
5222 BTF_MEMBER_ENC(NAME_TBD, 7, BTF_MEMBER_OFFSET(28, 98)), /* bits28 */
5223 BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 126)), /* unused_bits2b */
5224 BTF_MEMBER_ENC(0, 14, BTF_MEMBER_OFFSET(0, 128)), /* union (anon) */
5225 BTF_MEMBER_ENC(NAME_TBD, 15, BTF_MEMBER_OFFSET(0, 192)), /* aenum */
5226 BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 224)), /* uint32_t ui32b */
5227 BTF_MEMBER_ENC(NAME_TBD, 6, BTF_MEMBER_OFFSET(2, 256)), /* bits2c */
5228 BTF_MEMBER_ENC(NAME_TBD, 17, 264), /* si8_4 */
5229 BTF_TYPE_ARRAY_ENC(18, 1, 2), /* [17] */
5230 BTF_TYPE_ARRAY_ENC(1, 1, 2), /* [18] */
5231 BTF_END_RAW,
5232 },
5233 BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum\0ui32b\0bits2c\0si8_4"),
5234 .key_size = sizeof(unsigned int),
5235 .value_size = sizeof(struct pprint_mapv),
5236 .key_type_id = 3, /* unsigned int */
5237 .value_type_id = 16, /* struct pprint_mapv */
5238 .max_entries = 128,
5239 },
5240
5241 {
5242 /* this type will have the same layout as the
5243 * first .raw_types definition. The struct type will
5244 * be encoded with kind_flag set, bitfield members
5245 * are added typedef/const/volatile, and bitfield members
5246 * will have both int and enum types.
5247 */
5248 .raw_types = {
5249 /* unsigned char */ /* [1] */
5250 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
5251 /* unsigned short */ /* [2] */
5252 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
5253 /* unsigned int */ /* [3] */
5254 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
5255 /* int */ /* [4] */
5256 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
5257 /* unsigned long long */ /* [5] */
5258 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
5259 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [6] */
5260 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [7] */
5261 /* uint8_t[8] */ /* [8] */
5262 BTF_TYPE_ARRAY_ENC(9, 1, 8),
5263 /* typedef unsigned char uint8_t */ /* [9] */
5264 BTF_TYPEDEF_ENC(NAME_TBD, 1),
5265 /* typedef unsigned short uint16_t */ /* [10] */
5266 BTF_TYPEDEF_ENC(NAME_TBD, 2),
5267 /* typedef unsigned int uint32_t */ /* [11] */
5268 BTF_TYPEDEF_ENC(NAME_TBD, 3),
5269 /* typedef int int32_t */ /* [12] */
5270 BTF_TYPEDEF_ENC(NAME_TBD, 4),
5271 /* typedef unsigned long long uint64_t *//* [13] */
5272 BTF_TYPEDEF_ENC(NAME_TBD, 5),
5273 /* union (anon) */ /* [14] */
5274 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
5275 BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
5276 BTF_MEMBER_ENC(NAME_TBD, 8, 0), /* uint8_t ui8a[8]; */
5277 /* enum (anon) */ /* [15] */
5278 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
5279 BTF_ENUM_ENC(NAME_TBD, 0),
5280 BTF_ENUM_ENC(NAME_TBD, 1),
5281 BTF_ENUM_ENC(NAME_TBD, 2),
5282 BTF_ENUM_ENC(NAME_TBD, 3),
5283 /* struct pprint_mapv */ /* [16] */
5284 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 11), 40),
5285 BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 0)), /* uint32_t ui32 */
5286 BTF_MEMBER_ENC(NAME_TBD, 10, BTF_MEMBER_OFFSET(0, 32)), /* uint16_t ui16 */
5287 BTF_MEMBER_ENC(NAME_TBD, 12, BTF_MEMBER_OFFSET(0, 64)), /* int32_t si32 */
5288 BTF_MEMBER_ENC(NAME_TBD, 17, BTF_MEMBER_OFFSET(2, 96)), /* unused_bits2a */
5289 BTF_MEMBER_ENC(NAME_TBD, 7, BTF_MEMBER_OFFSET(28, 98)), /* bits28 */
5290 BTF_MEMBER_ENC(NAME_TBD, 19, BTF_MEMBER_OFFSET(2, 126)),/* unused_bits2b */
5291 BTF_MEMBER_ENC(0, 14, BTF_MEMBER_OFFSET(0, 128)), /* union (anon) */
5292 BTF_MEMBER_ENC(NAME_TBD, 15, BTF_MEMBER_OFFSET(0, 192)), /* aenum */
5293 BTF_MEMBER_ENC(NAME_TBD, 11, BTF_MEMBER_OFFSET(0, 224)), /* uint32_t ui32b */
5294 BTF_MEMBER_ENC(NAME_TBD, 17, BTF_MEMBER_OFFSET(2, 256)), /* bits2c */
5295 BTF_MEMBER_ENC(NAME_TBD, 20, BTF_MEMBER_OFFSET(0, 264)), /* si8_4 */
5296 /* typedef unsigned int ___int */ /* [17] */
5297 BTF_TYPEDEF_ENC(NAME_TBD, 18),
5298 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), 6), /* [18] */
5299 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 15), /* [19] */
5300 BTF_TYPE_ARRAY_ENC(21, 1, 2), /* [20] */
5301 BTF_TYPE_ARRAY_ENC(1, 1, 2), /* [21] */
5302 BTF_END_RAW,
5303 },
5304 BTF_STR_SEC("\0unsigned char\0unsigned short\0unsigned int\0int\0unsigned long long\0uint8_t\0uint16_t\0uint32_t\0int32_t\0uint64_t\0ui64\0ui8a\0ENUM_ZERO\0ENUM_ONE\0ENUM_TWO\0ENUM_THREE\0pprint_mapv\0ui32\0ui16\0si32\0unused_bits2a\0bits28\0unused_bits2b\0aenum\0ui32b\0bits2c\0___int\0si8_4"),
5305 .key_size = sizeof(unsigned int),
5306 .value_size = sizeof(struct pprint_mapv),
5307 .key_type_id = 3, /* unsigned int */
5308 .value_type_id = 16, /* struct pprint_mapv */
5309 .max_entries = 128,
5310 },
5311
5312 #ifdef __SIZEOF_INT128__
5313 {
5314 /* test int128 */
5315 .raw_types = {
5316 /* unsigned int */ /* [1] */
5317 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
5318 /* __int128 */ /* [2] */
5319 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 128, 16),
5320 /* unsigned __int128 */ /* [3] */
5321 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 128, 16),
5322 /* struct pprint_mapv_int128 */ /* [4] */
5323 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 5), 64),
5324 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 0)), /* si128a */
5325 BTF_MEMBER_ENC(NAME_TBD, 2, BTF_MEMBER_OFFSET(0, 128)), /* si128b */
5326 BTF_MEMBER_ENC(NAME_TBD, 3, BTF_MEMBER_OFFSET(3, 256)), /* bits3 */
5327 BTF_MEMBER_ENC(NAME_TBD, 3, BTF_MEMBER_OFFSET(80, 259)), /* bits80 */
5328 BTF_MEMBER_ENC(NAME_TBD, 3, BTF_MEMBER_OFFSET(0, 384)), /* ui128 */
5329 BTF_END_RAW,
5330 },
5331 BTF_STR_SEC("\0unsigned int\0__int128\0unsigned __int128\0pprint_mapv_int128\0si128a\0si128b\0bits3\0bits80\0ui128"),
5332 .key_size = sizeof(unsigned int),
5333 .value_size = sizeof(struct pprint_mapv_int128),
5334 .key_type_id = 1,
5335 .value_type_id = 4,
5336 .max_entries = 128,
5337 .mapv_kind = PPRINT_MAPV_KIND_INT128,
5338 },
5339 #endif
5340
5341 };
5342
5343 static struct btf_pprint_test_meta {
5344 const char *descr;
5345 enum bpf_map_type map_type;
5346 const char *map_name;
5347 bool ordered_map;
5348 bool lossless_map;
5349 bool percpu_map;
5350 } pprint_tests_meta[] = {
5351 {
5352 .descr = "BTF pretty print array",
5353 .map_type = BPF_MAP_TYPE_ARRAY,
5354 .map_name = "pprint_test_array",
5355 .ordered_map = true,
5356 .lossless_map = true,
5357 .percpu_map = false,
5358 },
5359
5360 {
5361 .descr = "BTF pretty print hash",
5362 .map_type = BPF_MAP_TYPE_HASH,
5363 .map_name = "pprint_test_hash",
5364 .ordered_map = false,
5365 .lossless_map = true,
5366 .percpu_map = false,
5367 },
5368
5369 {
5370 .descr = "BTF pretty print lru hash",
5371 .map_type = BPF_MAP_TYPE_LRU_HASH,
5372 .map_name = "pprint_test_lru_hash",
5373 .ordered_map = false,
5374 .lossless_map = false,
5375 .percpu_map = false,
5376 },
5377
5378 {
5379 .descr = "BTF pretty print percpu array",
5380 .map_type = BPF_MAP_TYPE_PERCPU_ARRAY,
5381 .map_name = "pprint_test_percpu_array",
5382 .ordered_map = true,
5383 .lossless_map = true,
5384 .percpu_map = true,
5385 },
5386
5387 {
5388 .descr = "BTF pretty print percpu hash",
5389 .map_type = BPF_MAP_TYPE_PERCPU_HASH,
5390 .map_name = "pprint_test_percpu_hash",
5391 .ordered_map = false,
5392 .lossless_map = true,
5393 .percpu_map = true,
5394 },
5395
5396 {
5397 .descr = "BTF pretty print lru percpu hash",
5398 .map_type = BPF_MAP_TYPE_LRU_PERCPU_HASH,
5399 .map_name = "pprint_test_lru_percpu_hash",
5400 .ordered_map = false,
5401 .lossless_map = false,
5402 .percpu_map = true,
5403 },
5404
5405 };
5406
get_pprint_mapv_size(enum pprint_mapv_kind_t mapv_kind)5407 static size_t get_pprint_mapv_size(enum pprint_mapv_kind_t mapv_kind)
5408 {
5409 if (mapv_kind == PPRINT_MAPV_KIND_BASIC)
5410 return sizeof(struct pprint_mapv);
5411
5412 #ifdef __SIZEOF_INT128__
5413 if (mapv_kind == PPRINT_MAPV_KIND_INT128)
5414 return sizeof(struct pprint_mapv_int128);
5415 #endif
5416
5417 assert(0);
5418 return 0;
5419 }
5420
set_pprint_mapv(enum pprint_mapv_kind_t mapv_kind,void * mapv,uint32_t i,int num_cpus,int rounded_value_size)5421 static void set_pprint_mapv(enum pprint_mapv_kind_t mapv_kind,
5422 void *mapv, uint32_t i,
5423 int num_cpus, int rounded_value_size)
5424 {
5425 int cpu;
5426
5427 if (mapv_kind == PPRINT_MAPV_KIND_BASIC) {
5428 struct pprint_mapv *v = mapv;
5429
5430 for (cpu = 0; cpu < num_cpus; cpu++) {
5431 v->ui32 = i + cpu;
5432 v->si32 = -i;
5433 v->unused_bits2a = 3;
5434 v->bits28 = i;
5435 v->unused_bits2b = 3;
5436 v->ui64 = i;
5437 v->aenum = i & 0x03;
5438 v->ui32b = 4;
5439 v->bits2c = 1;
5440 v->si8_4[0][0] = (cpu + i) & 0xff;
5441 v->si8_4[0][1] = (cpu + i + 1) & 0xff;
5442 v->si8_4[1][0] = (cpu + i + 2) & 0xff;
5443 v->si8_4[1][1] = (cpu + i + 3) & 0xff;
5444 v = (void *)v + rounded_value_size;
5445 }
5446 }
5447
5448 #ifdef __SIZEOF_INT128__
5449 if (mapv_kind == PPRINT_MAPV_KIND_INT128) {
5450 struct pprint_mapv_int128 *v = mapv;
5451
5452 for (cpu = 0; cpu < num_cpus; cpu++) {
5453 v->si128a = i;
5454 v->si128b = -i;
5455 v->bits3 = i & 0x07;
5456 v->bits80 = (((unsigned __int128)1) << 64) + i;
5457 v->ui128 = (((unsigned __int128)2) << 64) + i;
5458 v = (void *)v + rounded_value_size;
5459 }
5460 }
5461 #endif
5462 }
5463
get_pprint_expected_line(enum pprint_mapv_kind_t mapv_kind,char * expected_line,ssize_t line_size,bool percpu_map,unsigned int next_key,int cpu,void * mapv)5464 ssize_t get_pprint_expected_line(enum pprint_mapv_kind_t mapv_kind,
5465 char *expected_line, ssize_t line_size,
5466 bool percpu_map, unsigned int next_key,
5467 int cpu, void *mapv)
5468 {
5469 ssize_t nexpected_line = -1;
5470
5471 if (mapv_kind == PPRINT_MAPV_KIND_BASIC) {
5472 struct pprint_mapv *v = mapv;
5473
5474 nexpected_line = snprintf(expected_line, line_size,
5475 "%s%u: {%u,0,%d,0x%x,0x%x,0x%x,"
5476 "{%llu|[%u,%u,%u,%u,%u,%u,%u,%u]},%s,"
5477 "%u,0x%x,[[%d,%d],[%d,%d]]}\n",
5478 percpu_map ? "\tcpu" : "",
5479 percpu_map ? cpu : next_key,
5480 v->ui32, v->si32,
5481 v->unused_bits2a,
5482 v->bits28,
5483 v->unused_bits2b,
5484 (__u64)v->ui64,
5485 v->ui8a[0], v->ui8a[1],
5486 v->ui8a[2], v->ui8a[3],
5487 v->ui8a[4], v->ui8a[5],
5488 v->ui8a[6], v->ui8a[7],
5489 pprint_enum_str[v->aenum],
5490 v->ui32b,
5491 v->bits2c,
5492 v->si8_4[0][0], v->si8_4[0][1],
5493 v->si8_4[1][0], v->si8_4[1][1]);
5494 }
5495
5496 #ifdef __SIZEOF_INT128__
5497 if (mapv_kind == PPRINT_MAPV_KIND_INT128) {
5498 struct pprint_mapv_int128 *v = mapv;
5499
5500 nexpected_line = snprintf(expected_line, line_size,
5501 "%s%u: {0x%lx,0x%lx,0x%lx,"
5502 "0x%lx%016lx,0x%lx%016lx}\n",
5503 percpu_map ? "\tcpu" : "",
5504 percpu_map ? cpu : next_key,
5505 (uint64_t)v->si128a,
5506 (uint64_t)v->si128b,
5507 (uint64_t)v->bits3,
5508 (uint64_t)(v->bits80 >> 64),
5509 (uint64_t)v->bits80,
5510 (uint64_t)(v->ui128 >> 64),
5511 (uint64_t)v->ui128);
5512 }
5513 #endif
5514
5515 return nexpected_line;
5516 }
5517
check_line(const char * expected_line,int nexpected_line,int expected_line_len,const char * line)5518 static int check_line(const char *expected_line, int nexpected_line,
5519 int expected_line_len, const char *line)
5520 {
5521 if (CHECK(nexpected_line == expected_line_len,
5522 "expected_line is too long"))
5523 return -1;
5524
5525 if (strcmp(expected_line, line)) {
5526 fprintf(stderr, "unexpected pprint output\n");
5527 fprintf(stderr, "expected: %s", expected_line);
5528 fprintf(stderr, " read: %s", line);
5529 return -1;
5530 }
5531
5532 return 0;
5533 }
5534
5535
do_test_pprint(int test_num)5536 static void do_test_pprint(int test_num)
5537 {
5538 const struct btf_raw_test *test = &pprint_test_template[test_num];
5539 enum pprint_mapv_kind_t mapv_kind = test->mapv_kind;
5540 LIBBPF_OPTS(bpf_map_create_opts, opts);
5541 bool ordered_map, lossless_map, percpu_map;
5542 int err, ret, num_cpus, rounded_value_size;
5543 unsigned int key, nr_read_elems;
5544 int map_fd = -1, btf_fd = -1;
5545 unsigned int raw_btf_size;
5546 char expected_line[255];
5547 FILE *pin_file = NULL;
5548 char pin_path[255];
5549 size_t line_len = 0;
5550 char *line = NULL;
5551 void *mapv = NULL;
5552 uint8_t *raw_btf;
5553 ssize_t nread;
5554
5555 if (!test__start_subtest(test->descr))
5556 return;
5557
5558 raw_btf = btf_raw_create(&hdr_tmpl, test->raw_types,
5559 test->str_sec, test->str_sec_size,
5560 &raw_btf_size, NULL);
5561
5562 if (!raw_btf)
5563 return;
5564
5565 *btf_log_buf = '\0';
5566 btf_fd = load_raw_btf(raw_btf, raw_btf_size);
5567 free(raw_btf);
5568
5569 if (CHECK(btf_fd < 0, "errno:%d\n", errno)) {
5570 err = -1;
5571 goto done;
5572 }
5573
5574 opts.btf_fd = btf_fd;
5575 opts.btf_key_type_id = test->key_type_id;
5576 opts.btf_value_type_id = test->value_type_id;
5577 map_fd = bpf_map_create(test->map_type, test->map_name,
5578 test->key_size, test->value_size, test->max_entries, &opts);
5579 if (CHECK(map_fd < 0, "errno:%d", errno)) {
5580 err = -1;
5581 goto done;
5582 }
5583
5584 ret = snprintf(pin_path, sizeof(pin_path), "%s/%s",
5585 "/sys/fs/bpf", test->map_name);
5586
5587 if (CHECK(ret >= sizeof(pin_path), "pin_path %s/%s is too long",
5588 "/sys/fs/bpf", test->map_name)) {
5589 err = -1;
5590 goto done;
5591 }
5592
5593 err = bpf_obj_pin(map_fd, pin_path);
5594 if (CHECK(err, "bpf_obj_pin(%s): errno:%d.", pin_path, errno))
5595 goto done;
5596
5597 percpu_map = test->percpu_map;
5598 num_cpus = percpu_map ? bpf_num_possible_cpus() : 1;
5599 rounded_value_size = round_up(get_pprint_mapv_size(mapv_kind), 8);
5600 mapv = calloc(num_cpus, rounded_value_size);
5601 if (CHECK(!mapv, "mapv allocation failure")) {
5602 err = -1;
5603 goto done;
5604 }
5605
5606 for (key = 0; key < test->max_entries; key++) {
5607 set_pprint_mapv(mapv_kind, mapv, key, num_cpus, rounded_value_size);
5608 bpf_map_update_elem(map_fd, &key, mapv, 0);
5609 }
5610
5611 pin_file = fopen(pin_path, "r");
5612 if (CHECK(!pin_file, "fopen(%s): errno:%d", pin_path, errno)) {
5613 err = -1;
5614 goto done;
5615 }
5616
5617 /* Skip lines start with '#' */
5618 while ((nread = getline(&line, &line_len, pin_file)) > 0 &&
5619 *line == '#')
5620 ;
5621
5622 if (CHECK(nread <= 0, "Unexpected EOF")) {
5623 err = -1;
5624 goto done;
5625 }
5626
5627 nr_read_elems = 0;
5628 ordered_map = test->ordered_map;
5629 lossless_map = test->lossless_map;
5630 do {
5631 ssize_t nexpected_line;
5632 unsigned int next_key;
5633 void *cmapv;
5634 int cpu;
5635
5636 next_key = ordered_map ? nr_read_elems : atoi(line);
5637 set_pprint_mapv(mapv_kind, mapv, next_key, num_cpus, rounded_value_size);
5638 cmapv = mapv;
5639
5640 for (cpu = 0; cpu < num_cpus; cpu++) {
5641 if (percpu_map) {
5642 /* for percpu map, the format looks like:
5643 * <key>: {
5644 * cpu0: <value_on_cpu0>
5645 * cpu1: <value_on_cpu1>
5646 * ...
5647 * cpun: <value_on_cpun>
5648 * }
5649 *
5650 * let us verify the line containing the key here.
5651 */
5652 if (cpu == 0) {
5653 nexpected_line = snprintf(expected_line,
5654 sizeof(expected_line),
5655 "%u: {\n",
5656 next_key);
5657
5658 err = check_line(expected_line, nexpected_line,
5659 sizeof(expected_line), line);
5660 if (err < 0)
5661 goto done;
5662 }
5663
5664 /* read value@cpu */
5665 nread = getline(&line, &line_len, pin_file);
5666 if (nread < 0)
5667 break;
5668 }
5669
5670 nexpected_line = get_pprint_expected_line(mapv_kind, expected_line,
5671 sizeof(expected_line),
5672 percpu_map, next_key,
5673 cpu, cmapv);
5674 err = check_line(expected_line, nexpected_line,
5675 sizeof(expected_line), line);
5676 if (err < 0)
5677 goto done;
5678
5679 cmapv = cmapv + rounded_value_size;
5680 }
5681
5682 if (percpu_map) {
5683 /* skip the last bracket for the percpu map */
5684 nread = getline(&line, &line_len, pin_file);
5685 if (nread < 0)
5686 break;
5687 }
5688
5689 nread = getline(&line, &line_len, pin_file);
5690 } while (++nr_read_elems < test->max_entries && nread > 0);
5691
5692 if (lossless_map &&
5693 CHECK(nr_read_elems < test->max_entries,
5694 "Unexpected EOF. nr_read_elems:%u test->max_entries:%u",
5695 nr_read_elems, test->max_entries)) {
5696 err = -1;
5697 goto done;
5698 }
5699
5700 if (CHECK(nread > 0, "Unexpected extra pprint output: %s", line)) {
5701 err = -1;
5702 goto done;
5703 }
5704
5705 err = 0;
5706
5707 done:
5708 if (mapv)
5709 free(mapv);
5710 if (!err)
5711 fprintf(stderr, "OK");
5712 if (*btf_log_buf && (err || always_log))
5713 fprintf(stderr, "\n%s", btf_log_buf);
5714 if (btf_fd >= 0)
5715 close(btf_fd);
5716 if (map_fd >= 0)
5717 close(map_fd);
5718 if (pin_file)
5719 fclose(pin_file);
5720 unlink(pin_path);
5721 free(line);
5722 }
5723
test_pprint(void)5724 static void test_pprint(void)
5725 {
5726 unsigned int i;
5727
5728 /* test various maps with the first test template */
5729 for (i = 0; i < ARRAY_SIZE(pprint_tests_meta); i++) {
5730 pprint_test_template[0].descr = pprint_tests_meta[i].descr;
5731 pprint_test_template[0].map_type = pprint_tests_meta[i].map_type;
5732 pprint_test_template[0].map_name = pprint_tests_meta[i].map_name;
5733 pprint_test_template[0].ordered_map = pprint_tests_meta[i].ordered_map;
5734 pprint_test_template[0].lossless_map = pprint_tests_meta[i].lossless_map;
5735 pprint_test_template[0].percpu_map = pprint_tests_meta[i].percpu_map;
5736
5737 do_test_pprint(0);
5738 }
5739
5740 /* test rest test templates with the first map */
5741 for (i = 1; i < ARRAY_SIZE(pprint_test_template); i++) {
5742 pprint_test_template[i].descr = pprint_tests_meta[0].descr;
5743 pprint_test_template[i].map_type = pprint_tests_meta[0].map_type;
5744 pprint_test_template[i].map_name = pprint_tests_meta[0].map_name;
5745 pprint_test_template[i].ordered_map = pprint_tests_meta[0].ordered_map;
5746 pprint_test_template[i].lossless_map = pprint_tests_meta[0].lossless_map;
5747 pprint_test_template[i].percpu_map = pprint_tests_meta[0].percpu_map;
5748 do_test_pprint(i);
5749 }
5750 }
5751
5752 #define BPF_LINE_INFO_ENC(insn_off, file_off, line_off, line_num, line_col) \
5753 (insn_off), (file_off), (line_off), ((line_num) << 10 | ((line_col) & 0x3ff))
5754
5755 static struct prog_info_raw_test {
5756 const char *descr;
5757 const char *str_sec;
5758 const char *err_str;
5759 __u32 raw_types[MAX_NR_RAW_U32];
5760 __u32 str_sec_size;
5761 struct bpf_insn insns[MAX_INSNS];
5762 __u32 prog_type;
5763 __u32 func_info[MAX_SUBPROGS][2];
5764 __u32 func_info_rec_size;
5765 __u32 func_info_cnt;
5766 __u32 line_info[MAX_NR_RAW_U32];
5767 __u32 line_info_rec_size;
5768 __u32 nr_jited_ksyms;
5769 bool expected_prog_load_failure;
5770 __u32 dead_code_cnt;
5771 __u32 dead_code_mask;
5772 __u32 dead_func_cnt;
5773 __u32 dead_func_mask;
5774 } info_raw_tests[] = {
5775 {
5776 .descr = "func_type (main func + one sub)",
5777 .raw_types = {
5778 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5779 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
5780 BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
5781 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5782 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5783 BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
5784 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5785 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5786 BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
5787 BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
5788 BTF_END_RAW,
5789 },
5790 .str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5791 .str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5792 .insns = {
5793 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5794 BPF_MOV64_IMM(BPF_REG_0, 1),
5795 BPF_EXIT_INSN(),
5796 BPF_MOV64_IMM(BPF_REG_0, 2),
5797 BPF_EXIT_INSN(),
5798 },
5799 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5800 .func_info = { {0, 5}, {3, 6} },
5801 .func_info_rec_size = 8,
5802 .func_info_cnt = 2,
5803 .line_info = { BTF_END_RAW },
5804 },
5805
5806 {
5807 .descr = "func_type (Incorrect func_info_rec_size)",
5808 .raw_types = {
5809 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5810 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
5811 BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
5812 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5813 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5814 BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
5815 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5816 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5817 BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
5818 BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
5819 BTF_END_RAW,
5820 },
5821 .str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5822 .str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5823 .insns = {
5824 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5825 BPF_MOV64_IMM(BPF_REG_0, 1),
5826 BPF_EXIT_INSN(),
5827 BPF_MOV64_IMM(BPF_REG_0, 2),
5828 BPF_EXIT_INSN(),
5829 },
5830 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5831 .func_info = { {0, 5}, {3, 6} },
5832 .func_info_rec_size = 4,
5833 .func_info_cnt = 2,
5834 .line_info = { BTF_END_RAW },
5835 .expected_prog_load_failure = true,
5836 },
5837
5838 {
5839 .descr = "func_type (Incorrect func_info_cnt)",
5840 .raw_types = {
5841 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5842 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
5843 BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
5844 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5845 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5846 BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
5847 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5848 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5849 BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
5850 BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
5851 BTF_END_RAW,
5852 },
5853 .str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5854 .str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5855 .insns = {
5856 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5857 BPF_MOV64_IMM(BPF_REG_0, 1),
5858 BPF_EXIT_INSN(),
5859 BPF_MOV64_IMM(BPF_REG_0, 2),
5860 BPF_EXIT_INSN(),
5861 },
5862 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5863 .func_info = { {0, 5}, {3, 6} },
5864 .func_info_rec_size = 8,
5865 .func_info_cnt = 1,
5866 .line_info = { BTF_END_RAW },
5867 .expected_prog_load_failure = true,
5868 },
5869
5870 {
5871 .descr = "func_type (Incorrect bpf_func_info.insn_off)",
5872 .raw_types = {
5873 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5874 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4), /* [2] */
5875 BTF_FUNC_PROTO_ENC(1, 2), /* [3] */
5876 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5877 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5878 BTF_FUNC_PROTO_ENC(1, 2), /* [4] */
5879 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 2),
5880 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
5881 BTF_FUNC_ENC(NAME_TBD, 3), /* [5] */
5882 BTF_FUNC_ENC(NAME_TBD, 4), /* [6] */
5883 BTF_END_RAW,
5884 },
5885 .str_sec = "\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB",
5886 .str_sec_size = sizeof("\0int\0unsigned int\0a\0b\0c\0d\0funcA\0funcB"),
5887 .insns = {
5888 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 2),
5889 BPF_MOV64_IMM(BPF_REG_0, 1),
5890 BPF_EXIT_INSN(),
5891 BPF_MOV64_IMM(BPF_REG_0, 2),
5892 BPF_EXIT_INSN(),
5893 },
5894 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5895 .func_info = { {0, 5}, {2, 6} },
5896 .func_info_rec_size = 8,
5897 .func_info_cnt = 2,
5898 .line_info = { BTF_END_RAW },
5899 .expected_prog_load_failure = true,
5900 },
5901
5902 {
5903 .descr = "line_info (No subprog)",
5904 .raw_types = {
5905 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5906 BTF_END_RAW,
5907 },
5908 BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
5909 .insns = {
5910 BPF_MOV64_IMM(BPF_REG_0, 1),
5911 BPF_MOV64_IMM(BPF_REG_1, 2),
5912 BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
5913 BPF_EXIT_INSN(),
5914 },
5915 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5916 .func_info_cnt = 0,
5917 .line_info = {
5918 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5919 BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9),
5920 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
5921 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7),
5922 BTF_END_RAW,
5923 },
5924 .line_info_rec_size = sizeof(struct bpf_line_info),
5925 .nr_jited_ksyms = 1,
5926 },
5927
5928 {
5929 .descr = "line_info (No subprog. insn_off >= prog->len)",
5930 .raw_types = {
5931 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5932 BTF_END_RAW,
5933 },
5934 BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
5935 .insns = {
5936 BPF_MOV64_IMM(BPF_REG_0, 1),
5937 BPF_MOV64_IMM(BPF_REG_1, 2),
5938 BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
5939 BPF_EXIT_INSN(),
5940 },
5941 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5942 .func_info_cnt = 0,
5943 .line_info = {
5944 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5945 BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9),
5946 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
5947 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7),
5948 BPF_LINE_INFO_ENC(4, 0, 0, 5, 6),
5949 BTF_END_RAW,
5950 },
5951 .line_info_rec_size = sizeof(struct bpf_line_info),
5952 .nr_jited_ksyms = 1,
5953 .err_str = "line_info[4].insn_off",
5954 .expected_prog_load_failure = true,
5955 },
5956
5957 {
5958 .descr = "line_info (Zero bpf insn code)",
5959 .raw_types = {
5960 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5961 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8), /* [2] */
5962 BTF_TYPEDEF_ENC(NAME_TBD, 2), /* [3] */
5963 BTF_END_RAW,
5964 },
5965 BTF_STR_SEC("\0int\0unsigned long\0u64\0u64 a=1;\0return a;"),
5966 .insns = {
5967 BPF_LD_IMM64(BPF_REG_0, 1),
5968 BPF_EXIT_INSN(),
5969 },
5970 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5971 .func_info_cnt = 0,
5972 .line_info = {
5973 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
5974 BPF_LINE_INFO_ENC(1, 0, 0, 2, 9),
5975 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
5976 BTF_END_RAW,
5977 },
5978 .line_info_rec_size = sizeof(struct bpf_line_info),
5979 .nr_jited_ksyms = 1,
5980 .err_str = "Invalid insn code at line_info[1]",
5981 .expected_prog_load_failure = true,
5982 },
5983
5984 {
5985 .descr = "line_info (No subprog. zero tailing line_info",
5986 .raw_types = {
5987 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
5988 BTF_END_RAW,
5989 },
5990 BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
5991 .insns = {
5992 BPF_MOV64_IMM(BPF_REG_0, 1),
5993 BPF_MOV64_IMM(BPF_REG_1, 2),
5994 BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
5995 BPF_EXIT_INSN(),
5996 },
5997 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
5998 .func_info_cnt = 0,
5999 .line_info = {
6000 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10), 0,
6001 BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9), 0,
6002 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8), 0,
6003 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7), 0,
6004 BTF_END_RAW,
6005 },
6006 .line_info_rec_size = sizeof(struct bpf_line_info) + sizeof(__u32),
6007 .nr_jited_ksyms = 1,
6008 },
6009
6010 {
6011 .descr = "line_info (No subprog. nonzero tailing line_info)",
6012 .raw_types = {
6013 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6014 BTF_END_RAW,
6015 },
6016 BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
6017 .insns = {
6018 BPF_MOV64_IMM(BPF_REG_0, 1),
6019 BPF_MOV64_IMM(BPF_REG_1, 2),
6020 BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
6021 BPF_EXIT_INSN(),
6022 },
6023 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6024 .func_info_cnt = 0,
6025 .line_info = {
6026 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10), 0,
6027 BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9), 0,
6028 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8), 0,
6029 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7), 1,
6030 BTF_END_RAW,
6031 },
6032 .line_info_rec_size = sizeof(struct bpf_line_info) + sizeof(__u32),
6033 .nr_jited_ksyms = 1,
6034 .err_str = "nonzero tailing record in line_info",
6035 .expected_prog_load_failure = true,
6036 },
6037
6038 {
6039 .descr = "line_info (subprog)",
6040 .raw_types = {
6041 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6042 BTF_END_RAW,
6043 },
6044 BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
6045 .insns = {
6046 BPF_MOV64_IMM(BPF_REG_2, 1),
6047 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6048 BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6049 BPF_CALL_REL(1),
6050 BPF_EXIT_INSN(),
6051 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6052 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6053 BPF_EXIT_INSN(),
6054 },
6055 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6056 .func_info_cnt = 0,
6057 .line_info = {
6058 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6059 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
6060 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 3, 8),
6061 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
6062 BTF_END_RAW,
6063 },
6064 .line_info_rec_size = sizeof(struct bpf_line_info),
6065 .nr_jited_ksyms = 2,
6066 },
6067
6068 {
6069 .descr = "line_info (subprog + func_info)",
6070 .raw_types = {
6071 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6072 BTF_FUNC_PROTO_ENC(1, 1), /* [2] */
6073 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6074 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
6075 BTF_FUNC_ENC(NAME_TBD, 2), /* [4] */
6076 BTF_END_RAW,
6077 },
6078 BTF_STR_SEC("\0int\0x\0sub\0main\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
6079 .insns = {
6080 BPF_MOV64_IMM(BPF_REG_2, 1),
6081 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6082 BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6083 BPF_CALL_REL(1),
6084 BPF_EXIT_INSN(),
6085 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6086 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6087 BPF_EXIT_INSN(),
6088 },
6089 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6090 .func_info_cnt = 2,
6091 .func_info_rec_size = 8,
6092 .func_info = { {0, 4}, {5, 3} },
6093 .line_info = {
6094 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6095 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
6096 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 3, 8),
6097 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
6098 BTF_END_RAW,
6099 },
6100 .line_info_rec_size = sizeof(struct bpf_line_info),
6101 .nr_jited_ksyms = 2,
6102 },
6103
6104 {
6105 .descr = "line_info (subprog. missing 1st func line info)",
6106 .raw_types = {
6107 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6108 BTF_END_RAW,
6109 },
6110 BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
6111 .insns = {
6112 BPF_MOV64_IMM(BPF_REG_2, 1),
6113 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6114 BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6115 BPF_CALL_REL(1),
6116 BPF_EXIT_INSN(),
6117 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6118 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6119 BPF_EXIT_INSN(),
6120 },
6121 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6122 .func_info_cnt = 0,
6123 .line_info = {
6124 BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 1, 10),
6125 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
6126 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 3, 8),
6127 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
6128 BTF_END_RAW,
6129 },
6130 .line_info_rec_size = sizeof(struct bpf_line_info),
6131 .nr_jited_ksyms = 2,
6132 .err_str = "missing bpf_line_info for func#0",
6133 .expected_prog_load_failure = true,
6134 },
6135
6136 {
6137 .descr = "line_info (subprog. missing 2nd func line info)",
6138 .raw_types = {
6139 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6140 BTF_END_RAW,
6141 },
6142 BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
6143 .insns = {
6144 BPF_MOV64_IMM(BPF_REG_2, 1),
6145 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6146 BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6147 BPF_CALL_REL(1),
6148 BPF_EXIT_INSN(),
6149 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6150 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6151 BPF_EXIT_INSN(),
6152 },
6153 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6154 .func_info_cnt = 0,
6155 .line_info = {
6156 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6157 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 2, 9),
6158 BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 3, 8),
6159 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
6160 BTF_END_RAW,
6161 },
6162 .line_info_rec_size = sizeof(struct bpf_line_info),
6163 .nr_jited_ksyms = 2,
6164 .err_str = "missing bpf_line_info for func#1",
6165 .expected_prog_load_failure = true,
6166 },
6167
6168 {
6169 .descr = "line_info (subprog. unordered insn offset)",
6170 .raw_types = {
6171 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6172 BTF_END_RAW,
6173 },
6174 BTF_STR_SEC("\0int\0int a=1+1;\0return func(a);\0b+=1;\0return b;"),
6175 .insns = {
6176 BPF_MOV64_IMM(BPF_REG_2, 1),
6177 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6178 BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6179 BPF_CALL_REL(1),
6180 BPF_EXIT_INSN(),
6181 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6182 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6183 BPF_EXIT_INSN(),
6184 },
6185 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6186 .func_info_cnt = 0,
6187 .line_info = {
6188 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6189 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 2, 9),
6190 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
6191 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 4, 7),
6192 BTF_END_RAW,
6193 },
6194 .line_info_rec_size = sizeof(struct bpf_line_info),
6195 .nr_jited_ksyms = 2,
6196 .err_str = "Invalid line_info[2].insn_off",
6197 .expected_prog_load_failure = true,
6198 },
6199
6200 {
6201 .descr = "line_info (dead start)",
6202 .raw_types = {
6203 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6204 BTF_END_RAW,
6205 },
6206 BTF_STR_SEC("\0int\0/* dead jmp */\0int a=1;\0int b=2;\0return a + b;\0return a + b;"),
6207 .insns = {
6208 BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6209 BPF_MOV64_IMM(BPF_REG_0, 1),
6210 BPF_MOV64_IMM(BPF_REG_1, 2),
6211 BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
6212 BPF_EXIT_INSN(),
6213 },
6214 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6215 .func_info_cnt = 0,
6216 .line_info = {
6217 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6218 BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 9),
6219 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 8),
6220 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 7),
6221 BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 5, 6),
6222 BTF_END_RAW,
6223 },
6224 .line_info_rec_size = sizeof(struct bpf_line_info),
6225 .nr_jited_ksyms = 1,
6226 .dead_code_cnt = 1,
6227 .dead_code_mask = 0x01,
6228 },
6229
6230 {
6231 .descr = "line_info (dead end)",
6232 .raw_types = {
6233 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6234 BTF_END_RAW,
6235 },
6236 BTF_STR_SEC("\0int\0int a=1;\0int b=2;\0return a + b;\0/* dead jmp */\0return a + b;\0/* dead exit */"),
6237 .insns = {
6238 BPF_MOV64_IMM(BPF_REG_0, 1),
6239 BPF_MOV64_IMM(BPF_REG_1, 2),
6240 BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1),
6241 BPF_JMP_IMM(BPF_JGE, BPF_REG_0, 10, 1),
6242 BPF_EXIT_INSN(),
6243 BPF_EXIT_INSN(),
6244 },
6245 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6246 .func_info_cnt = 0,
6247 .line_info = {
6248 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 12),
6249 BPF_LINE_INFO_ENC(1, 0, NAME_TBD, 2, 11),
6250 BPF_LINE_INFO_ENC(2, 0, NAME_TBD, 3, 10),
6251 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 4, 9),
6252 BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 5, 8),
6253 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 6, 7),
6254 BTF_END_RAW,
6255 },
6256 .line_info_rec_size = sizeof(struct bpf_line_info),
6257 .nr_jited_ksyms = 1,
6258 .dead_code_cnt = 2,
6259 .dead_code_mask = 0x28,
6260 },
6261
6262 {
6263 .descr = "line_info (dead code + subprog + func_info)",
6264 .raw_types = {
6265 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6266 BTF_FUNC_PROTO_ENC(1, 1), /* [2] */
6267 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6268 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
6269 BTF_FUNC_ENC(NAME_TBD, 2), /* [4] */
6270 BTF_END_RAW,
6271 },
6272 BTF_STR_SEC("\0int\0x\0sub\0main\0int a=1+1;\0/* dead jmp */"
6273 "\0/* dead */\0/* dead */\0/* dead */\0/* dead */"
6274 "\0/* dead */\0/* dead */\0/* dead */\0/* dead */"
6275 "\0return func(a);\0b+=1;\0return b;"),
6276 .insns = {
6277 BPF_MOV64_IMM(BPF_REG_2, 1),
6278 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1),
6279 BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
6280 BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 8),
6281 BPF_MOV64_IMM(BPF_REG_2, 1),
6282 BPF_MOV64_IMM(BPF_REG_2, 1),
6283 BPF_MOV64_IMM(BPF_REG_2, 1),
6284 BPF_MOV64_IMM(BPF_REG_2, 1),
6285 BPF_MOV64_IMM(BPF_REG_2, 1),
6286 BPF_MOV64_IMM(BPF_REG_2, 1),
6287 BPF_MOV64_IMM(BPF_REG_2, 1),
6288 BPF_MOV64_IMM(BPF_REG_2, 1),
6289 BPF_CALL_REL(1),
6290 BPF_EXIT_INSN(),
6291 BPF_MOV64_REG(BPF_REG_0, BPF_REG_1),
6292 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6293 BPF_EXIT_INSN(),
6294 },
6295 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6296 .func_info_cnt = 2,
6297 .func_info_rec_size = 8,
6298 .func_info = { {0, 4}, {14, 3} },
6299 .line_info = {
6300 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6301 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6302 BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6303 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6304 BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6305 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6306 BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6307 BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6308 BPF_LINE_INFO_ENC(10, 0, NAME_TBD, 1, 10),
6309 BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 2, 9),
6310 BPF_LINE_INFO_ENC(12, 0, NAME_TBD, 2, 9),
6311 BPF_LINE_INFO_ENC(14, 0, NAME_TBD, 3, 8),
6312 BPF_LINE_INFO_ENC(16, 0, NAME_TBD, 4, 7),
6313 BTF_END_RAW,
6314 },
6315 .line_info_rec_size = sizeof(struct bpf_line_info),
6316 .nr_jited_ksyms = 2,
6317 .dead_code_cnt = 9,
6318 .dead_code_mask = 0x3fe,
6319 },
6320
6321 {
6322 .descr = "line_info (dead subprog)",
6323 .raw_types = {
6324 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6325 BTF_FUNC_PROTO_ENC(1, 1), /* [2] */
6326 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6327 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
6328 BTF_FUNC_ENC(NAME_TBD, 2), /* [4] */
6329 BTF_FUNC_ENC(NAME_TBD, 2), /* [5] */
6330 BTF_END_RAW,
6331 },
6332 BTF_STR_SEC("\0int\0x\0dead\0main\0func\0int a=1+1;\0/* live call */"
6333 "\0return 0;\0return 0;\0/* dead */\0/* dead */"
6334 "\0/* dead */\0return bla + 1;\0return bla + 1;"
6335 "\0return bla + 1;\0return func(a);\0b+=1;\0return b;"),
6336 .insns = {
6337 BPF_MOV64_IMM(BPF_REG_2, 1),
6338 BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6339 BPF_CALL_REL(3),
6340 BPF_CALL_REL(5),
6341 BPF_MOV64_IMM(BPF_REG_0, 0),
6342 BPF_EXIT_INSN(),
6343 BPF_MOV64_IMM(BPF_REG_0, 0),
6344 BPF_CALL_REL(1),
6345 BPF_EXIT_INSN(),
6346 BPF_MOV64_REG(BPF_REG_0, 2),
6347 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6348 BPF_EXIT_INSN(),
6349 },
6350 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6351 .func_info_cnt = 3,
6352 .func_info_rec_size = 8,
6353 .func_info = { {0, 4}, {6, 3}, {9, 5} },
6354 .line_info = {
6355 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6356 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6357 BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6358 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6359 BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6360 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6361 BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6362 BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6363 BPF_LINE_INFO_ENC(10, 0, NAME_TBD, 1, 10),
6364 BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 2, 9),
6365 BTF_END_RAW,
6366 },
6367 .line_info_rec_size = sizeof(struct bpf_line_info),
6368 .nr_jited_ksyms = 2,
6369 .dead_code_cnt = 3,
6370 .dead_code_mask = 0x70,
6371 .dead_func_cnt = 1,
6372 .dead_func_mask = 0x2,
6373 },
6374
6375 {
6376 .descr = "line_info (dead last subprog)",
6377 .raw_types = {
6378 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6379 BTF_FUNC_PROTO_ENC(1, 1), /* [2] */
6380 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6381 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
6382 BTF_FUNC_ENC(NAME_TBD, 2), /* [5] */
6383 BTF_END_RAW,
6384 },
6385 BTF_STR_SEC("\0int\0x\0dead\0main\0int a=1+1;\0/* live call */"
6386 "\0return 0;\0/* dead */\0/* dead */"),
6387 .insns = {
6388 BPF_MOV64_IMM(BPF_REG_2, 1),
6389 BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6390 BPF_CALL_REL(2),
6391 BPF_MOV64_IMM(BPF_REG_0, 0),
6392 BPF_EXIT_INSN(),
6393 BPF_MOV64_IMM(BPF_REG_0, 0),
6394 BPF_EXIT_INSN(),
6395 },
6396 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6397 .func_info_cnt = 2,
6398 .func_info_rec_size = 8,
6399 .func_info = { {0, 4}, {5, 3} },
6400 .line_info = {
6401 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6402 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6403 BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6404 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6405 BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6406 BTF_END_RAW,
6407 },
6408 .line_info_rec_size = sizeof(struct bpf_line_info),
6409 .nr_jited_ksyms = 1,
6410 .dead_code_cnt = 2,
6411 .dead_code_mask = 0x18,
6412 .dead_func_cnt = 1,
6413 .dead_func_mask = 0x2,
6414 },
6415
6416 {
6417 .descr = "line_info (dead subprog + dead start)",
6418 .raw_types = {
6419 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6420 BTF_FUNC_PROTO_ENC(1, 1), /* [2] */
6421 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6422 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
6423 BTF_FUNC_ENC(NAME_TBD, 2), /* [4] */
6424 BTF_FUNC_ENC(NAME_TBD, 2), /* [5] */
6425 BTF_END_RAW,
6426 },
6427 BTF_STR_SEC("\0int\0x\0dead\0main\0func\0int a=1+1;\0/* dead */"
6428 "\0return 0;\0return 0;\0return 0;"
6429 "\0/* dead */\0/* dead */\0/* dead */\0/* dead */"
6430 "\0return b + 1;\0return b + 1;\0return b + 1;"),
6431 .insns = {
6432 BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6433 BPF_MOV64_IMM(BPF_REG_2, 1),
6434 BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6435 BPF_CALL_REL(3),
6436 BPF_CALL_REL(5),
6437 BPF_MOV64_IMM(BPF_REG_0, 0),
6438 BPF_EXIT_INSN(),
6439 BPF_MOV64_IMM(BPF_REG_0, 0),
6440 BPF_CALL_REL(1),
6441 BPF_EXIT_INSN(),
6442 BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6443 BPF_MOV64_REG(BPF_REG_0, 2),
6444 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6445 BPF_EXIT_INSN(),
6446 },
6447 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6448 .func_info_cnt = 3,
6449 .func_info_rec_size = 8,
6450 .func_info = { {0, 4}, {7, 3}, {10, 5} },
6451 .line_info = {
6452 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6453 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6454 BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6455 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6456 BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6457 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6458 BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6459 BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6460 BPF_LINE_INFO_ENC(10, 0, NAME_TBD, 1, 10),
6461 BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 2, 9),
6462 BPF_LINE_INFO_ENC(12, 0, NAME_TBD, 2, 9),
6463 BPF_LINE_INFO_ENC(13, 0, NAME_TBD, 2, 9),
6464 BTF_END_RAW,
6465 },
6466 .line_info_rec_size = sizeof(struct bpf_line_info),
6467 .nr_jited_ksyms = 2,
6468 .dead_code_cnt = 5,
6469 .dead_code_mask = 0x1e2,
6470 .dead_func_cnt = 1,
6471 .dead_func_mask = 0x2,
6472 },
6473
6474 {
6475 .descr = "line_info (dead subprog + dead start w/ move)",
6476 .raw_types = {
6477 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6478 BTF_FUNC_PROTO_ENC(1, 1), /* [2] */
6479 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6480 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
6481 BTF_FUNC_ENC(NAME_TBD, 2), /* [4] */
6482 BTF_FUNC_ENC(NAME_TBD, 2), /* [5] */
6483 BTF_END_RAW,
6484 },
6485 BTF_STR_SEC("\0int\0x\0dead\0main\0func\0int a=1+1;\0/* live call */"
6486 "\0return 0;\0return 0;\0/* dead */\0/* dead */"
6487 "\0/* dead */\0return bla + 1;\0return bla + 1;"
6488 "\0return bla + 1;\0return func(a);\0b+=1;\0return b;"),
6489 .insns = {
6490 BPF_MOV64_IMM(BPF_REG_2, 1),
6491 BPF_JMP_IMM(BPF_JGE, BPF_REG_2, 0, 1),
6492 BPF_CALL_REL(3),
6493 BPF_CALL_REL(5),
6494 BPF_MOV64_IMM(BPF_REG_0, 0),
6495 BPF_EXIT_INSN(),
6496 BPF_MOV64_IMM(BPF_REG_0, 0),
6497 BPF_CALL_REL(1),
6498 BPF_EXIT_INSN(),
6499 BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6500 BPF_MOV64_REG(BPF_REG_0, 2),
6501 BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1),
6502 BPF_EXIT_INSN(),
6503 },
6504 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6505 .func_info_cnt = 3,
6506 .func_info_rec_size = 8,
6507 .func_info = { {0, 4}, {6, 3}, {9, 5} },
6508 .line_info = {
6509 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6510 BPF_LINE_INFO_ENC(3, 0, NAME_TBD, 1, 10),
6511 BPF_LINE_INFO_ENC(4, 0, NAME_TBD, 1, 10),
6512 BPF_LINE_INFO_ENC(5, 0, NAME_TBD, 1, 10),
6513 BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6514 BPF_LINE_INFO_ENC(7, 0, NAME_TBD, 1, 10),
6515 BPF_LINE_INFO_ENC(8, 0, NAME_TBD, 1, 10),
6516 BPF_LINE_INFO_ENC(9, 0, NAME_TBD, 1, 10),
6517 BPF_LINE_INFO_ENC(11, 0, NAME_TBD, 1, 10),
6518 BPF_LINE_INFO_ENC(12, 0, NAME_TBD, 2, 9),
6519 BTF_END_RAW,
6520 },
6521 .line_info_rec_size = sizeof(struct bpf_line_info),
6522 .nr_jited_ksyms = 2,
6523 .dead_code_cnt = 3,
6524 .dead_code_mask = 0x70,
6525 .dead_func_cnt = 1,
6526 .dead_func_mask = 0x2,
6527 },
6528
6529 {
6530 .descr = "line_info (dead end + subprog start w/ no linfo)",
6531 .raw_types = {
6532 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
6533 BTF_FUNC_PROTO_ENC(1, 1), /* [2] */
6534 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
6535 BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
6536 BTF_FUNC_ENC(NAME_TBD, 2), /* [4] */
6537 BTF_END_RAW,
6538 },
6539 BTF_STR_SEC("\0int\0x\0main\0func\0/* main linfo */\0/* func linfo */"),
6540 .insns = {
6541 BPF_MOV64_IMM(BPF_REG_0, 0),
6542 BPF_JMP_IMM(BPF_JGE, BPF_REG_0, 1, 3),
6543 BPF_CALL_REL(3),
6544 BPF_MOV64_IMM(BPF_REG_0, 0),
6545 BPF_EXIT_INSN(),
6546 BPF_EXIT_INSN(),
6547 BPF_JMP_IMM(BPF_JA, 0, 0, 0),
6548 BPF_EXIT_INSN(),
6549 },
6550 .prog_type = BPF_PROG_TYPE_TRACEPOINT,
6551 .func_info_cnt = 2,
6552 .func_info_rec_size = 8,
6553 .func_info = { {0, 3}, {6, 4}, },
6554 .line_info = {
6555 BPF_LINE_INFO_ENC(0, 0, NAME_TBD, 1, 10),
6556 BPF_LINE_INFO_ENC(6, 0, NAME_TBD, 1, 10),
6557 BTF_END_RAW,
6558 },
6559 .line_info_rec_size = sizeof(struct bpf_line_info),
6560 .nr_jited_ksyms = 2,
6561 },
6562
6563 };
6564
probe_prog_length(const struct bpf_insn * fp)6565 static size_t probe_prog_length(const struct bpf_insn *fp)
6566 {
6567 size_t len;
6568
6569 for (len = MAX_INSNS - 1; len > 0; --len)
6570 if (fp[len].code != 0 || fp[len].imm != 0)
6571 break;
6572 return len + 1;
6573 }
6574
patch_name_tbd(const __u32 * raw_u32,const char * str,__u32 str_off,unsigned int str_sec_size,unsigned int * ret_size)6575 static __u32 *patch_name_tbd(const __u32 *raw_u32,
6576 const char *str, __u32 str_off,
6577 unsigned int str_sec_size,
6578 unsigned int *ret_size)
6579 {
6580 int i, raw_u32_size = get_raw_sec_size(raw_u32);
6581 const char *end_str = str + str_sec_size;
6582 const char *next_str = str + str_off;
6583 __u32 *new_u32 = NULL;
6584
6585 if (raw_u32_size == -1)
6586 return ERR_PTR(-EINVAL);
6587
6588 if (!raw_u32_size) {
6589 *ret_size = 0;
6590 return NULL;
6591 }
6592
6593 new_u32 = malloc(raw_u32_size);
6594 if (!new_u32)
6595 return ERR_PTR(-ENOMEM);
6596
6597 for (i = 0; i < raw_u32_size / sizeof(raw_u32[0]); i++) {
6598 if (raw_u32[i] == NAME_TBD) {
6599 next_str = get_next_str(next_str, end_str);
6600 if (CHECK(!next_str, "Error in getting next_str\n")) {
6601 free(new_u32);
6602 return ERR_PTR(-EINVAL);
6603 }
6604 new_u32[i] = next_str - str;
6605 next_str += strlen(next_str);
6606 } else {
6607 new_u32[i] = raw_u32[i];
6608 }
6609 }
6610
6611 *ret_size = raw_u32_size;
6612 return new_u32;
6613 }
6614
test_get_finfo(const struct prog_info_raw_test * test,int prog_fd)6615 static int test_get_finfo(const struct prog_info_raw_test *test,
6616 int prog_fd)
6617 {
6618 struct bpf_prog_info info = {};
6619 struct bpf_func_info *finfo;
6620 __u32 info_len, rec_size, i;
6621 void *func_info = NULL;
6622 __u32 nr_func_info;
6623 int err;
6624
6625 /* get necessary lens */
6626 info_len = sizeof(struct bpf_prog_info);
6627 err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6628 if (CHECK(err < 0, "invalid get info (1st) errno:%d", errno)) {
6629 fprintf(stderr, "%s\n", btf_log_buf);
6630 return -1;
6631 }
6632 nr_func_info = test->func_info_cnt - test->dead_func_cnt;
6633 if (CHECK(info.nr_func_info != nr_func_info,
6634 "incorrect info.nr_func_info (1st) %d",
6635 info.nr_func_info)) {
6636 return -1;
6637 }
6638
6639 rec_size = info.func_info_rec_size;
6640 if (CHECK(rec_size != sizeof(struct bpf_func_info),
6641 "incorrect info.func_info_rec_size (1st) %d", rec_size)) {
6642 return -1;
6643 }
6644
6645 if (!info.nr_func_info)
6646 return 0;
6647
6648 func_info = malloc(info.nr_func_info * rec_size);
6649 if (CHECK(!func_info, "out of memory"))
6650 return -1;
6651
6652 /* reset info to only retrieve func_info related data */
6653 memset(&info, 0, sizeof(info));
6654 info.nr_func_info = nr_func_info;
6655 info.func_info_rec_size = rec_size;
6656 info.func_info = ptr_to_u64(func_info);
6657 err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6658 if (CHECK(err < 0, "invalid get info (2nd) errno:%d", errno)) {
6659 fprintf(stderr, "%s\n", btf_log_buf);
6660 err = -1;
6661 goto done;
6662 }
6663 if (CHECK(info.nr_func_info != nr_func_info,
6664 "incorrect info.nr_func_info (2nd) %d",
6665 info.nr_func_info)) {
6666 err = -1;
6667 goto done;
6668 }
6669 if (CHECK(info.func_info_rec_size != rec_size,
6670 "incorrect info.func_info_rec_size (2nd) %d",
6671 info.func_info_rec_size)) {
6672 err = -1;
6673 goto done;
6674 }
6675
6676 finfo = func_info;
6677 for (i = 0; i < nr_func_info; i++) {
6678 if (test->dead_func_mask & (1 << i))
6679 continue;
6680 if (CHECK(finfo->type_id != test->func_info[i][1],
6681 "incorrect func_type %u expected %u",
6682 finfo->type_id, test->func_info[i][1])) {
6683 err = -1;
6684 goto done;
6685 }
6686 finfo = (void *)finfo + rec_size;
6687 }
6688
6689 err = 0;
6690
6691 done:
6692 free(func_info);
6693 return err;
6694 }
6695
test_get_linfo(const struct prog_info_raw_test * test,const void * patched_linfo,__u32 cnt,int prog_fd)6696 static int test_get_linfo(const struct prog_info_raw_test *test,
6697 const void *patched_linfo,
6698 __u32 cnt, int prog_fd)
6699 {
6700 __u32 i, info_len, nr_jited_ksyms, nr_jited_func_lens;
6701 __u64 *jited_linfo = NULL, *jited_ksyms = NULL;
6702 __u32 rec_size, jited_rec_size, jited_cnt;
6703 struct bpf_line_info *linfo = NULL;
6704 __u32 cur_func_len, ksyms_found;
6705 struct bpf_prog_info info = {};
6706 __u32 *jited_func_lens = NULL;
6707 __u64 cur_func_ksyms;
6708 __u32 dead_insns;
6709 int err;
6710
6711 jited_cnt = cnt;
6712 rec_size = sizeof(*linfo);
6713 jited_rec_size = sizeof(*jited_linfo);
6714 if (test->nr_jited_ksyms)
6715 nr_jited_ksyms = test->nr_jited_ksyms;
6716 else
6717 nr_jited_ksyms = test->func_info_cnt - test->dead_func_cnt;
6718 nr_jited_func_lens = nr_jited_ksyms;
6719
6720 info_len = sizeof(struct bpf_prog_info);
6721 err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6722 if (CHECK(err < 0, "err:%d errno:%d", err, errno)) {
6723 err = -1;
6724 goto done;
6725 }
6726
6727 if (!info.jited_prog_len) {
6728 /* prog is not jited */
6729 jited_cnt = 0;
6730 nr_jited_ksyms = 1;
6731 nr_jited_func_lens = 1;
6732 }
6733
6734 if (CHECK(info.nr_line_info != cnt ||
6735 info.nr_jited_line_info != jited_cnt ||
6736 info.nr_jited_ksyms != nr_jited_ksyms ||
6737 info.nr_jited_func_lens != nr_jited_func_lens ||
6738 (!info.nr_line_info && info.nr_jited_line_info),
6739 "info: nr_line_info:%u(expected:%u) nr_jited_line_info:%u(expected:%u) nr_jited_ksyms:%u(expected:%u) nr_jited_func_lens:%u(expected:%u)",
6740 info.nr_line_info, cnt,
6741 info.nr_jited_line_info, jited_cnt,
6742 info.nr_jited_ksyms, nr_jited_ksyms,
6743 info.nr_jited_func_lens, nr_jited_func_lens)) {
6744 err = -1;
6745 goto done;
6746 }
6747
6748 if (CHECK(info.line_info_rec_size != sizeof(struct bpf_line_info) ||
6749 info.jited_line_info_rec_size != sizeof(__u64),
6750 "info: line_info_rec_size:%u(userspace expected:%u) jited_line_info_rec_size:%u(userspace expected:%u)",
6751 info.line_info_rec_size, rec_size,
6752 info.jited_line_info_rec_size, jited_rec_size)) {
6753 err = -1;
6754 goto done;
6755 }
6756
6757 if (!cnt)
6758 return 0;
6759
6760 rec_size = info.line_info_rec_size;
6761 jited_rec_size = info.jited_line_info_rec_size;
6762
6763 memset(&info, 0, sizeof(info));
6764
6765 linfo = calloc(cnt, rec_size);
6766 if (CHECK(!linfo, "!linfo")) {
6767 err = -1;
6768 goto done;
6769 }
6770 info.nr_line_info = cnt;
6771 info.line_info_rec_size = rec_size;
6772 info.line_info = ptr_to_u64(linfo);
6773
6774 if (jited_cnt) {
6775 jited_linfo = calloc(jited_cnt, jited_rec_size);
6776 jited_ksyms = calloc(nr_jited_ksyms, sizeof(*jited_ksyms));
6777 jited_func_lens = calloc(nr_jited_func_lens,
6778 sizeof(*jited_func_lens));
6779 if (CHECK(!jited_linfo || !jited_ksyms || !jited_func_lens,
6780 "jited_linfo:%p jited_ksyms:%p jited_func_lens:%p",
6781 jited_linfo, jited_ksyms, jited_func_lens)) {
6782 err = -1;
6783 goto done;
6784 }
6785
6786 info.nr_jited_line_info = jited_cnt;
6787 info.jited_line_info_rec_size = jited_rec_size;
6788 info.jited_line_info = ptr_to_u64(jited_linfo);
6789 info.nr_jited_ksyms = nr_jited_ksyms;
6790 info.jited_ksyms = ptr_to_u64(jited_ksyms);
6791 info.nr_jited_func_lens = nr_jited_func_lens;
6792 info.jited_func_lens = ptr_to_u64(jited_func_lens);
6793 }
6794
6795 err = bpf_prog_get_info_by_fd(prog_fd, &info, &info_len);
6796
6797 /*
6798 * Only recheck the info.*line_info* fields.
6799 * Other fields are not the concern of this test.
6800 */
6801 if (CHECK(err < 0 ||
6802 info.nr_line_info != cnt ||
6803 (jited_cnt && !info.jited_line_info) ||
6804 info.nr_jited_line_info != jited_cnt ||
6805 info.line_info_rec_size != rec_size ||
6806 info.jited_line_info_rec_size != jited_rec_size,
6807 "err:%d errno:%d info: nr_line_info:%u(expected:%u) nr_jited_line_info:%u(expected:%u) line_info_rec_size:%u(expected:%u) jited_linfo_rec_size:%u(expected:%u) line_info:%p jited_line_info:%p",
6808 err, errno,
6809 info.nr_line_info, cnt,
6810 info.nr_jited_line_info, jited_cnt,
6811 info.line_info_rec_size, rec_size,
6812 info.jited_line_info_rec_size, jited_rec_size,
6813 (void *)(long)info.line_info,
6814 (void *)(long)info.jited_line_info)) {
6815 err = -1;
6816 goto done;
6817 }
6818
6819 dead_insns = 0;
6820 while (test->dead_code_mask & (1 << dead_insns))
6821 dead_insns++;
6822
6823 CHECK(linfo[0].insn_off, "linfo[0].insn_off:%u",
6824 linfo[0].insn_off);
6825 for (i = 1; i < cnt; i++) {
6826 const struct bpf_line_info *expected_linfo;
6827
6828 while (test->dead_code_mask & (1 << (i + dead_insns)))
6829 dead_insns++;
6830
6831 expected_linfo = patched_linfo +
6832 ((i + dead_insns) * test->line_info_rec_size);
6833 if (CHECK(linfo[i].insn_off <= linfo[i - 1].insn_off,
6834 "linfo[%u].insn_off:%u <= linfo[%u].insn_off:%u",
6835 i, linfo[i].insn_off,
6836 i - 1, linfo[i - 1].insn_off)) {
6837 err = -1;
6838 goto done;
6839 }
6840 if (CHECK(linfo[i].file_name_off != expected_linfo->file_name_off ||
6841 linfo[i].line_off != expected_linfo->line_off ||
6842 linfo[i].line_col != expected_linfo->line_col,
6843 "linfo[%u] (%u, %u, %u) != (%u, %u, %u)", i,
6844 linfo[i].file_name_off,
6845 linfo[i].line_off,
6846 linfo[i].line_col,
6847 expected_linfo->file_name_off,
6848 expected_linfo->line_off,
6849 expected_linfo->line_col)) {
6850 err = -1;
6851 goto done;
6852 }
6853 }
6854
6855 if (!jited_cnt) {
6856 fprintf(stderr, "not jited. skipping jited_line_info check. ");
6857 err = 0;
6858 goto done;
6859 }
6860
6861 if (CHECK(jited_linfo[0] != jited_ksyms[0],
6862 "jited_linfo[0]:%lx != jited_ksyms[0]:%lx",
6863 (long)(jited_linfo[0]), (long)(jited_ksyms[0]))) {
6864 err = -1;
6865 goto done;
6866 }
6867
6868 ksyms_found = 1;
6869 cur_func_len = jited_func_lens[0];
6870 cur_func_ksyms = jited_ksyms[0];
6871 for (i = 1; i < jited_cnt; i++) {
6872 if (ksyms_found < nr_jited_ksyms &&
6873 jited_linfo[i] == jited_ksyms[ksyms_found]) {
6874 cur_func_ksyms = jited_ksyms[ksyms_found];
6875 cur_func_len = jited_ksyms[ksyms_found];
6876 ksyms_found++;
6877 continue;
6878 }
6879
6880 if (CHECK(jited_linfo[i] <= jited_linfo[i - 1],
6881 "jited_linfo[%u]:%lx <= jited_linfo[%u]:%lx",
6882 i, (long)jited_linfo[i],
6883 i - 1, (long)(jited_linfo[i - 1]))) {
6884 err = -1;
6885 goto done;
6886 }
6887
6888 if (CHECK(jited_linfo[i] - cur_func_ksyms > cur_func_len,
6889 "jited_linfo[%u]:%lx - %lx > %u",
6890 i, (long)jited_linfo[i], (long)cur_func_ksyms,
6891 cur_func_len)) {
6892 err = -1;
6893 goto done;
6894 }
6895 }
6896
6897 if (CHECK(ksyms_found != nr_jited_ksyms,
6898 "ksyms_found:%u != nr_jited_ksyms:%u",
6899 ksyms_found, nr_jited_ksyms)) {
6900 err = -1;
6901 goto done;
6902 }
6903
6904 err = 0;
6905
6906 done:
6907 free(linfo);
6908 free(jited_linfo);
6909 free(jited_ksyms);
6910 free(jited_func_lens);
6911 return err;
6912 }
6913
do_test_info_raw(unsigned int test_num)6914 static void do_test_info_raw(unsigned int test_num)
6915 {
6916 const struct prog_info_raw_test *test = &info_raw_tests[test_num - 1];
6917 unsigned int raw_btf_size, linfo_str_off, linfo_size = 0;
6918 int btf_fd = -1, prog_fd = -1, err = 0;
6919 void *raw_btf, *patched_linfo = NULL;
6920 const char *ret_next_str;
6921 union bpf_attr attr = {};
6922
6923 if (!test__start_subtest(test->descr))
6924 return;
6925
6926 raw_btf = btf_raw_create(&hdr_tmpl, test->raw_types,
6927 test->str_sec, test->str_sec_size,
6928 &raw_btf_size, &ret_next_str);
6929 if (!raw_btf)
6930 return;
6931
6932 *btf_log_buf = '\0';
6933 btf_fd = load_raw_btf(raw_btf, raw_btf_size);
6934 free(raw_btf);
6935
6936 if (CHECK(btf_fd < 0, "invalid btf_fd errno:%d", errno)) {
6937 err = -1;
6938 goto done;
6939 }
6940
6941 if (*btf_log_buf && always_log)
6942 fprintf(stderr, "\n%s", btf_log_buf);
6943 *btf_log_buf = '\0';
6944
6945 linfo_str_off = ret_next_str - test->str_sec;
6946 patched_linfo = patch_name_tbd(test->line_info,
6947 test->str_sec, linfo_str_off,
6948 test->str_sec_size, &linfo_size);
6949 err = libbpf_get_error(patched_linfo);
6950 if (err) {
6951 fprintf(stderr, "error in creating raw bpf_line_info");
6952 err = -1;
6953 goto done;
6954 }
6955
6956 attr.prog_type = test->prog_type;
6957 attr.insns = ptr_to_u64(test->insns);
6958 attr.insn_cnt = probe_prog_length(test->insns);
6959 attr.license = ptr_to_u64("GPL");
6960 attr.prog_btf_fd = btf_fd;
6961 attr.func_info_rec_size = test->func_info_rec_size;
6962 attr.func_info_cnt = test->func_info_cnt;
6963 attr.func_info = ptr_to_u64(test->func_info);
6964 attr.log_buf = ptr_to_u64(btf_log_buf);
6965 attr.log_size = BTF_LOG_BUF_SIZE;
6966 attr.log_level = 1;
6967 if (linfo_size) {
6968 attr.line_info_rec_size = test->line_info_rec_size;
6969 attr.line_info = ptr_to_u64(patched_linfo);
6970 attr.line_info_cnt = linfo_size / attr.line_info_rec_size;
6971 }
6972
6973 prog_fd = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
6974 err = ((prog_fd < 0) != test->expected_prog_load_failure);
6975 if (CHECK(err, "prog_fd:%d expected_prog_load_failure:%u errno:%d",
6976 prog_fd, test->expected_prog_load_failure, errno) ||
6977 CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
6978 "expected err_str:%s", test->err_str)) {
6979 err = -1;
6980 goto done;
6981 }
6982
6983 if (prog_fd < 0)
6984 goto done;
6985
6986 err = test_get_finfo(test, prog_fd);
6987 if (err)
6988 goto done;
6989
6990 err = test_get_linfo(test, patched_linfo,
6991 attr.line_info_cnt - test->dead_code_cnt,
6992 prog_fd);
6993 if (err)
6994 goto done;
6995
6996 done:
6997 if (*btf_log_buf && (err || always_log))
6998 fprintf(stderr, "\n%s", btf_log_buf);
6999
7000 if (btf_fd >= 0)
7001 close(btf_fd);
7002 if (prog_fd >= 0)
7003 close(prog_fd);
7004
7005 if (!libbpf_get_error(patched_linfo))
7006 free(patched_linfo);
7007 }
7008
7009 struct btf_raw_data {
7010 __u32 raw_types[MAX_NR_RAW_U32];
7011 const char *str_sec;
7012 __u32 str_sec_size;
7013 };
7014
7015 struct btf_dedup_test {
7016 const char *descr;
7017 struct btf_raw_data input;
7018 struct btf_raw_data expect;
7019 struct btf_dedup_opts opts;
7020 };
7021
7022 static struct btf_dedup_test dedup_tests[] = {
7023
7024 {
7025 .descr = "dedup: unused strings filtering",
7026 .input = {
7027 .raw_types = {
7028 BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 4),
7029 BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 64, 8),
7030 BTF_END_RAW,
7031 },
7032 BTF_STR_SEC("\0unused\0int\0foo\0bar\0long"),
7033 },
7034 .expect = {
7035 .raw_types = {
7036 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
7037 BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
7038 BTF_END_RAW,
7039 },
7040 BTF_STR_SEC("\0int\0long"),
7041 },
7042 },
7043 {
7044 .descr = "dedup: strings deduplication",
7045 .input = {
7046 .raw_types = {
7047 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
7048 BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
7049 BTF_TYPE_INT_ENC(NAME_NTH(3), BTF_INT_SIGNED, 0, 32, 4),
7050 BTF_TYPE_INT_ENC(NAME_NTH(4), BTF_INT_SIGNED, 0, 64, 8),
7051 BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 32, 4),
7052 BTF_END_RAW,
7053 },
7054 BTF_STR_SEC("\0int\0long int\0int\0long int\0int"),
7055 },
7056 .expect = {
7057 .raw_types = {
7058 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
7059 BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
7060 BTF_END_RAW,
7061 },
7062 BTF_STR_SEC("\0int\0long int"),
7063 },
7064 },
7065 {
7066 .descr = "dedup: struct example #1",
7067 /*
7068 * struct s {
7069 * struct s *next;
7070 * const int *a;
7071 * int b[16];
7072 * int c;
7073 * }
7074 */
7075 .input = {
7076 .raw_types = {
7077 /* int */
7078 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7079 /* int[16] */
7080 BTF_TYPE_ARRAY_ENC(1, 1, 16), /* [2] */
7081 /* struct s { */
7082 BTF_STRUCT_ENC(NAME_NTH(2), 5, 88), /* [3] */
7083 BTF_MEMBER_ENC(NAME_NTH(3), 4, 0), /* struct s *next; */
7084 BTF_MEMBER_ENC(NAME_NTH(4), 5, 64), /* const int *a; */
7085 BTF_MEMBER_ENC(NAME_NTH(5), 2, 128), /* int b[16]; */
7086 BTF_MEMBER_ENC(NAME_NTH(6), 1, 640), /* int c; */
7087 BTF_MEMBER_ENC(NAME_NTH(8), 15, 672), /* float d; */
7088 /* ptr -> [3] struct s */
7089 BTF_PTR_ENC(3), /* [4] */
7090 /* ptr -> [6] const int */
7091 BTF_PTR_ENC(6), /* [5] */
7092 /* const -> [1] int */
7093 BTF_CONST_ENC(1), /* [6] */
7094 /* tag -> [3] struct s */
7095 BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1), /* [7] */
7096 /* tag -> [3] struct s, member 1 */
7097 BTF_DECL_TAG_ENC(NAME_NTH(2), 3, 1), /* [8] */
7098
7099 /* full copy of the above */
7100 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [9] */
7101 BTF_TYPE_ARRAY_ENC(9, 9, 16), /* [10] */
7102 BTF_STRUCT_ENC(NAME_NTH(2), 5, 88), /* [11] */
7103 BTF_MEMBER_ENC(NAME_NTH(3), 12, 0),
7104 BTF_MEMBER_ENC(NAME_NTH(4), 13, 64),
7105 BTF_MEMBER_ENC(NAME_NTH(5), 10, 128),
7106 BTF_MEMBER_ENC(NAME_NTH(6), 9, 640),
7107 BTF_MEMBER_ENC(NAME_NTH(8), 15, 672),
7108 BTF_PTR_ENC(11), /* [12] */
7109 BTF_PTR_ENC(14), /* [13] */
7110 BTF_CONST_ENC(9), /* [14] */
7111 BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [15] */
7112 BTF_DECL_TAG_ENC(NAME_NTH(2), 11, -1), /* [16] */
7113 BTF_DECL_TAG_ENC(NAME_NTH(2), 11, 1), /* [17] */
7114 BTF_END_RAW,
7115 },
7116 BTF_STR_SEC("\0int\0s\0next\0a\0b\0c\0float\0d"),
7117 },
7118 .expect = {
7119 .raw_types = {
7120 /* int */
7121 BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7122 /* int[16] */
7123 BTF_TYPE_ARRAY_ENC(1, 1, 16), /* [2] */
7124 /* struct s { */
7125 BTF_STRUCT_ENC(NAME_NTH(8), 5, 88), /* [3] */
7126 BTF_MEMBER_ENC(NAME_NTH(7), 4, 0), /* struct s *next; */
7127 BTF_MEMBER_ENC(NAME_NTH(1), 5, 64), /* const int *a; */
7128 BTF_MEMBER_ENC(NAME_NTH(2), 2, 128), /* int b[16]; */
7129 BTF_MEMBER_ENC(NAME_NTH(3), 1, 640), /* int c; */
7130 BTF_MEMBER_ENC(NAME_NTH(4), 9, 672), /* float d; */
7131 /* ptr -> [3] struct s */
7132 BTF_PTR_ENC(3), /* [4] */
7133 /* ptr -> [6] const int */
7134 BTF_PTR_ENC(6), /* [5] */
7135 /* const -> [1] int */
7136 BTF_CONST_ENC(1), /* [6] */
7137 BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1), /* [7] */
7138 BTF_DECL_TAG_ENC(NAME_NTH(2), 3, 1), /* [8] */
7139 BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [9] */
7140 BTF_END_RAW,
7141 },
7142 BTF_STR_SEC("\0a\0b\0c\0d\0int\0float\0next\0s"),
7143 },
7144 },
7145 {
7146 .descr = "dedup: struct <-> fwd resolution w/ hash collision",
7147 /*
7148 * // CU 1:
7149 * struct x;
7150 * struct s {
7151 * struct x *x;
7152 * };
7153 * // CU 2:
7154 * struct x {};
7155 * struct s {
7156 * struct x *x;
7157 * };
7158 */
7159 .input = {
7160 .raw_types = {
7161 /* CU 1 */
7162 BTF_FWD_ENC(NAME_TBD, 0 /* struct fwd */), /* [1] fwd x */
7163 BTF_PTR_ENC(1), /* [2] ptr -> [1] */
7164 BTF_STRUCT_ENC(NAME_TBD, 1, 8), /* [3] struct s */
7165 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
7166 /* CU 2 */
7167 BTF_STRUCT_ENC(NAME_TBD, 0, 0), /* [4] struct x */
7168 BTF_PTR_ENC(4), /* [5] ptr -> [4] */
7169 BTF_STRUCT_ENC(NAME_TBD, 1, 8), /* [6] struct s */
7170 BTF_MEMBER_ENC(NAME_TBD, 5, 0),
7171 BTF_END_RAW,
7172 },
7173 BTF_STR_SEC("\0x\0s\0x\0x\0s\0x\0"),
7174 },
7175 .expect = {
7176 .raw_types = {
7177 BTF_PTR_ENC(3), /* [1] ptr -> [3] */
7178 BTF_STRUCT_ENC(NAME_TBD, 1, 8), /* [2] struct s */
7179 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7180 BTF_STRUCT_ENC(NAME_NTH(2), 0, 0), /* [3] struct x */
7181 BTF_END_RAW,
7182 },
7183 BTF_STR_SEC("\0s\0x"),
7184 },
7185 .opts = {
7186 .force_collisions = true, /* force hash collisions */
7187 },
7188 },
7189 {
7190 .descr = "dedup: void equiv check",
7191 /*
7192 * // CU 1:
7193 * struct s {
7194 * struct {} *x;
7195 * };
7196 * // CU 2:
7197 * struct s {
7198 * int *x;
7199 * };
7200 */
7201 .input = {
7202 .raw_types = {
7203 /* CU 1 */
7204 BTF_STRUCT_ENC(0, 0, 1), /* [1] struct {} */
7205 BTF_PTR_ENC(1), /* [2] ptr -> [1] */
7206 BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [3] struct s */
7207 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7208 /* CU 2 */
7209 BTF_PTR_ENC(0), /* [4] ptr -> void */
7210 BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [5] struct s */
7211 BTF_MEMBER_ENC(NAME_NTH(2), 4, 0),
7212 BTF_END_RAW,
7213 },
7214 BTF_STR_SEC("\0s\0x"),
7215 },
7216 .expect = {
7217 .raw_types = {
7218 /* CU 1 */
7219 BTF_STRUCT_ENC(0, 0, 1), /* [1] struct {} */
7220 BTF_PTR_ENC(1), /* [2] ptr -> [1] */
7221 BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [3] struct s */
7222 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
7223 /* CU 2 */
7224 BTF_PTR_ENC(0), /* [4] ptr -> void */
7225 BTF_STRUCT_ENC(NAME_NTH(1), 1, 8), /* [5] struct s */
7226 BTF_MEMBER_ENC(NAME_NTH(2), 4, 0),
7227 BTF_END_RAW,
7228 },
7229 BTF_STR_SEC("\0s\0x"),
7230 },
7231 .opts = {
7232 .force_collisions = true, /* force hash collisions */
7233 },
7234 },
7235 {
7236 .descr = "dedup: all possible kinds (no duplicates)",
7237 .input = {
7238 .raw_types = {
7239 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 8), /* [1] int */
7240 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 4), /* [2] enum */
7241 BTF_ENUM_ENC(NAME_TBD, 0),
7242 BTF_ENUM_ENC(NAME_TBD, 1),
7243 BTF_FWD_ENC(NAME_TBD, 1 /* union kind_flag */), /* [3] fwd */
7244 BTF_TYPE_ARRAY_ENC(2, 1, 7), /* [4] array */
7245 BTF_STRUCT_ENC(NAME_TBD, 1, 4), /* [5] struct */
7246 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7247 BTF_UNION_ENC(NAME_TBD, 1, 4), /* [6] union */
7248 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7249 BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [7] typedef */
7250 BTF_PTR_ENC(0), /* [8] ptr */
7251 BTF_CONST_ENC(8), /* [9] const */
7252 BTF_VOLATILE_ENC(8), /* [10] volatile */
7253 BTF_RESTRICT_ENC(8), /* [11] restrict */
7254 BTF_FUNC_PROTO_ENC(1, 2), /* [12] func_proto */
7255 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
7256 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
7257 BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
7258 BTF_TYPE_FLOAT_ENC(NAME_TBD, 2), /* [14] float */
7259 BTF_DECL_TAG_ENC(NAME_TBD, 13, -1), /* [15] decl_tag */
7260 BTF_DECL_TAG_ENC(NAME_TBD, 13, 1), /* [16] decl_tag */
7261 BTF_DECL_TAG_ENC(NAME_TBD, 7, -1), /* [17] decl_tag */
7262 BTF_TYPE_TAG_ENC(NAME_TBD, 8), /* [18] type_tag */
7263 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 2), 8), /* [19] enum64 */
7264 BTF_ENUM64_ENC(NAME_TBD, 0, 0),
7265 BTF_ENUM64_ENC(NAME_TBD, 1, 1),
7266 BTF_END_RAW,
7267 },
7268 BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R\0S\0T\0U"),
7269 },
7270 .expect = {
7271 .raw_types = {
7272 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 8), /* [1] int */
7273 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 4), /* [2] enum */
7274 BTF_ENUM_ENC(NAME_TBD, 0),
7275 BTF_ENUM_ENC(NAME_TBD, 1),
7276 BTF_FWD_ENC(NAME_TBD, 1 /* union kind_flag */), /* [3] fwd */
7277 BTF_TYPE_ARRAY_ENC(2, 1, 7), /* [4] array */
7278 BTF_STRUCT_ENC(NAME_TBD, 1, 4), /* [5] struct */
7279 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7280 BTF_UNION_ENC(NAME_TBD, 1, 4), /* [6] union */
7281 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
7282 BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [7] typedef */
7283 BTF_PTR_ENC(0), /* [8] ptr */
7284 BTF_CONST_ENC(8), /* [9] const */
7285 BTF_VOLATILE_ENC(8), /* [10] volatile */
7286 BTF_RESTRICT_ENC(8), /* [11] restrict */
7287 BTF_FUNC_PROTO_ENC(1, 2), /* [12] func_proto */
7288 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
7289 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
7290 BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
7291 BTF_TYPE_FLOAT_ENC(NAME_TBD, 2), /* [14] float */
7292 BTF_DECL_TAG_ENC(NAME_TBD, 13, -1), /* [15] decl_tag */
7293 BTF_DECL_TAG_ENC(NAME_TBD, 13, 1), /* [16] decl_tag */
7294 BTF_DECL_TAG_ENC(NAME_TBD, 7, -1), /* [17] decl_tag */
7295 BTF_TYPE_TAG_ENC(NAME_TBD, 8), /* [18] type_tag */
7296 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 2), 8), /* [19] enum64 */
7297 BTF_ENUM64_ENC(NAME_TBD, 0, 0),
7298 BTF_ENUM64_ENC(NAME_TBD, 1, 1),
7299 BTF_END_RAW,
7300 },
7301 BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R\0S\0T\0U"),
7302 },
7303 },
7304 {
7305 .descr = "dedup: no int/float duplicates",
7306 .input = {
7307 .raw_types = {
7308 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 8),
7309 /* different name */
7310 BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 8),
7311 /* different encoding */
7312 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_CHAR, 0, 32, 8),
7313 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_BOOL, 0, 32, 8),
7314 /* different bit offset */
7315 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 8, 32, 8),
7316 /* different bit size */
7317 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 27, 8),
7318 /* different byte size */
7319 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
7320 /* all allowed sizes */
7321 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 2),
7322 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 4),
7323 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 8),
7324 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 12),
7325 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 16),
7326 BTF_END_RAW,
7327 },
7328 BTF_STR_SEC("\0int\0some other int\0float"),
7329 },
7330 .expect = {
7331 .raw_types = {
7332 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 8),
7333 /* different name */
7334 BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 8),
7335 /* different encoding */
7336 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_CHAR, 0, 32, 8),
7337 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_BOOL, 0, 32, 8),
7338 /* different bit offset */
7339 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 8, 32, 8),
7340 /* different bit size */
7341 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 27, 8),
7342 /* different byte size */
7343 BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
7344 /* all allowed sizes */
7345 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 2),
7346 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 4),
7347 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 8),
7348 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 12),
7349 BTF_TYPE_FLOAT_ENC(NAME_NTH(3), 16),
7350 BTF_END_RAW,
7351 },
7352 BTF_STR_SEC("\0int\0some other int\0float"),
7353 },
7354 },
7355 {
7356 .descr = "dedup: enum fwd resolution",
7357 .input = {
7358 .raw_types = {
7359 /* [1] fwd enum 'e1' before full enum */
7360 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 4),
7361 /* [2] full enum 'e1' after fwd */
7362 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7363 BTF_ENUM_ENC(NAME_NTH(2), 123),
7364 /* [3] full enum 'e2' before fwd */
7365 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7366 BTF_ENUM_ENC(NAME_NTH(4), 456),
7367 /* [4] fwd enum 'e2' after full enum */
7368 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 4),
7369 /* [5] fwd enum with different size, size does not matter for fwd */
7370 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 1),
7371 /* [6] incompatible full enum with different value */
7372 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7373 BTF_ENUM_ENC(NAME_NTH(2), 321),
7374 BTF_END_RAW,
7375 },
7376 BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7377 },
7378 .expect = {
7379 .raw_types = {
7380 /* [1] full enum 'e1' */
7381 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7382 BTF_ENUM_ENC(NAME_NTH(2), 123),
7383 /* [2] full enum 'e2' */
7384 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7385 BTF_ENUM_ENC(NAME_NTH(4), 456),
7386 /* [3] incompatible full enum with different value */
7387 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7388 BTF_ENUM_ENC(NAME_NTH(2), 321),
7389 BTF_END_RAW,
7390 },
7391 BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7392 },
7393 },
7394 {
7395 .descr = "dedup: datasec and vars pass-through",
7396 .input = {
7397 .raw_types = {
7398 /* int */
7399 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7400 /* static int t */
7401 BTF_VAR_ENC(NAME_NTH(2), 1, 0), /* [2] */
7402 /* .bss section */ /* [3] */
7403 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7404 BTF_VAR_SECINFO_ENC(2, 0, 4),
7405 /* int, referenced from [5] */
7406 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [4] */
7407 /* another static int t */
7408 BTF_VAR_ENC(NAME_NTH(2), 4, 0), /* [5] */
7409 /* another .bss section */ /* [6] */
7410 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7411 BTF_VAR_SECINFO_ENC(5, 0, 4),
7412 BTF_END_RAW,
7413 },
7414 BTF_STR_SEC("\0.bss\0t"),
7415 },
7416 .expect = {
7417 .raw_types = {
7418 /* int */
7419 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7420 /* static int t */
7421 BTF_VAR_ENC(NAME_NTH(2), 1, 0), /* [2] */
7422 /* .bss section */ /* [3] */
7423 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7424 BTF_VAR_SECINFO_ENC(2, 0, 4),
7425 /* another static int t */
7426 BTF_VAR_ENC(NAME_NTH(2), 1, 0), /* [4] */
7427 /* another .bss section */ /* [5] */
7428 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
7429 BTF_VAR_SECINFO_ENC(4, 0, 4),
7430 BTF_END_RAW,
7431 },
7432 BTF_STR_SEC("\0.bss\0t"),
7433 },
7434 .opts = {
7435 .force_collisions = true
7436 },
7437 },
7438 {
7439 .descr = "dedup: func/func_arg/var tags",
7440 .input = {
7441 .raw_types = {
7442 /* int */
7443 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7444 /* static int t */
7445 BTF_VAR_ENC(NAME_NTH(1), 1, 0), /* [2] */
7446 /* void f(int a1, int a2) */
7447 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
7448 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7449 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
7450 BTF_FUNC_ENC(NAME_NTH(4), 3), /* [4] */
7451 /* tag -> t */
7452 BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
7453 BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [6] */
7454 /* tag -> func */
7455 BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1), /* [7] */
7456 BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1), /* [8] */
7457 /* tag -> func arg a1 */
7458 BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1), /* [9] */
7459 BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1), /* [10] */
7460 BTF_END_RAW,
7461 },
7462 BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
7463 },
7464 .expect = {
7465 .raw_types = {
7466 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7467 BTF_VAR_ENC(NAME_NTH(1), 1, 0), /* [2] */
7468 BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
7469 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7470 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
7471 BTF_FUNC_ENC(NAME_NTH(4), 3), /* [4] */
7472 BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
7473 BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1), /* [6] */
7474 BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1), /* [7] */
7475 BTF_END_RAW,
7476 },
7477 BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
7478 },
7479 },
7480 {
7481 .descr = "dedup: func/func_param tags",
7482 .input = {
7483 .raw_types = {
7484 /* int */
7485 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7486 /* void f(int a1, int a2) */
7487 BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
7488 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
7489 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7490 BTF_FUNC_ENC(NAME_NTH(3), 2), /* [3] */
7491 /* void f(int a1, int a2) */
7492 BTF_FUNC_PROTO_ENC(0, 2), /* [4] */
7493 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
7494 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7495 BTF_FUNC_ENC(NAME_NTH(3), 4), /* [5] */
7496 /* tag -> f: tag1, tag2 */
7497 BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [6] */
7498 BTF_DECL_TAG_ENC(NAME_NTH(5), 3, -1), /* [7] */
7499 /* tag -> f/a2: tag1, tag2 */
7500 BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1), /* [8] */
7501 BTF_DECL_TAG_ENC(NAME_NTH(5), 3, 1), /* [9] */
7502 /* tag -> f: tag1, tag3 */
7503 BTF_DECL_TAG_ENC(NAME_NTH(4), 5, -1), /* [10] */
7504 BTF_DECL_TAG_ENC(NAME_NTH(6), 5, -1), /* [11] */
7505 /* tag -> f/a2: tag1, tag3 */
7506 BTF_DECL_TAG_ENC(NAME_NTH(4), 5, 1), /* [12] */
7507 BTF_DECL_TAG_ENC(NAME_NTH(6), 5, 1), /* [13] */
7508 BTF_END_RAW,
7509 },
7510 BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
7511 },
7512 .expect = {
7513 .raw_types = {
7514 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7515 BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
7516 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
7517 BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
7518 BTF_FUNC_ENC(NAME_NTH(3), 2), /* [3] */
7519 BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [4] */
7520 BTF_DECL_TAG_ENC(NAME_NTH(5), 3, -1), /* [5] */
7521 BTF_DECL_TAG_ENC(NAME_NTH(6), 3, -1), /* [6] */
7522 BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1), /* [7] */
7523 BTF_DECL_TAG_ENC(NAME_NTH(5), 3, 1), /* [8] */
7524 BTF_DECL_TAG_ENC(NAME_NTH(6), 3, 1), /* [9] */
7525 BTF_END_RAW,
7526 },
7527 BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
7528 },
7529 },
7530 {
7531 .descr = "dedup: struct/struct_member tags",
7532 .input = {
7533 .raw_types = {
7534 /* int */
7535 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7536 BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [2] */
7537 BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
7538 BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
7539 BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [3] */
7540 BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
7541 BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
7542 /* tag -> t: tag1, tag2 */
7543 BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1), /* [4] */
7544 BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
7545 /* tag -> t/m2: tag1, tag2 */
7546 BTF_DECL_TAG_ENC(NAME_NTH(4), 2, 1), /* [6] */
7547 BTF_DECL_TAG_ENC(NAME_NTH(5), 2, 1), /* [7] */
7548 /* tag -> t: tag1, tag3 */
7549 BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [8] */
7550 BTF_DECL_TAG_ENC(NAME_NTH(6), 3, -1), /* [9] */
7551 /* tag -> t/m2: tag1, tag3 */
7552 BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1), /* [10] */
7553 BTF_DECL_TAG_ENC(NAME_NTH(6), 3, 1), /* [11] */
7554 BTF_END_RAW,
7555 },
7556 BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
7557 },
7558 .expect = {
7559 .raw_types = {
7560 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7561 BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [2] */
7562 BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
7563 BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
7564 BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1), /* [3] */
7565 BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [4] */
7566 BTF_DECL_TAG_ENC(NAME_NTH(6), 2, -1), /* [5] */
7567 BTF_DECL_TAG_ENC(NAME_NTH(4), 2, 1), /* [6] */
7568 BTF_DECL_TAG_ENC(NAME_NTH(5), 2, 1), /* [7] */
7569 BTF_DECL_TAG_ENC(NAME_NTH(6), 2, 1), /* [8] */
7570 BTF_END_RAW,
7571 },
7572 BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
7573 },
7574 },
7575 {
7576 .descr = "dedup: recursive typedef",
7577 /*
7578 * This test simulates a recursive typedef, which in GO is defined as such:
7579 *
7580 * type Foo func() Foo
7581 *
7582 * In BTF terms, this is represented as a TYPEDEF referencing
7583 * a FUNC_PROTO that returns the same TYPEDEF.
7584 */
7585 .input = {
7586 .raw_types = {
7587 /*
7588 * [1] typedef Foo -> func() Foo
7589 * [2] func_proto() -> Foo
7590 * [3] typedef Foo -> func() Foo
7591 * [4] func_proto() -> Foo
7592 */
7593 BTF_TYPEDEF_ENC(NAME_NTH(1), 2), /* [1] */
7594 BTF_FUNC_PROTO_ENC(1, 0), /* [2] */
7595 BTF_TYPEDEF_ENC(NAME_NTH(1), 4), /* [3] */
7596 BTF_FUNC_PROTO_ENC(3, 0), /* [4] */
7597 BTF_END_RAW,
7598 },
7599 BTF_STR_SEC("\0Foo"),
7600 },
7601 .expect = {
7602 .raw_types = {
7603 BTF_TYPEDEF_ENC(NAME_NTH(1), 2), /* [1] */
7604 BTF_FUNC_PROTO_ENC(1, 0), /* [2] */
7605 BTF_END_RAW,
7606 },
7607 BTF_STR_SEC("\0Foo"),
7608 },
7609 },
7610 {
7611 .descr = "dedup: typedef",
7612 /*
7613 * // CU 1:
7614 * typedef int foo;
7615 *
7616 * // CU 2:
7617 * typedef int foo;
7618 */
7619 .input = {
7620 .raw_types = {
7621 /* CU 1 */
7622 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7623 BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [2] */
7624 /* CU 2 */
7625 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [3] */
7626 BTF_TYPEDEF_ENC(NAME_NTH(1), 3), /* [4] */
7627 BTF_END_RAW,
7628 },
7629 BTF_STR_SEC("\0foo"),
7630 },
7631 .expect = {
7632 .raw_types = {
7633 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7634 BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [2] */
7635 BTF_END_RAW,
7636 },
7637 BTF_STR_SEC("\0foo"),
7638 },
7639 },
7640 {
7641 .descr = "dedup: typedef tags",
7642 .input = {
7643 .raw_types = {
7644 /* int */
7645 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7646 BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [2] */
7647 BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [3] */
7648 /* tag -> t: tag1, tag2 */
7649 BTF_DECL_TAG_ENC(NAME_NTH(2), 2, -1), /* [4] */
7650 BTF_DECL_TAG_ENC(NAME_NTH(3), 2, -1), /* [5] */
7651 /* tag -> t: tag1, tag3 */
7652 BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1), /* [6] */
7653 BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [7] */
7654 BTF_END_RAW,
7655 },
7656 BTF_STR_SEC("\0t\0tag1\0tag2\0tag3"),
7657 },
7658 .expect = {
7659 .raw_types = {
7660 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7661 BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [2] */
7662 BTF_DECL_TAG_ENC(NAME_NTH(2), 2, -1), /* [3] */
7663 BTF_DECL_TAG_ENC(NAME_NTH(3), 2, -1), /* [4] */
7664 BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1), /* [5] */
7665 BTF_END_RAW,
7666 },
7667 BTF_STR_SEC("\0t\0tag1\0tag2\0tag3"),
7668 },
7669 },
7670 {
7671 .descr = "dedup: btf_type_tag #1",
7672 .input = {
7673 .raw_types = {
7674 /* ptr -> tag2 -> tag1 -> int */
7675 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7676 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7677 BTF_TYPE_TAG_ENC(NAME_NTH(2), 2), /* [3] */
7678 BTF_PTR_ENC(3), /* [4] */
7679 /* ptr -> tag2 -> tag1 -> int */
7680 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [5] */
7681 BTF_TYPE_TAG_ENC(NAME_NTH(2), 5), /* [6] */
7682 BTF_PTR_ENC(6), /* [7] */
7683 /* ptr -> tag1 -> int */
7684 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [8] */
7685 BTF_PTR_ENC(8), /* [9] */
7686 BTF_END_RAW,
7687 },
7688 BTF_STR_SEC("\0tag1\0tag2"),
7689 },
7690 .expect = {
7691 .raw_types = {
7692 /* ptr -> tag2 -> tag1 -> int */
7693 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7694 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7695 BTF_TYPE_TAG_ENC(NAME_NTH(2), 2), /* [3] */
7696 BTF_PTR_ENC(3), /* [4] */
7697 /* ptr -> tag1 -> int */
7698 BTF_PTR_ENC(2), /* [5] */
7699 BTF_END_RAW,
7700 },
7701 BTF_STR_SEC("\0tag1\0tag2"),
7702 },
7703 },
7704 {
7705 .descr = "dedup: btf_type_tag #2",
7706 .input = {
7707 .raw_types = {
7708 /* ptr -> tag2 -> tag1 -> int */
7709 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7710 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7711 BTF_TYPE_TAG_ENC(NAME_NTH(2), 2), /* [3] */
7712 BTF_PTR_ENC(3), /* [4] */
7713 /* ptr -> tag2 -> int */
7714 BTF_TYPE_TAG_ENC(NAME_NTH(2), 1), /* [5] */
7715 BTF_PTR_ENC(5), /* [6] */
7716 BTF_END_RAW,
7717 },
7718 BTF_STR_SEC("\0tag1\0tag2"),
7719 },
7720 .expect = {
7721 .raw_types = {
7722 /* ptr -> tag2 -> tag1 -> int */
7723 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7724 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7725 BTF_TYPE_TAG_ENC(NAME_NTH(2), 2), /* [3] */
7726 BTF_PTR_ENC(3), /* [4] */
7727 /* ptr -> tag2 -> int */
7728 BTF_TYPE_TAG_ENC(NAME_NTH(2), 1), /* [5] */
7729 BTF_PTR_ENC(5), /* [6] */
7730 BTF_END_RAW,
7731 },
7732 BTF_STR_SEC("\0tag1\0tag2"),
7733 },
7734 },
7735 {
7736 .descr = "dedup: btf_type_tag #3",
7737 .input = {
7738 .raw_types = {
7739 /* ptr -> tag2 -> tag1 -> int */
7740 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7741 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7742 BTF_TYPE_TAG_ENC(NAME_NTH(2), 2), /* [3] */
7743 BTF_PTR_ENC(3), /* [4] */
7744 /* ptr -> tag1 -> tag2 -> int */
7745 BTF_TYPE_TAG_ENC(NAME_NTH(2), 1), /* [5] */
7746 BTF_TYPE_TAG_ENC(NAME_NTH(1), 5), /* [6] */
7747 BTF_PTR_ENC(6), /* [7] */
7748 BTF_END_RAW,
7749 },
7750 BTF_STR_SEC("\0tag1\0tag2"),
7751 },
7752 .expect = {
7753 .raw_types = {
7754 /* ptr -> tag2 -> tag1 -> int */
7755 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7756 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7757 BTF_TYPE_TAG_ENC(NAME_NTH(2), 2), /* [3] */
7758 BTF_PTR_ENC(3), /* [4] */
7759 /* ptr -> tag1 -> tag2 -> int */
7760 BTF_TYPE_TAG_ENC(NAME_NTH(2), 1), /* [5] */
7761 BTF_TYPE_TAG_ENC(NAME_NTH(1), 5), /* [6] */
7762 BTF_PTR_ENC(6), /* [7] */
7763 BTF_END_RAW,
7764 },
7765 BTF_STR_SEC("\0tag1\0tag2"),
7766 },
7767 },
7768 {
7769 .descr = "dedup: btf_type_tag #4",
7770 .input = {
7771 .raw_types = {
7772 /* ptr -> tag1 -> int */
7773 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7774 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7775 BTF_PTR_ENC(2), /* [3] */
7776 /* ptr -> tag1 -> long */
7777 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8), /* [4] */
7778 BTF_TYPE_TAG_ENC(NAME_NTH(1), 4), /* [5] */
7779 BTF_PTR_ENC(5), /* [6] */
7780 BTF_END_RAW,
7781 },
7782 BTF_STR_SEC("\0tag1"),
7783 },
7784 .expect = {
7785 .raw_types = {
7786 /* ptr -> tag1 -> int */
7787 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7788 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7789 BTF_PTR_ENC(2), /* [3] */
7790 /* ptr -> tag1 -> long */
7791 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8), /* [4] */
7792 BTF_TYPE_TAG_ENC(NAME_NTH(1), 4), /* [5] */
7793 BTF_PTR_ENC(5), /* [6] */
7794 BTF_END_RAW,
7795 },
7796 BTF_STR_SEC("\0tag1"),
7797 },
7798 },
7799 {
7800 .descr = "dedup: btf_type_tag #5, struct",
7801 .input = {
7802 .raw_types = {
7803 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7804 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7805 BTF_TYPE_ENC(NAME_NTH(2), BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 4), /* [3] */
7806 BTF_MEMBER_ENC(NAME_NTH(3), 2, BTF_MEMBER_OFFSET(0, 0)),
7807 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [4] */
7808 BTF_TYPE_ENC(NAME_NTH(2), BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 4), /* [5] */
7809 BTF_MEMBER_ENC(NAME_NTH(3), 4, BTF_MEMBER_OFFSET(0, 0)),
7810 BTF_END_RAW,
7811 },
7812 BTF_STR_SEC("\0tag1\0t\0m"),
7813 },
7814 .expect = {
7815 .raw_types = {
7816 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
7817 BTF_TYPE_TAG_ENC(NAME_NTH(1), 1), /* [2] */
7818 BTF_TYPE_ENC(NAME_NTH(2), BTF_INFO_ENC(BTF_KIND_STRUCT, 1, 1), 4), /* [3] */
7819 BTF_MEMBER_ENC(NAME_NTH(3), 2, BTF_MEMBER_OFFSET(0, 0)),
7820 BTF_END_RAW,
7821 },
7822 BTF_STR_SEC("\0tag1\0t\0m"),
7823 },
7824 },
7825 {
7826 .descr = "dedup: enum64, standalone",
7827 .input = {
7828 .raw_types = {
7829 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7830 BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7831 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7832 BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7833 BTF_END_RAW,
7834 },
7835 BTF_STR_SEC("\0e1\0e1_val"),
7836 },
7837 .expect = {
7838 .raw_types = {
7839 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7840 BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7841 BTF_END_RAW,
7842 },
7843 BTF_STR_SEC("\0e1\0e1_val"),
7844 },
7845 },
7846 {
7847 .descr = "dedup: enum64, fwd resolution",
7848 .input = {
7849 .raw_types = {
7850 /* [1] fwd enum64 'e1' before full enum */
7851 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
7852 /* [2] full enum64 'e1' after fwd */
7853 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7854 BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7855 /* [3] full enum64 'e2' before fwd */
7856 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7857 BTF_ENUM64_ENC(NAME_NTH(4), 0, 456),
7858 /* [4] fwd enum64 'e2' after full enum */
7859 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
7860 /* [5] incompatible full enum64 with different value */
7861 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7862 BTF_ENUM64_ENC(NAME_NTH(2), 0, 321),
7863 BTF_END_RAW,
7864 },
7865 BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7866 },
7867 .expect = {
7868 .raw_types = {
7869 /* [1] full enum64 'e1' */
7870 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7871 BTF_ENUM64_ENC(NAME_NTH(2), 1, 123),
7872 /* [2] full enum64 'e2' */
7873 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7874 BTF_ENUM64_ENC(NAME_NTH(4), 0, 456),
7875 /* [3] incompatible full enum64 with different value */
7876 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7877 BTF_ENUM64_ENC(NAME_NTH(2), 0, 321),
7878 BTF_END_RAW,
7879 },
7880 BTF_STR_SEC("\0e1\0e1_val\0e2\0e2_val"),
7881 },
7882 },
7883 {
7884 .descr = "dedup: enum and enum64, no dedup",
7885 .input = {
7886 .raw_types = {
7887 /* [1] enum 'e1' */
7888 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7889 BTF_ENUM_ENC(NAME_NTH(2), 1),
7890 /* [2] enum64 'e1' */
7891 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 4),
7892 BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7893 BTF_END_RAW,
7894 },
7895 BTF_STR_SEC("\0e1\0e1_val"),
7896 },
7897 .expect = {
7898 .raw_types = {
7899 /* [1] enum 'e1' */
7900 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7901 BTF_ENUM_ENC(NAME_NTH(2), 1),
7902 /* [2] enum64 'e1' */
7903 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 4),
7904 BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7905 BTF_END_RAW,
7906 },
7907 BTF_STR_SEC("\0e1\0e1_val"),
7908 },
7909 },
7910 {
7911 .descr = "dedup: enum of different size: no dedup",
7912 .input = {
7913 .raw_types = {
7914 /* [1] enum 'e1' */
7915 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7916 BTF_ENUM_ENC(NAME_NTH(2), 1),
7917 /* [2] enum 'e1' */
7918 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 2),
7919 BTF_ENUM_ENC(NAME_NTH(2), 1),
7920 BTF_END_RAW,
7921 },
7922 BTF_STR_SEC("\0e1\0e1_val"),
7923 },
7924 .expect = {
7925 .raw_types = {
7926 /* [1] enum 'e1' */
7927 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7928 BTF_ENUM_ENC(NAME_NTH(2), 1),
7929 /* [2] enum 'e1' */
7930 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 2),
7931 BTF_ENUM_ENC(NAME_NTH(2), 1),
7932 BTF_END_RAW,
7933 },
7934 BTF_STR_SEC("\0e1\0e1_val"),
7935 },
7936 },
7937 {
7938 .descr = "dedup: enum fwd to enum64",
7939 .input = {
7940 .raw_types = {
7941 /* [1] enum64 'e1' */
7942 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7943 BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7944 /* [2] enum 'e1' fwd */
7945 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 0), 4),
7946 /* [3] typedef enum 'e1' td */
7947 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 2),
7948 BTF_END_RAW,
7949 },
7950 BTF_STR_SEC("\0e1\0e1_val\0td"),
7951 },
7952 .expect = {
7953 .raw_types = {
7954 /* [1] enum64 'e1' */
7955 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 1), 8),
7956 BTF_ENUM64_ENC(NAME_NTH(2), 1, 0),
7957 /* [2] typedef enum 'e1' td */
7958 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 1),
7959 BTF_END_RAW,
7960 },
7961 BTF_STR_SEC("\0e1\0e1_val\0td"),
7962 },
7963 },
7964 {
7965 .descr = "dedup: enum64 fwd to enum",
7966 .input = {
7967 .raw_types = {
7968 /* [1] enum 'e1' */
7969 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7970 BTF_ENUM_ENC(NAME_NTH(2), 1),
7971 /* [2] enum64 'e1' fwd */
7972 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
7973 /* [3] typedef enum 'e1' td */
7974 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 2),
7975 BTF_END_RAW,
7976 },
7977 BTF_STR_SEC("\0e1\0e1_val\0td"),
7978 },
7979 .expect = {
7980 .raw_types = {
7981 /* [1] enum 'e1' */
7982 BTF_TYPE_ENC(NAME_NTH(1), BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1), 4),
7983 BTF_ENUM_ENC(NAME_NTH(2), 1),
7984 /* [2] typedef enum 'e1' td */
7985 BTF_TYPE_ENC(NAME_NTH(3), BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 1),
7986 BTF_END_RAW,
7987 },
7988 BTF_STR_SEC("\0e1\0e1_val\0td"),
7989 },
7990 },
7991 {
7992 .descr = "dedup: standalone fwd declaration struct",
7993 /*
7994 * Verify that CU1:foo and CU2:foo would be unified and that
7995 * typedef/ptr would be updated to point to CU1:foo.
7996 *
7997 * // CU 1:
7998 * struct foo { int x; };
7999 *
8000 * // CU 2:
8001 * struct foo;
8002 * typedef struct foo *foo_ptr;
8003 */
8004 .input = {
8005 .raw_types = {
8006 /* CU 1 */
8007 BTF_STRUCT_ENC(NAME_NTH(1), 1, 4), /* [1] */
8008 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8009 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8010 /* CU 2 */
8011 BTF_FWD_ENC(NAME_NTH(1), 0), /* [3] */
8012 BTF_PTR_ENC(3), /* [4] */
8013 BTF_TYPEDEF_ENC(NAME_NTH(3), 4), /* [5] */
8014 BTF_END_RAW,
8015 },
8016 BTF_STR_SEC("\0foo\0x\0foo_ptr"),
8017 },
8018 .expect = {
8019 .raw_types = {
8020 BTF_STRUCT_ENC(NAME_NTH(1), 1, 4), /* [1] */
8021 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8022 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8023 BTF_PTR_ENC(1), /* [3] */
8024 BTF_TYPEDEF_ENC(NAME_NTH(3), 3), /* [4] */
8025 BTF_END_RAW,
8026 },
8027 BTF_STR_SEC("\0foo\0x\0foo_ptr"),
8028 },
8029 },
8030 {
8031 .descr = "dedup: standalone fwd declaration union",
8032 /*
8033 * Verify that CU1:foo and CU2:foo would be unified and that
8034 * typedef/ptr would be updated to point to CU1:foo.
8035 * Same as "dedup: standalone fwd declaration struct" but for unions.
8036 *
8037 * // CU 1:
8038 * union foo { int x; };
8039 *
8040 * // CU 2:
8041 * union foo;
8042 * typedef union foo *foo_ptr;
8043 */
8044 .input = {
8045 .raw_types = {
8046 /* CU 1 */
8047 BTF_UNION_ENC(NAME_NTH(1), 1, 4), /* [1] */
8048 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8049 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8050 /* CU 2 */
8051 BTF_FWD_ENC(NAME_TBD, 1), /* [3] */
8052 BTF_PTR_ENC(3), /* [4] */
8053 BTF_TYPEDEF_ENC(NAME_NTH(3), 4), /* [5] */
8054 BTF_END_RAW,
8055 },
8056 BTF_STR_SEC("\0foo\0x\0foo_ptr"),
8057 },
8058 .expect = {
8059 .raw_types = {
8060 BTF_UNION_ENC(NAME_NTH(1), 1, 4), /* [1] */
8061 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8062 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8063 BTF_PTR_ENC(1), /* [3] */
8064 BTF_TYPEDEF_ENC(NAME_NTH(3), 3), /* [4] */
8065 BTF_END_RAW,
8066 },
8067 BTF_STR_SEC("\0foo\0x\0foo_ptr"),
8068 },
8069 },
8070 {
8071 .descr = "dedup: standalone fwd declaration wrong kind",
8072 /*
8073 * Negative test for btf_dedup_resolve_fwds:
8074 * - CU1:foo is a struct, C2:foo is a union, thus CU2:foo is not deduped;
8075 * - typedef/ptr should remain unchanged as well.
8076 *
8077 * // CU 1:
8078 * struct foo { int x; };
8079 *
8080 * // CU 2:
8081 * union foo;
8082 * typedef union foo *foo_ptr;
8083 */
8084 .input = {
8085 .raw_types = {
8086 /* CU 1 */
8087 BTF_STRUCT_ENC(NAME_NTH(1), 1, 4), /* [1] */
8088 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8089 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8090 /* CU 2 */
8091 BTF_FWD_ENC(NAME_NTH(3), 1), /* [3] */
8092 BTF_PTR_ENC(3), /* [4] */
8093 BTF_TYPEDEF_ENC(NAME_NTH(3), 4), /* [5] */
8094 BTF_END_RAW,
8095 },
8096 BTF_STR_SEC("\0foo\0x\0foo_ptr"),
8097 },
8098 .expect = {
8099 .raw_types = {
8100 /* CU 1 */
8101 BTF_STRUCT_ENC(NAME_NTH(1), 1, 4), /* [1] */
8102 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8103 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8104 /* CU 2 */
8105 BTF_FWD_ENC(NAME_NTH(3), 1), /* [3] */
8106 BTF_PTR_ENC(3), /* [4] */
8107 BTF_TYPEDEF_ENC(NAME_NTH(3), 4), /* [5] */
8108 BTF_END_RAW,
8109 },
8110 BTF_STR_SEC("\0foo\0x\0foo_ptr"),
8111 },
8112 },
8113 {
8114 .descr = "dedup: standalone fwd declaration name conflict",
8115 /*
8116 * Negative test for btf_dedup_resolve_fwds:
8117 * - two candidates for CU2:foo dedup, thus it is unchanged;
8118 * - typedef/ptr should remain unchanged as well.
8119 *
8120 * // CU 1:
8121 * struct foo { int x; };
8122 *
8123 * // CU 2:
8124 * struct foo;
8125 * typedef struct foo *foo_ptr;
8126 *
8127 * // CU 3:
8128 * struct foo { int x; int y; };
8129 */
8130 .input = {
8131 .raw_types = {
8132 /* CU 1 */
8133 BTF_STRUCT_ENC(NAME_NTH(1), 1, 4), /* [1] */
8134 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8135 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8136 /* CU 2 */
8137 BTF_FWD_ENC(NAME_NTH(1), 0), /* [3] */
8138 BTF_PTR_ENC(3), /* [4] */
8139 BTF_TYPEDEF_ENC(NAME_NTH(4), 4), /* [5] */
8140 /* CU 3 */
8141 BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [6] */
8142 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8143 BTF_MEMBER_ENC(NAME_NTH(3), 2, 0),
8144 BTF_END_RAW,
8145 },
8146 BTF_STR_SEC("\0foo\0x\0y\0foo_ptr"),
8147 },
8148 .expect = {
8149 .raw_types = {
8150 /* CU 1 */
8151 BTF_STRUCT_ENC(NAME_NTH(1), 1, 4), /* [1] */
8152 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8153 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [2] */
8154 /* CU 2 */
8155 BTF_FWD_ENC(NAME_NTH(1), 0), /* [3] */
8156 BTF_PTR_ENC(3), /* [4] */
8157 BTF_TYPEDEF_ENC(NAME_NTH(4), 4), /* [5] */
8158 /* CU 3 */
8159 BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [6] */
8160 BTF_MEMBER_ENC(NAME_NTH(2), 2, 0),
8161 BTF_MEMBER_ENC(NAME_NTH(3), 2, 0),
8162 BTF_END_RAW,
8163 },
8164 BTF_STR_SEC("\0foo\0x\0y\0foo_ptr"),
8165 },
8166 },
8167 };
8168
btf_type_size(const struct btf_type * t)8169 static int btf_type_size(const struct btf_type *t)
8170 {
8171 int base_size = sizeof(struct btf_type);
8172 __u32 vlen = BTF_INFO_VLEN(t->info);
8173 __u16 kind = BTF_INFO_KIND(t->info);
8174
8175 switch (kind) {
8176 case BTF_KIND_FWD:
8177 case BTF_KIND_CONST:
8178 case BTF_KIND_VOLATILE:
8179 case BTF_KIND_RESTRICT:
8180 case BTF_KIND_PTR:
8181 case BTF_KIND_TYPEDEF:
8182 case BTF_KIND_FUNC:
8183 case BTF_KIND_FLOAT:
8184 case BTF_KIND_TYPE_TAG:
8185 return base_size;
8186 case BTF_KIND_INT:
8187 return base_size + sizeof(__u32);
8188 case BTF_KIND_ENUM:
8189 return base_size + vlen * sizeof(struct btf_enum);
8190 case BTF_KIND_ENUM64:
8191 return base_size + vlen * sizeof(struct btf_enum64);
8192 case BTF_KIND_ARRAY:
8193 return base_size + sizeof(struct btf_array);
8194 case BTF_KIND_STRUCT:
8195 case BTF_KIND_UNION:
8196 return base_size + vlen * sizeof(struct btf_member);
8197 case BTF_KIND_FUNC_PROTO:
8198 return base_size + vlen * sizeof(struct btf_param);
8199 case BTF_KIND_VAR:
8200 return base_size + sizeof(struct btf_var);
8201 case BTF_KIND_DATASEC:
8202 return base_size + vlen * sizeof(struct btf_var_secinfo);
8203 case BTF_KIND_DECL_TAG:
8204 return base_size + sizeof(struct btf_decl_tag);
8205 default:
8206 fprintf(stderr, "Unsupported BTF_KIND:%u\n", kind);
8207 return -EINVAL;
8208 }
8209 }
8210
dump_btf_strings(const char * strs,__u32 len)8211 static void dump_btf_strings(const char *strs, __u32 len)
8212 {
8213 const char *cur = strs;
8214 int i = 0;
8215
8216 while (cur < strs + len) {
8217 fprintf(stderr, "string #%d: '%s'\n", i, cur);
8218 cur += strlen(cur) + 1;
8219 i++;
8220 }
8221 }
8222
do_test_dedup(unsigned int test_num)8223 static void do_test_dedup(unsigned int test_num)
8224 {
8225 struct btf_dedup_test *test = &dedup_tests[test_num - 1];
8226 __u32 test_nr_types, expect_nr_types, test_btf_size, expect_btf_size;
8227 const struct btf_header *test_hdr, *expect_hdr;
8228 struct btf *test_btf = NULL, *expect_btf = NULL;
8229 const void *test_btf_data, *expect_btf_data;
8230 const char *ret_test_next_str, *ret_expect_next_str;
8231 const char *test_strs, *expect_strs;
8232 const char *test_str_cur;
8233 const char *expect_str_cur, *expect_str_end;
8234 unsigned int raw_btf_size;
8235 void *raw_btf;
8236 int err = 0, i;
8237
8238 if (!test__start_subtest(test->descr))
8239 return;
8240
8241 raw_btf = btf_raw_create(&hdr_tmpl, test->input.raw_types,
8242 test->input.str_sec, test->input.str_sec_size,
8243 &raw_btf_size, &ret_test_next_str);
8244 if (!raw_btf)
8245 return;
8246
8247 test_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
8248 err = libbpf_get_error(test_btf);
8249 free(raw_btf);
8250 if (CHECK(err, "invalid test_btf errno:%d", err)) {
8251 err = -1;
8252 goto done;
8253 }
8254
8255 raw_btf = btf_raw_create(&hdr_tmpl, test->expect.raw_types,
8256 test->expect.str_sec,
8257 test->expect.str_sec_size,
8258 &raw_btf_size, &ret_expect_next_str);
8259 if (!raw_btf)
8260 return;
8261 expect_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
8262 err = libbpf_get_error(expect_btf);
8263 free(raw_btf);
8264 if (CHECK(err, "invalid expect_btf errno:%d", err)) {
8265 err = -1;
8266 goto done;
8267 }
8268
8269 test->opts.sz = sizeof(test->opts);
8270 err = btf__dedup(test_btf, &test->opts);
8271 if (CHECK(err, "btf_dedup failed errno:%d", err)) {
8272 err = -1;
8273 goto done;
8274 }
8275
8276 test_btf_data = btf__raw_data(test_btf, &test_btf_size);
8277 expect_btf_data = btf__raw_data(expect_btf, &expect_btf_size);
8278 if (CHECK(test_btf_size != expect_btf_size,
8279 "test_btf_size:%u != expect_btf_size:%u",
8280 test_btf_size, expect_btf_size)) {
8281 err = -1;
8282 goto done;
8283 }
8284
8285 test_hdr = test_btf_data;
8286 test_strs = test_btf_data + sizeof(*test_hdr) + test_hdr->str_off;
8287 expect_hdr = expect_btf_data;
8288 expect_strs = expect_btf_data + sizeof(*test_hdr) + expect_hdr->str_off;
8289 if (CHECK(test_hdr->str_len != expect_hdr->str_len,
8290 "test_hdr->str_len:%u != expect_hdr->str_len:%u",
8291 test_hdr->str_len, expect_hdr->str_len)) {
8292 fprintf(stderr, "\ntest strings:\n");
8293 dump_btf_strings(test_strs, test_hdr->str_len);
8294 fprintf(stderr, "\nexpected strings:\n");
8295 dump_btf_strings(expect_strs, expect_hdr->str_len);
8296 err = -1;
8297 goto done;
8298 }
8299
8300 expect_str_cur = expect_strs;
8301 expect_str_end = expect_strs + expect_hdr->str_len;
8302 while (expect_str_cur < expect_str_end) {
8303 size_t test_len, expect_len;
8304 int off;
8305
8306 off = btf__find_str(test_btf, expect_str_cur);
8307 if (CHECK(off < 0, "exp str '%s' not found: %d\n", expect_str_cur, off)) {
8308 err = -1;
8309 goto done;
8310 }
8311 test_str_cur = btf__str_by_offset(test_btf, off);
8312
8313 test_len = strlen(test_str_cur);
8314 expect_len = strlen(expect_str_cur);
8315 if (CHECK(test_len != expect_len,
8316 "test_len:%zu != expect_len:%zu "
8317 "(test_str:%s, expect_str:%s)",
8318 test_len, expect_len, test_str_cur, expect_str_cur)) {
8319 err = -1;
8320 goto done;
8321 }
8322 if (CHECK(strcmp(test_str_cur, expect_str_cur),
8323 "test_str:%s != expect_str:%s",
8324 test_str_cur, expect_str_cur)) {
8325 err = -1;
8326 goto done;
8327 }
8328 expect_str_cur += expect_len + 1;
8329 }
8330
8331 test_nr_types = btf__type_cnt(test_btf);
8332 expect_nr_types = btf__type_cnt(expect_btf);
8333 if (CHECK(test_nr_types != expect_nr_types,
8334 "test_nr_types:%u != expect_nr_types:%u",
8335 test_nr_types, expect_nr_types)) {
8336 err = -1;
8337 goto done;
8338 }
8339
8340 for (i = 1; i < test_nr_types; i++) {
8341 const struct btf_type *test_type, *expect_type;
8342 int test_size, expect_size;
8343
8344 test_type = btf__type_by_id(test_btf, i);
8345 expect_type = btf__type_by_id(expect_btf, i);
8346 test_size = btf_type_size(test_type);
8347 expect_size = btf_type_size(expect_type);
8348
8349 if (CHECK(test_size != expect_size,
8350 "type #%d: test_size:%d != expect_size:%u",
8351 i, test_size, expect_size)) {
8352 err = -1;
8353 goto done;
8354 }
8355 if (CHECK(btf_kind(test_type) != btf_kind(expect_type),
8356 "type %d kind: exp %d != got %u\n",
8357 i, btf_kind(expect_type), btf_kind(test_type))) {
8358 err = -1;
8359 goto done;
8360 }
8361 if (CHECK(test_type->info != expect_type->info,
8362 "type %d info: exp %d != got %u\n",
8363 i, expect_type->info, test_type->info)) {
8364 err = -1;
8365 goto done;
8366 }
8367 if (CHECK(test_type->size != expect_type->size,
8368 "type %d size/type: exp %d != got %u\n",
8369 i, expect_type->size, test_type->size)) {
8370 err = -1;
8371 goto done;
8372 }
8373 }
8374
8375 done:
8376 btf__free(test_btf);
8377 btf__free(expect_btf);
8378 }
8379
test_btf(void)8380 void test_btf(void)
8381 {
8382 int i;
8383
8384 always_log = env.verbosity > VERBOSE_NONE;
8385
8386 for (i = 1; i <= ARRAY_SIZE(raw_tests); i++)
8387 do_test_raw(i);
8388 for (i = 1; i <= ARRAY_SIZE(get_info_tests); i++)
8389 do_test_get_info(i);
8390 for (i = 1; i <= ARRAY_SIZE(file_tests); i++)
8391 do_test_file(i);
8392 for (i = 1; i <= ARRAY_SIZE(info_raw_tests); i++)
8393 do_test_info_raw(i);
8394 for (i = 1; i <= ARRAY_SIZE(dedup_tests); i++)
8395 do_test_dedup(i);
8396 test_pprint();
8397 }
8398