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 4340 static const char *get_next_str(const char *start, const char *end) 4341 { 4342 return start < end - 1 ? start + 1 : NULL; 4343 } 4344 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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