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