tools/testing/selftests/bpf/test_btf.c

   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 <bpf/bpf.h>
   8 #include <sys/resource.h>
   9 #include <libelf.h>
  10 #include <gelf.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <stdarg.h>
  15 #include <unistd.h>
  16 #include <fcntl.h>
  17 #include <errno.h>
  18 #include <bpf/libbpf.h>
  19 #include <bpf/btf.h>
  20
  21 #include "bpf_rlimit.h"
  22 #include "bpf_util.h"
  23
  24 static uint32_t pass_cnt;
  25 static uint32_t error_cnt;
  26 static uint32_t skip_cnt;
  27
  28 #define CHECK(condition, format...) ({                                  \
  29         int __ret = !!(condition);                                      \
  30         if (__ret) {                                                    \
  31                 fprintf(stderr, "%s:%d:FAIL ", __func__, __LINE__);     \
  32                 fprintf(stderr, format);                                \
  33         }                                                               \
  34         __ret;                                                          \
  35 })
  36
  37 static int count_result(int err)
  38 {
  39         if (err)
  40                 error_cnt++;
  41         else
  42                 pass_cnt++;
  43
  44         fprintf(stderr, "\n");
  45         return err;
  46 }
  47
  48 #define min(a, b) ((a) < (b) ? (a) : (b))
  49 #define __printf(a, b)  __attribute__((format(printf, a, b)))
  50
  51 __printf(1, 2)
  52 static int __base_pr(const char *format, ...)
  53 {
  54         va_list args;
  55         int err;
  56
  57         va_start(args, format);
  58         err = vfprintf(stderr, format, args);
  59         va_end(args);
  60         return err;
  61 }
  62
  63 #define BTF_INFO_ENC(kind, root, vlen)                  \
  64         ((!!(root) << 31) | ((kind) << 24) | ((vlen) & BTF_MAX_VLEN))
  65
  66 #define BTF_TYPE_ENC(name, info, size_or_type)  \
  67         (name), (info), (size_or_type)
  68
  69 #define BTF_INT_ENC(encoding, bits_offset, nr_bits)     \
  70         ((encoding) << 24 | (bits_offset) << 16 | (nr_bits))
  71 #define BTF_TYPE_INT_ENC(name, encoding, bits_offset, bits, sz) \
  72         BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), sz),       \
  73         BTF_INT_ENC(encoding, bits_offset, bits)
  74
  75 #define BTF_ARRAY_ENC(type, index_type, nr_elems)       \
  76         (type), (index_type), (nr_elems)
  77 #define BTF_TYPE_ARRAY_ENC(type, index_type, nr_elems) \
  78         BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 0), \
  79         BTF_ARRAY_ENC(type, index_type, nr_elems)
  80
  81 #define BTF_MEMBER_ENC(name, type, bits_offset) \
  82         (name), (type), (bits_offset)
  83 #define BTF_ENUM_ENC(name, val) (name), (val)
  84
  85 #define BTF_TYPEDEF_ENC(name, type) \
  86         BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), type)
  87
  88 #define BTF_PTR_ENC(name, type) \
  89         BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), type)
  90
  91 #define BTF_END_RAW 0xdeadbeef
  92 #define NAME_TBD 0xdeadb33f
  93
  94 #define MAX_NR_RAW_TYPES 1024
  95 #define BTF_LOG_BUF_SIZE 65535
  96
  97 static struct args {
  98         unsigned int raw_test_num;
  99         unsigned int file_test_num;
 100         unsigned int get_info_test_num;
 101         bool raw_test;
 102         bool file_test;
 103         bool get_info_test;
 104         bool pprint_test;
 105         bool always_log;
 106 } args;
 107
 108 static char btf_log_buf[BTF_LOG_BUF_SIZE];
 109
 110 static struct btf_header hdr_tmpl = {
 111         .magic = BTF_MAGIC,
 112         .version = BTF_VERSION,
 113         .hdr_len = sizeof(struct btf_header),
 114 };
 115
 116 struct btf_raw_test {
 117         const char *descr;
 118         const char *str_sec;
 119         const char *map_name;
 120         const char *err_str;
 121         __u32 raw_types[MAX_NR_RAW_TYPES];
 122         __u32 str_sec_size;
 123         enum bpf_map_type map_type;
 124         __u32 key_size;
 125         __u32 value_size;
 126         __u32 key_type_id;
 127         __u32 value_type_id;
 128         __u32 max_entries;
 129         bool btf_load_err;
 130         bool map_create_err;
 131         bool ordered_map;
 132         bool lossless_map;
 133         int hdr_len_delta;
 134         int type_off_delta;
 135         int str_off_delta;
 136         int str_len_delta;
 137 };
 138
 139 static struct btf_raw_test raw_tests[] = {
 140 /* enum E {
 141  *     E0,
 142  *     E1,
 143  * };
 144  *
 145  * struct A {
 146  *      unsigned long long m;
 147  *      int n;
 148  *      char o;
 149  *      [3 bytes hole]
 150  *      int p[8];
 151  *      int q[4][8];
 152  *      enum E r;
 153  * };
 154  */
 155 {
 156         .descr = "struct test #1",
 157         .raw_types = {
 158                 /* int */
 159                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
 160                 /* unsigned long long */
 161                 BTF_TYPE_INT_ENC(0, 0, 0, 64, 8),               /* [2] */
 162                 /* char */
 163                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 8, 1),   /* [3] */
 164                 /* int[8] */
 165                 BTF_TYPE_ARRAY_ENC(1, 1, 8),                    /* [4] */
 166                 /* struct A { */                                /* [5] */
 167                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 6), 180),
 168                 BTF_MEMBER_ENC(NAME_TBD, 2, 0), /* unsigned long long m;*/
 169                 BTF_MEMBER_ENC(NAME_TBD, 1, 64),/* int n;               */
 170                 BTF_MEMBER_ENC(NAME_TBD, 3, 96),/* char o;              */
 171                 BTF_MEMBER_ENC(NAME_TBD, 4, 128),/* int p[8]            */
 172                 BTF_MEMBER_ENC(NAME_TBD, 6, 384),/* int q[4][8]         */
 173                 BTF_MEMBER_ENC(NAME_TBD, 7, 1408), /* enum E r          */
 174                 /* } */
 175                 /* int[4][8] */
 176                 BTF_TYPE_ARRAY_ENC(4, 1, 4),                    /* [6] */
 177                 /* enum E */                                    /* [7] */
 178                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
 179                 BTF_ENUM_ENC(NAME_TBD, 0),
 180                 BTF_ENUM_ENC(NAME_TBD, 1),
 181                 BTF_END_RAW,
 182         },
 183         .str_sec = "\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1",
 184         .str_sec_size = sizeof("\0A\0m\0n\0o\0p\0q\0r\0E\0E0\0E1"),
 185         .map_type = BPF_MAP_TYPE_ARRAY,
 186         .map_name = "struct_test1_map",
 187         .key_size = sizeof(int),
 188         .value_size = 180,
 189         .key_type_id = 1,
 190         .value_type_id = 5,
 191         .max_entries = 4,
 192 },
 193
 194 /* typedef struct b Struct_B;
 195  *
 196  * struct A {
 197  *     int m;
 198  *     struct b n[4];
 199  *     const Struct_B o[4];
 200  * };
 201  *
 202  * struct B {
 203  *     int m;
 204  *     int n;
 205  * };
 206  */
 207 {
 208         .descr = "struct test #2",
 209         .raw_types = {
 210                 /* int */                                       /* [1] */
 211                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 212                 /* struct b [4] */                              /* [2] */
 213                 BTF_TYPE_ARRAY_ENC(4, 1, 4),
 214
 215                 /* struct A { */                                /* [3] */
 216                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 3), 68),
 217                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m;               */
 218                 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct B n[4]        */
 219                 BTF_MEMBER_ENC(NAME_TBD, 8, 288),/* const Struct_B o[4];*/
 220                 /* } */
 221
 222                 /* struct B { */                                /* [4] */
 223                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
 224                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
 225                 BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
 226                 /* } */
 227
 228                 /* const int */                                 /* [5] */
 229                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
 230                 /* typedef struct b Struct_B */ /* [6] */
 231                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_TYPEDEF, 0, 0), 4),
 232                 /* const Struct_B */                            /* [7] */
 233                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 6),
 234                 /* const Struct_B [4] */                        /* [8] */
 235                 BTF_TYPE_ARRAY_ENC(7, 1, 4),
 236                 BTF_END_RAW,
 237         },
 238         .str_sec = "\0A\0m\0n\0o\0B\0m\0n\0Struct_B",
 239         .str_sec_size = sizeof("\0A\0m\0n\0o\0B\0m\0n\0Struct_B"),
 240         .map_type = BPF_MAP_TYPE_ARRAY,
 241         .map_name = "struct_test2_map",
 242         .key_size = sizeof(int),
 243         .value_size = 68,
 244         .key_type_id = 1,
 245         .value_type_id = 3,
 246         .max_entries = 4,
 247 },
 248
 249 {
 250         .descr = "struct test #3 Invalid member offset",
 251         .raw_types = {
 252                 /* int */                                       /* [1] */
 253                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 254                 /* int64 */                                     /* [2] */
 255                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 64, 8),
 256
 257                 /* struct A { */                                /* [3] */
 258                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 16),
 259                 BTF_MEMBER_ENC(NAME_TBD, 1, 64),        /* int m;               */
 260                 BTF_MEMBER_ENC(NAME_TBD, 2, 0),         /* int64 n; */
 261                 /* } */
 262                 BTF_END_RAW,
 263         },
 264         .str_sec = "\0A\0m\0n\0",
 265         .str_sec_size = sizeof("\0A\0m\0n\0"),
 266         .map_type = BPF_MAP_TYPE_ARRAY,
 267         .map_name = "struct_test3_map",
 268         .key_size = sizeof(int),
 269         .value_size = 16,
 270         .key_type_id = 1,
 271         .value_type_id = 3,
 272         .max_entries = 4,
 273         .btf_load_err = true,
 274         .err_str = "Invalid member bits_offset",
 275 },
 276
 277 /* Test member exceeds the size of struct.
 278  *
 279  * struct A {
 280  *     int m;
 281  *     int n;
 282  * };
 283  */
 284 {
 285         .descr = "size check test #1",
 286         .raw_types = {
 287                 /* int */                                       /* [1] */
 288                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 289                 /* struct A { */                                /* [2] */
 290                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 -  1),
 291                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
 292                 BTF_MEMBER_ENC(NAME_TBD, 1, 32),/* int n; */
 293                 /* } */
 294                 BTF_END_RAW,
 295         },
 296         .str_sec = "\0A\0m\0n",
 297         .str_sec_size = sizeof("\0A\0m\0n"),
 298         .map_type = BPF_MAP_TYPE_ARRAY,
 299         .map_name = "size_check1_map",
 300         .key_size = sizeof(int),
 301         .value_size = 1,
 302         .key_type_id = 1,
 303         .value_type_id = 2,
 304         .max_entries = 4,
 305         .btf_load_err = true,
 306         .err_str = "Member exceeds struct_size",
 307 },
 308
 309 /* Test member exeeds the size of struct
 310  *
 311  * struct A {
 312  *     int m;
 313  *     int n[2];
 314  * };
 315  */
 316 {
 317         .descr = "size check test #2",
 318         .raw_types = {
 319                 /* int */                                       /* [1] */
 320                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
 321                 /* int[2] */                                    /* [2] */
 322                 BTF_TYPE_ARRAY_ENC(1, 1, 2),
 323                 /* struct A { */                                /* [3] */
 324                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 3 - 1),
 325                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
 326                 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* int n[2]; */
 327                 /* } */
 328                 BTF_END_RAW,
 329         },
 330         .str_sec = "\0A\0m\0n",
 331         .str_sec_size = sizeof("\0A\0m\0n"),
 332         .map_type = BPF_MAP_TYPE_ARRAY,
 333         .map_name = "size_check2_map",
 334         .key_size = sizeof(int),
 335         .value_size = 1,
 336         .key_type_id = 1,
 337         .value_type_id = 3,
 338         .max_entries = 4,
 339         .btf_load_err = true,
 340         .err_str = "Member exceeds struct_size",
 341 },
 342
 343 /* Test member exeeds the size of struct
 344  *
 345  * struct A {
 346  *     int m;
 347  *     void *n;
 348  * };
 349  */
 350 {
 351         .descr = "size check test #3",
 352         .raw_types = {
 353                 /* int */                                       /* [1] */
 354                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
 355                 /* void* */                                     /* [2] */
 356                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
 357                 /* struct A { */                                /* [3] */
 358                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) + sizeof(void *) - 1),
 359                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
 360                 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* void *n; */
 361                 /* } */
 362                 BTF_END_RAW,
 363         },
 364         .str_sec = "\0A\0m\0n",
 365         .str_sec_size = sizeof("\0A\0m\0n"),
 366         .map_type = BPF_MAP_TYPE_ARRAY,
 367         .map_name = "size_check3_map",
 368         .key_size = sizeof(int),
 369         .value_size = 1,
 370         .key_type_id = 1,
 371         .value_type_id = 3,
 372         .max_entries = 4,
 373         .btf_load_err = true,
 374         .err_str = "Member exceeds struct_size",
 375 },
 376
 377 /* Test member exceeds the size of struct
 378  *
 379  * enum E {
 380  *     E0,
 381  *     E1,
 382  * };
 383  *
 384  * struct A {
 385  *     int m;
 386  *     enum E n;
 387  * };
 388  */
 389 {
 390         .descr = "size check test #4",
 391         .raw_types = {
 392                 /* int */                       /* [1] */
 393                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, sizeof(int)),
 394                 /* enum E { */                  /* [2] */
 395                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), sizeof(int)),
 396                 BTF_ENUM_ENC(NAME_TBD, 0),
 397                 BTF_ENUM_ENC(NAME_TBD, 1),
 398                 /* } */
 399                 /* struct A { */                /* [3] */
 400                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), sizeof(int) * 2 - 1),
 401                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int m; */
 402                 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* enum E n; */
 403                 /* } */
 404                 BTF_END_RAW,
 405         },
 406         .str_sec = "\0E\0E0\0E1\0A\0m\0n",
 407         .str_sec_size = sizeof("\0E\0E0\0E1\0A\0m\0n"),
 408         .map_type = BPF_MAP_TYPE_ARRAY,
 409         .map_name = "size_check4_map",
 410         .key_size = sizeof(int),
 411         .value_size = 1,
 412         .key_type_id = 1,
 413         .value_type_id = 3,
 414         .max_entries = 4,
 415         .btf_load_err = true,
 416         .err_str = "Member exceeds struct_size",
 417 },
 418
 419 /* typedef const void * const_void_ptr;
 420  * struct A {
 421  *      const_void_ptr m;
 422  * };
 423  */
 424 {
 425         .descr = "void test #1",
 426         .raw_types = {
 427                 /* int */               /* [1] */
 428                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 429                 /* const void */        /* [2] */
 430                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
 431                 /* const void* */       /* [3] */
 432                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
 433                 /* typedef const void * const_void_ptr */
 434                 BTF_TYPEDEF_ENC(NAME_TBD, 3),   /* [4] */
 435                 /* struct A { */        /* [5] */
 436                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
 437                 /* const_void_ptr m; */
 438                 BTF_MEMBER_ENC(NAME_TBD, 4, 0),
 439                 /* } */
 440                 BTF_END_RAW,
 441         },
 442         .str_sec = "\0const_void_ptr\0A\0m",
 443         .str_sec_size = sizeof("\0const_void_ptr\0A\0m"),
 444         .map_type = BPF_MAP_TYPE_ARRAY,
 445         .map_name = "void_test1_map",
 446         .key_size = sizeof(int),
 447         .value_size = sizeof(void *),
 448         .key_type_id = 1,
 449         .value_type_id = 4,
 450         .max_entries = 4,
 451 },
 452
 453 /* struct A {
 454  *     const void m;
 455  * };
 456  */
 457 {
 458         .descr = "void test #2",
 459         .raw_types = {
 460                 /* int */               /* [1] */
 461                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 462                 /* const void */        /* [2] */
 463                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
 464                 /* struct A { */        /* [3] */
 465                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 8),
 466                 /* const void m; */
 467                 BTF_MEMBER_ENC(NAME_TBD, 2, 0),
 468                 /* } */
 469                 BTF_END_RAW,
 470         },
 471         .str_sec = "\0A\0m",
 472         .str_sec_size = sizeof("\0A\0m"),
 473         .map_type = BPF_MAP_TYPE_ARRAY,
 474         .map_name = "void_test2_map",
 475         .key_size = sizeof(int),
 476         .value_size = sizeof(void *),
 477         .key_type_id = 1,
 478         .value_type_id = 3,
 479         .max_entries = 4,
 480         .btf_load_err = true,
 481         .err_str = "Invalid member",
 482 },
 483
 484 /* typedef const void * const_void_ptr;
 485  * const_void_ptr[4]
 486  */
 487 {
 488         .descr = "void test #3",
 489         .raw_types = {
 490                 /* int */               /* [1] */
 491                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 492                 /* const void */        /* [2] */
 493                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
 494                 /* const void* */       /* [3] */
 495                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),
 496                 /* typedef const void * const_void_ptr */
 497                 BTF_TYPEDEF_ENC(NAME_TBD, 3),   /* [4] */
 498                 /* const_void_ptr[4] */
 499                 BTF_TYPE_ARRAY_ENC(4, 1, 4),    /* [5] */
 500                 BTF_END_RAW,
 501         },
 502         .str_sec = "\0const_void_ptr",
 503         .str_sec_size = sizeof("\0const_void_ptr"),
 504         .map_type = BPF_MAP_TYPE_ARRAY,
 505         .map_name = "void_test3_map",
 506         .key_size = sizeof(int),
 507         .value_size = sizeof(void *) * 4,
 508         .key_type_id = 1,
 509         .value_type_id = 5,
 510         .max_entries = 4,
 511 },
 512
 513 /* const void[4]  */
 514 {
 515         .descr = "void test #4",
 516         .raw_types = {
 517                 /* int */               /* [1] */
 518                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 519                 /* const void */        /* [2] */
 520                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
 521                 /* const void[4] */     /* [3] */
 522                 BTF_TYPE_ARRAY_ENC(2, 1, 4),
 523                 BTF_END_RAW,
 524         },
 525         .str_sec = "\0A\0m",
 526         .str_sec_size = sizeof("\0A\0m"),
 527         .map_type = BPF_MAP_TYPE_ARRAY,
 528         .map_name = "void_test4_map",
 529         .key_size = sizeof(int),
 530         .value_size = sizeof(void *) * 4,
 531         .key_type_id = 1,
 532         .value_type_id = 3,
 533         .max_entries = 4,
 534         .btf_load_err = true,
 535         .err_str = "Invalid elem",
 536 },
 537
 538 /* Array_A  <------------------+
 539  *     elem_type == Array_B    |
 540  *                    |        |
 541  *                    |        |
 542  * Array_B  <-------- +        |
 543  *      elem_type == Array A --+
 544  */
 545 {
 546         .descr = "loop test #1",
 547         .raw_types = {
 548                 /* int */                       /* [1] */
 549                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 550                 /* Array_A */                   /* [2] */
 551                 BTF_TYPE_ARRAY_ENC(3, 1, 8),
 552                 /* Array_B */                   /* [3] */
 553                 BTF_TYPE_ARRAY_ENC(2, 1, 8),
 554                 BTF_END_RAW,
 555         },
 556         .str_sec = "",
 557         .str_sec_size = sizeof(""),
 558         .map_type = BPF_MAP_TYPE_ARRAY,
 559         .map_name = "loop_test1_map",
 560         .key_size = sizeof(int),
 561         .value_size = sizeof(sizeof(int) * 8),
 562         .key_type_id = 1,
 563         .value_type_id = 2,
 564         .max_entries = 4,
 565         .btf_load_err = true,
 566         .err_str = "Loop detected",
 567 },
 568
 569 /* typedef is _before_ the BTF type of Array_A and Array_B
 570  *
 571  * typedef Array_B int_array;
 572  *
 573  * Array_A  <------------------+
 574  *     elem_type == int_array  |
 575  *                    |        |
 576  *                    |        |
 577  * Array_B  <-------- +        |
 578  *      elem_type == Array_A --+
 579  */
 580 {
 581         .descr = "loop test #2",
 582         .raw_types = {
 583                 /* int */
 584                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
 585                 /* typedef Array_B int_array */
 586                 BTF_TYPEDEF_ENC(1, 4),                          /* [2] */
 587                 /* Array_A */
 588                 BTF_TYPE_ARRAY_ENC(2, 1, 8),                    /* [3] */
 589                 /* Array_B */
 590                 BTF_TYPE_ARRAY_ENC(3, 1, 8),                    /* [4] */
 591                 BTF_END_RAW,
 592         },
 593         .str_sec = "\0int_array\0",
 594         .str_sec_size = sizeof("\0int_array"),
 595         .map_type = BPF_MAP_TYPE_ARRAY,
 596         .map_name = "loop_test2_map",
 597         .key_size = sizeof(int),
 598         .value_size = sizeof(sizeof(int) * 8),
 599         .key_type_id = 1,
 600         .value_type_id = 2,
 601         .max_entries = 4,
 602         .btf_load_err = true,
 603         .err_str = "Loop detected",
 604 },
 605
 606 /* Array_A  <------------------+
 607  *     elem_type == Array_B    |
 608  *                    |        |
 609  *                    |        |
 610  * Array_B  <-------- +        |
 611  *      elem_type == Array_A --+
 612  */
 613 {
 614         .descr = "loop test #3",
 615         .raw_types = {
 616                 /* int */                               /* [1] */
 617                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 618                 /* Array_A */                           /* [2] */
 619                 BTF_TYPE_ARRAY_ENC(3, 1, 8),
 620                 /* Array_B */                           /* [3] */
 621                 BTF_TYPE_ARRAY_ENC(2, 1, 8),
 622                 BTF_END_RAW,
 623         },
 624         .str_sec = "",
 625         .str_sec_size = sizeof(""),
 626         .map_type = BPF_MAP_TYPE_ARRAY,
 627         .map_name = "loop_test3_map",
 628         .key_size = sizeof(int),
 629         .value_size = sizeof(sizeof(int) * 8),
 630         .key_type_id = 1,
 631         .value_type_id = 2,
 632         .max_entries = 4,
 633         .btf_load_err = true,
 634         .err_str = "Loop detected",
 635 },
 636
 637 /* typedef is _between_ the BTF type of Array_A and Array_B
 638  *
 639  * typedef Array_B int_array;
 640  *
 641  * Array_A  <------------------+
 642  *     elem_type == int_array  |
 643  *                    |        |
 644  *                    |        |
 645  * Array_B  <-------- +        |
 646  *      elem_type == Array_A --+
 647  */
 648 {
 649         .descr = "loop test #4",
 650         .raw_types = {
 651                 /* int */                               /* [1] */
 652                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 653                 /* Array_A */                           /* [2] */
 654                 BTF_TYPE_ARRAY_ENC(3, 1, 8),
 655                 /* typedef Array_B int_array */         /* [3] */
 656                 BTF_TYPEDEF_ENC(NAME_TBD, 4),
 657                 /* Array_B */                           /* [4] */
 658                 BTF_TYPE_ARRAY_ENC(2, 1, 8),
 659                 BTF_END_RAW,
 660         },
 661         .str_sec = "\0int_array\0",
 662         .str_sec_size = sizeof("\0int_array"),
 663         .map_type = BPF_MAP_TYPE_ARRAY,
 664         .map_name = "loop_test4_map",
 665         .key_size = sizeof(int),
 666         .value_size = sizeof(sizeof(int) * 8),
 667         .key_type_id = 1,
 668         .value_type_id = 2,
 669         .max_entries = 4,
 670         .btf_load_err = true,
 671         .err_str = "Loop detected",
 672 },
 673
 674 /* typedef struct B Struct_B
 675  *
 676  * struct A {
 677  *     int x;
 678  *     Struct_B y;
 679  * };
 680  *
 681  * struct B {
 682  *     int x;
 683  *     struct A y;
 684  * };
 685  */
 686 {
 687         .descr = "loop test #5",
 688         .raw_types = {
 689                 /* int */
 690                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
 691                 /* struct A */                                  /* [2] */
 692                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
 693                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x;       */
 694                 BTF_MEMBER_ENC(NAME_TBD, 3, 32),/* Struct_B y;  */
 695                 /* typedef struct B Struct_B */
 696                 BTF_TYPEDEF_ENC(NAME_TBD, 4),                   /* [3] */
 697                 /* struct B */                                  /* [4] */
 698                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
 699                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x;       */
 700                 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A y;  */
 701                 BTF_END_RAW,
 702         },
 703         .str_sec = "\0A\0x\0y\0Struct_B\0B\0x\0y",
 704         .str_sec_size = sizeof("\0A\0x\0y\0Struct_B\0B\0x\0y"),
 705         .map_type = BPF_MAP_TYPE_ARRAY,
 706         .map_name = "loop_test5_map",
 707         .key_size = sizeof(int),
 708         .value_size = 8,
 709         .key_type_id = 1,
 710         .value_type_id = 2,
 711         .max_entries = 4,
 712         .btf_load_err = true,
 713         .err_str = "Loop detected",
 714 },
 715
 716 /* struct A {
 717  *     int x;
 718  *     struct A array_a[4];
 719  * };
 720  */
 721 {
 722         .descr = "loop test #6",
 723         .raw_types = {
 724                 /* int */
 725                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
 726                 BTF_TYPE_ARRAY_ENC(3, 1, 4),                    /* [2] */
 727                 /* struct A */                                  /* [3] */
 728                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 2), 8),
 729                 BTF_MEMBER_ENC(NAME_TBD, 1, 0), /* int x;               */
 730                 BTF_MEMBER_ENC(NAME_TBD, 2, 32),/* struct A array_a[4]; */
 731                 BTF_END_RAW,
 732         },
 733         .str_sec = "\0A\0x\0y",
 734         .str_sec_size = sizeof("\0A\0x\0y"),
 735         .map_type = BPF_MAP_TYPE_ARRAY,
 736         .map_name = "loop_test6_map",
 737         .key_size = sizeof(int),
 738         .value_size = 8,
 739         .key_type_id = 1,
 740         .value_type_id = 2,
 741         .max_entries = 4,
 742         .btf_load_err = true,
 743         .err_str = "Loop detected",
 744 },
 745
 746 {
 747         .descr = "loop test #7",
 748         .raw_types = {
 749                 /* int */                               /* [1] */
 750                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 751                 /* struct A { */                        /* [2] */
 752                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
 753                 /*     const void *m;   */
 754                 BTF_MEMBER_ENC(NAME_TBD, 3, 0),
 755                 /* CONST type_id=3      */              /* [3] */
 756                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
 757                 /* PTR type_id=2        */              /* [4] */
 758                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 3),
 759                 BTF_END_RAW,
 760         },
 761         .str_sec = "\0A\0m",
 762         .str_sec_size = sizeof("\0A\0m"),
 763         .map_type = BPF_MAP_TYPE_ARRAY,
 764         .map_name = "loop_test7_map",
 765         .key_size = sizeof(int),
 766         .value_size = sizeof(void *),
 767         .key_type_id = 1,
 768         .value_type_id = 2,
 769         .max_entries = 4,
 770         .btf_load_err = true,
 771         .err_str = "Loop detected",
 772 },
 773
 774 {
 775         .descr = "loop test #8",
 776         .raw_types = {
 777                 /* int */                               /* [1] */
 778                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 779                 /* struct A { */                        /* [2] */
 780                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
 781                 /*     const void *m;   */
 782                 BTF_MEMBER_ENC(NAME_TBD, 4, 0),
 783                 /* struct B { */                        /* [3] */
 784                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), sizeof(void *)),
 785                 /*     const void *n;   */
 786                 BTF_MEMBER_ENC(NAME_TBD, 6, 0),
 787                 /* CONST type_id=5      */              /* [4] */
 788                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 5),
 789                 /* PTR type_id=6        */              /* [5] */
 790                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 6),
 791                 /* CONST type_id=7      */              /* [6] */
 792                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 7),
 793                 /* PTR type_id=4        */              /* [7] */
 794                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 4),
 795                 BTF_END_RAW,
 796         },
 797         .str_sec = "\0A\0m\0B\0n",
 798         .str_sec_size = sizeof("\0A\0m\0B\0n"),
 799         .map_type = BPF_MAP_TYPE_ARRAY,
 800         .map_name = "loop_test8_map",
 801         .key_size = sizeof(int),
 802         .value_size = sizeof(void *),
 803         .key_type_id = 1,
 804         .value_type_id = 2,
 805         .max_entries = 4,
 806         .btf_load_err = true,
 807         .err_str = "Loop detected",
 808 },
 809
 810 {
 811         .descr = "string section does not end with null",
 812         .raw_types = {
 813                 /* int */                               /* [1] */
 814                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
 815                 BTF_END_RAW,
 816         },
 817         .str_sec = "\0int",
 818         .str_sec_size = sizeof("\0int") - 1,
 819         .map_type = BPF_MAP_TYPE_ARRAY,
 820         .map_name = "hdr_test_map",
 821         .key_size = sizeof(int),
 822         .value_size = sizeof(int),
 823         .key_type_id = 1,
 824         .value_type_id = 1,
 825         .max_entries = 4,
 826         .btf_load_err = true,
 827         .err_str = "Invalid string section",
 828 },
 829
 830 {
 831         .descr = "empty string section",
 832         .raw_types = {
 833                 /* int */                               /* [1] */
 834                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 835                 BTF_END_RAW,
 836         },
 837         .str_sec = "",
 838         .str_sec_size = 0,
 839         .map_type = BPF_MAP_TYPE_ARRAY,
 840         .map_name = "hdr_test_map",
 841         .key_size = sizeof(int),
 842         .value_size = sizeof(int),
 843         .key_type_id = 1,
 844         .value_type_id = 1,
 845         .max_entries = 4,
 846         .btf_load_err = true,
 847         .err_str = "Invalid string section",
 848 },
 849
 850 {
 851         .descr = "empty type section",
 852         .raw_types = {
 853                 BTF_END_RAW,
 854         },
 855         .str_sec = "\0int",
 856         .str_sec_size = sizeof("\0int"),
 857         .map_type = BPF_MAP_TYPE_ARRAY,
 858         .map_name = "hdr_test_map",
 859         .key_size = sizeof(int),
 860         .value_size = sizeof(int),
 861         .key_type_id = 1,
 862         .value_type_id = 1,
 863         .max_entries = 4,
 864         .btf_load_err = true,
 865         .err_str = "No type found",
 866 },
 867
 868 {
 869         .descr = "btf_header test. Longer hdr_len",
 870         .raw_types = {
 871                 /* int */                               /* [1] */
 872                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
 873                 BTF_END_RAW,
 874         },
 875         .str_sec = "\0int",
 876         .str_sec_size = sizeof("\0int"),
 877         .map_type = BPF_MAP_TYPE_ARRAY,
 878         .map_name = "hdr_test_map",
 879         .key_size = sizeof(int),
 880         .value_size = sizeof(int),
 881         .key_type_id = 1,
 882         .value_type_id = 1,
 883         .max_entries = 4,
 884         .btf_load_err = true,
 885         .hdr_len_delta = 4,
 886         .err_str = "Unsupported btf_header",
 887 },
 888
 889 {
 890         .descr = "btf_header test. Gap between hdr and type",
 891         .raw_types = {
 892                 /* int */                               /* [1] */
 893                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
 894                 BTF_END_RAW,
 895         },
 896         .str_sec = "\0int",
 897         .str_sec_size = sizeof("\0int"),
 898         .map_type = BPF_MAP_TYPE_ARRAY,
 899         .map_name = "hdr_test_map",
 900         .key_size = sizeof(int),
 901         .value_size = sizeof(int),
 902         .key_type_id = 1,
 903         .value_type_id = 1,
 904         .max_entries = 4,
 905         .btf_load_err = true,
 906         .type_off_delta = 4,
 907         .err_str = "Unsupported section found",
 908 },
 909
 910 {
 911         .descr = "btf_header test. Gap between type and str",
 912         .raw_types = {
 913                 /* int */                               /* [1] */
 914                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
 915                 BTF_END_RAW,
 916         },
 917         .str_sec = "\0int",
 918         .str_sec_size = sizeof("\0int"),
 919         .map_type = BPF_MAP_TYPE_ARRAY,
 920         .map_name = "hdr_test_map",
 921         .key_size = sizeof(int),
 922         .value_size = sizeof(int),
 923         .key_type_id = 1,
 924         .value_type_id = 1,
 925         .max_entries = 4,
 926         .btf_load_err = true,
 927         .str_off_delta = 4,
 928         .err_str = "Unsupported section found",
 929 },
 930
 931 {
 932         .descr = "btf_header test. Overlap between type and str",
 933         .raw_types = {
 934                 /* int */                               /* [1] */
 935                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
 936                 BTF_END_RAW,
 937         },
 938         .str_sec = "\0int",
 939         .str_sec_size = sizeof("\0int"),
 940         .map_type = BPF_MAP_TYPE_ARRAY,
 941         .map_name = "hdr_test_map",
 942         .key_size = sizeof(int),
 943         .value_size = sizeof(int),
 944         .key_type_id = 1,
 945         .value_type_id = 1,
 946         .max_entries = 4,
 947         .btf_load_err = true,
 948         .str_off_delta = -4,
 949         .err_str = "Section overlap found",
 950 },
 951
 952 {
 953         .descr = "btf_header test. Larger BTF size",
 954         .raw_types = {
 955                 /* int */                               /* [1] */
 956                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
 957                 BTF_END_RAW,
 958         },
 959         .str_sec = "\0int",
 960         .str_sec_size = sizeof("\0int"),
 961         .map_type = BPF_MAP_TYPE_ARRAY,
 962         .map_name = "hdr_test_map",
 963         .key_size = sizeof(int),
 964         .value_size = sizeof(int),
 965         .key_type_id = 1,
 966         .value_type_id = 1,
 967         .max_entries = 4,
 968         .btf_load_err = true,
 969         .str_len_delta = -4,
 970         .err_str = "Unsupported section found",
 971 },
 972
 973 {
 974         .descr = "btf_header test. Smaller BTF size",
 975         .raw_types = {
 976                 /* int */                               /* [1] */
 977                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
 978                 BTF_END_RAW,
 979         },
 980         .str_sec = "\0int",
 981         .str_sec_size = sizeof("\0int"),
 982         .map_type = BPF_MAP_TYPE_ARRAY,
 983         .map_name = "hdr_test_map",
 984         .key_size = sizeof(int),
 985         .value_size = sizeof(int),
 986         .key_type_id = 1,
 987         .value_type_id = 1,
 988         .max_entries = 4,
 989         .btf_load_err = true,
 990         .str_len_delta = 4,
 991         .err_str = "Total section length too long",
 992 },
 993
 994 {
 995         .descr = "array test. index_type/elem_type \"int\"",
 996         .raw_types = {
 997                 /* int */                               /* [1] */
 998                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
 999                 /* int[16] */                           /* [2] */
1000                 BTF_TYPE_ARRAY_ENC(1, 1, 16),
1001                 BTF_END_RAW,
1002         },
1003         .str_sec = "",
1004         .str_sec_size = sizeof(""),
1005         .map_type = BPF_MAP_TYPE_ARRAY,
1006         .map_name = "array_test_map",
1007         .key_size = sizeof(int),
1008         .value_size = sizeof(int),
1009         .key_type_id = 1,
1010         .value_type_id = 1,
1011         .max_entries = 4,
1012 },
1013
1014 {
1015         .descr = "array test. index_type/elem_type \"const int\"",
1016         .raw_types = {
1017                 /* int */                               /* [1] */
1018                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1019                 /* int[16] */                           /* [2] */
1020                 BTF_TYPE_ARRAY_ENC(3, 3, 16),
1021                 /* CONST type_id=1 */                   /* [3] */
1022                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),
1023                 BTF_END_RAW,
1024         },
1025         .str_sec = "",
1026         .str_sec_size = sizeof(""),
1027         .map_type = BPF_MAP_TYPE_ARRAY,
1028         .map_name = "array_test_map",
1029         .key_size = sizeof(int),
1030         .value_size = sizeof(int),
1031         .key_type_id = 1,
1032         .value_type_id = 1,
1033         .max_entries = 4,
1034 },
1035
1036 {
1037         .descr = "array test. index_type \"const int:31\"",
1038         .raw_types = {
1039                 /* int */                               /* [1] */
1040                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1041                 /* int:31 */                            /* [2] */
1042                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
1043                 /* int[16] */                           /* [3] */
1044                 BTF_TYPE_ARRAY_ENC(1, 4, 16),
1045                 /* CONST type_id=2 */                   /* [4] */
1046                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
1047                 BTF_END_RAW,
1048         },
1049         .str_sec = "",
1050         .str_sec_size = sizeof(""),
1051         .map_type = BPF_MAP_TYPE_ARRAY,
1052         .map_name = "array_test_map",
1053         .key_size = sizeof(int),
1054         .value_size = sizeof(int),
1055         .key_type_id = 1,
1056         .value_type_id = 1,
1057         .max_entries = 4,
1058         .btf_load_err = true,
1059         .err_str = "Invalid index",
1060 },
1061
1062 {
1063         .descr = "array test. elem_type \"const int:31\"",
1064         .raw_types = {
1065                 /* int */                               /* [1] */
1066                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1067                 /* int:31 */                            /* [2] */
1068                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 31, 4),
1069                 /* int[16] */                           /* [3] */
1070                 BTF_TYPE_ARRAY_ENC(4, 1, 16),
1071                 /* CONST type_id=2 */                   /* [4] */
1072                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 2),
1073                 BTF_END_RAW,
1074         },
1075         .str_sec = "",
1076         .str_sec_size = sizeof(""),
1077         .map_type = BPF_MAP_TYPE_ARRAY,
1078         .map_name = "array_test_map",
1079         .key_size = sizeof(int),
1080         .value_size = sizeof(int),
1081         .key_type_id = 1,
1082         .value_type_id = 1,
1083         .max_entries = 4,
1084         .btf_load_err = true,
1085         .err_str = "Invalid array of int",
1086 },
1087
1088 {
1089         .descr = "array test. index_type \"void\"",
1090         .raw_types = {
1091                 /* int */                               /* [1] */
1092                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1093                 /* int[16] */                           /* [2] */
1094                 BTF_TYPE_ARRAY_ENC(1, 0, 16),
1095                 BTF_END_RAW,
1096         },
1097         .str_sec = "",
1098         .str_sec_size = sizeof(""),
1099         .map_type = BPF_MAP_TYPE_ARRAY,
1100         .map_name = "array_test_map",
1101         .key_size = sizeof(int),
1102         .value_size = sizeof(int),
1103         .key_type_id = 1,
1104         .value_type_id = 1,
1105         .max_entries = 4,
1106         .btf_load_err = true,
1107         .err_str = "Invalid index",
1108 },
1109
1110 {
1111         .descr = "array test. index_type \"const void\"",
1112         .raw_types = {
1113                 /* int */                               /* [1] */
1114                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1115                 /* int[16] */                           /* [2] */
1116                 BTF_TYPE_ARRAY_ENC(1, 3, 16),
1117                 /* CONST type_id=0 (void) */            /* [3] */
1118                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1119                 BTF_END_RAW,
1120         },
1121         .str_sec = "",
1122         .str_sec_size = sizeof(""),
1123         .map_type = BPF_MAP_TYPE_ARRAY,
1124         .map_name = "array_test_map",
1125         .key_size = sizeof(int),
1126         .value_size = sizeof(int),
1127         .key_type_id = 1,
1128         .value_type_id = 1,
1129         .max_entries = 4,
1130         .btf_load_err = true,
1131         .err_str = "Invalid index",
1132 },
1133
1134 {
1135         .descr = "array test. elem_type \"const void\"",
1136         .raw_types = {
1137                 /* int */                               /* [1] */
1138                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1139                 /* int[16] */                           /* [2] */
1140                 BTF_TYPE_ARRAY_ENC(3, 1, 16),
1141                 /* CONST type_id=0 (void) */            /* [3] */
1142                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 0),
1143                 BTF_END_RAW,
1144         },
1145         .str_sec = "",
1146         .str_sec_size = sizeof(""),
1147         .map_type = BPF_MAP_TYPE_ARRAY,
1148         .map_name = "array_test_map",
1149         .key_size = sizeof(int),
1150         .value_size = sizeof(int),
1151         .key_type_id = 1,
1152         .value_type_id = 1,
1153         .max_entries = 4,
1154         .btf_load_err = true,
1155         .err_str = "Invalid elem",
1156 },
1157
1158 {
1159         .descr = "array test. elem_type \"const void *\"",
1160         .raw_types = {
1161                 /* int */                               /* [1] */
1162                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1163                 /* const void *[16] */                  /* [2] */
1164                 BTF_TYPE_ARRAY_ENC(3, 1, 16),
1165                 /* CONST type_id=4 */                   /* [3] */
1166                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1167                 /* void* */                             /* [4] */
1168                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
1169                 BTF_END_RAW,
1170         },
1171         .str_sec = "",
1172         .str_sec_size = sizeof(""),
1173         .map_type = BPF_MAP_TYPE_ARRAY,
1174         .map_name = "array_test_map",
1175         .key_size = sizeof(int),
1176         .value_size = sizeof(int),
1177         .key_type_id = 1,
1178         .value_type_id = 1,
1179         .max_entries = 4,
1180 },
1181
1182 {
1183         .descr = "array test. index_type \"const void *\"",
1184         .raw_types = {
1185                 /* int */                               /* [1] */
1186                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1187                 /* const void *[16] */                  /* [2] */
1188                 BTF_TYPE_ARRAY_ENC(3, 3, 16),
1189                 /* CONST type_id=4 */                   /* [3] */
1190                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 4),
1191                 /* void* */                             /* [4] */
1192                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
1193                 BTF_END_RAW,
1194         },
1195         .str_sec = "",
1196         .str_sec_size = sizeof(""),
1197         .map_type = BPF_MAP_TYPE_ARRAY,
1198         .map_name = "array_test_map",
1199         .key_size = sizeof(int),
1200         .value_size = sizeof(int),
1201         .key_type_id = 1,
1202         .value_type_id = 1,
1203         .max_entries = 4,
1204         .btf_load_err = true,
1205         .err_str = "Invalid index",
1206 },
1207
1208 {
1209         .descr = "array test. t->size != 0\"",
1210         .raw_types = {
1211                 /* int */                               /* [1] */
1212                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1213                 /* int[16] */                           /* [2] */
1214                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 1),
1215                 BTF_ARRAY_ENC(1, 1, 16),
1216                 BTF_END_RAW,
1217         },
1218         .str_sec = "",
1219         .str_sec_size = sizeof(""),
1220         .map_type = BPF_MAP_TYPE_ARRAY,
1221         .map_name = "array_test_map",
1222         .key_size = sizeof(int),
1223         .value_size = sizeof(int),
1224         .key_type_id = 1,
1225         .value_type_id = 1,
1226         .max_entries = 4,
1227         .btf_load_err = true,
1228         .err_str = "size != 0",
1229 },
1230
1231 {
1232         .descr = "int test. invalid int_data",
1233         .raw_types = {
1234                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), 4),
1235                 0x10000000,
1236                 BTF_END_RAW,
1237         },
1238         .str_sec = "",
1239         .str_sec_size = sizeof(""),
1240         .map_type = BPF_MAP_TYPE_ARRAY,
1241         .map_name = "array_test_map",
1242         .key_size = sizeof(int),
1243         .value_size = sizeof(int),
1244         .key_type_id = 1,
1245         .value_type_id = 1,
1246         .max_entries = 4,
1247         .btf_load_err = true,
1248         .err_str = "Invalid int_data",
1249 },
1250
1251 {
1252         .descr = "invalid BTF_INFO",
1253         .raw_types = {
1254                 /* int */                               /* [1] */
1255                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1256                 BTF_TYPE_ENC(0, 0x10000000, 4),
1257                 BTF_END_RAW,
1258         },
1259         .str_sec = "",
1260         .str_sec_size = sizeof(""),
1261         .map_type = BPF_MAP_TYPE_ARRAY,
1262         .map_name = "array_test_map",
1263         .key_size = sizeof(int),
1264         .value_size = sizeof(int),
1265         .key_type_id = 1,
1266         .value_type_id = 1,
1267         .max_entries = 4,
1268         .btf_load_err = true,
1269         .err_str = "Invalid btf_info",
1270 },
1271
1272 {
1273         .descr = "fwd test. t->type != 0\"",
1274         .raw_types = {
1275                 /* int */                               /* [1] */
1276                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1277                 /* fwd type */                          /* [2] */
1278                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 1),
1279                 BTF_END_RAW,
1280         },
1281         .str_sec = "",
1282         .str_sec_size = sizeof(""),
1283         .map_type = BPF_MAP_TYPE_ARRAY,
1284         .map_name = "fwd_test_map",
1285         .key_size = sizeof(int),
1286         .value_size = sizeof(int),
1287         .key_type_id = 1,
1288         .value_type_id = 1,
1289         .max_entries = 4,
1290         .btf_load_err = true,
1291         .err_str = "type != 0",
1292 },
1293
1294 {
1295         .descr = "typedef (invalid name, name_off = 0)",
1296         .raw_types = {
1297                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
1298                 BTF_TYPEDEF_ENC(0, 1),                          /* [2] */
1299                 BTF_END_RAW,
1300         },
1301         .str_sec = "\0__int",
1302         .str_sec_size = sizeof("\0__int"),
1303         .map_type = BPF_MAP_TYPE_ARRAY,
1304         .map_name = "typedef_check_btf",
1305         .key_size = sizeof(int),
1306         .value_size = sizeof(int),
1307         .key_type_id = 1,
1308         .value_type_id = 1,
1309         .max_entries = 4,
1310         .btf_load_err = true,
1311         .err_str = "Invalid name",
1312 },
1313
1314 {
1315         .descr = "typedef (invalid name, invalid identifier)",
1316         .raw_types = {
1317                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
1318                 BTF_TYPEDEF_ENC(NAME_TBD, 1),                   /* [2] */
1319                 BTF_END_RAW,
1320         },
1321         .str_sec = "\0__!int",
1322         .str_sec_size = sizeof("\0__!int"),
1323         .map_type = BPF_MAP_TYPE_ARRAY,
1324         .map_name = "typedef_check_btf",
1325         .key_size = sizeof(int),
1326         .value_size = sizeof(int),
1327         .key_type_id = 1,
1328         .value_type_id = 1,
1329         .max_entries = 4,
1330         .btf_load_err = true,
1331         .err_str = "Invalid name",
1332 },
1333
1334 {
1335         .descr = "ptr type (invalid name, name_off <> 0)",
1336         .raw_types = {
1337                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1338                 BTF_TYPE_ENC(NAME_TBD,
1339                              BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1),      /* [2] */
1340                 BTF_END_RAW,
1341         },
1342         .str_sec = "\0__int",
1343         .str_sec_size = sizeof("\0__int"),
1344         .map_type = BPF_MAP_TYPE_ARRAY,
1345         .map_name = "ptr_type_check_btf",
1346         .key_size = sizeof(int),
1347         .value_size = sizeof(int),
1348         .key_type_id = 1,
1349         .value_type_id = 1,
1350         .max_entries = 4,
1351         .btf_load_err = true,
1352         .err_str = "Invalid name",
1353 },
1354
1355 {
1356         .descr = "volatile type (invalid name, name_off <> 0)",
1357         .raw_types = {
1358                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1359                 BTF_TYPE_ENC(NAME_TBD,
1360                              BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), 1), /* [2] */
1361                 BTF_END_RAW,
1362         },
1363         .str_sec = "\0__int",
1364         .str_sec_size = sizeof("\0__int"),
1365         .map_type = BPF_MAP_TYPE_ARRAY,
1366         .map_name = "volatile_type_check_btf",
1367         .key_size = sizeof(int),
1368         .value_size = sizeof(int),
1369         .key_type_id = 1,
1370         .value_type_id = 1,
1371         .max_entries = 4,
1372         .btf_load_err = true,
1373         .err_str = "Invalid name",
1374 },
1375
1376 {
1377         .descr = "const type (invalid name, name_off <> 0)",
1378         .raw_types = {
1379                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1380                 BTF_TYPE_ENC(NAME_TBD,
1381                              BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), 1),    /* [2] */
1382                 BTF_END_RAW,
1383         },
1384         .str_sec = "\0__int",
1385         .str_sec_size = sizeof("\0__int"),
1386         .map_type = BPF_MAP_TYPE_ARRAY,
1387         .map_name = "const_type_check_btf",
1388         .key_size = sizeof(int),
1389         .value_size = sizeof(int),
1390         .key_type_id = 1,
1391         .value_type_id = 1,
1392         .max_entries = 4,
1393         .btf_load_err = true,
1394         .err_str = "Invalid name",
1395 },
1396
1397 {
1398         .descr = "restrict type (invalid name, name_off <> 0)",
1399         .raw_types = {
1400                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1401                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 1),   /* [2] */
1402                 BTF_TYPE_ENC(NAME_TBD,
1403                              BTF_INFO_ENC(BTF_KIND_RESTRICT, 0, 0), 2), /* [3] */
1404                 BTF_END_RAW,
1405         },
1406         .str_sec = "\0__int",
1407         .str_sec_size = sizeof("\0__int"),
1408         .map_type = BPF_MAP_TYPE_ARRAY,
1409         .map_name = "restrict_type_check_btf",
1410         .key_size = sizeof(int),
1411         .value_size = sizeof(int),
1412         .key_type_id = 1,
1413         .value_type_id = 1,
1414         .max_entries = 4,
1415         .btf_load_err = true,
1416         .err_str = "Invalid name",
1417 },
1418
1419 {
1420         .descr = "fwd type (invalid name, name_off = 0)",
1421         .raw_types = {
1422                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1423                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0),   /* [2] */
1424                 BTF_END_RAW,
1425         },
1426         .str_sec = "\0__skb",
1427         .str_sec_size = sizeof("\0__skb"),
1428         .map_type = BPF_MAP_TYPE_ARRAY,
1429         .map_name = "fwd_type_check_btf",
1430         .key_size = sizeof(int),
1431         .value_size = sizeof(int),
1432         .key_type_id = 1,
1433         .value_type_id = 1,
1434         .max_entries = 4,
1435         .btf_load_err = true,
1436         .err_str = "Invalid name",
1437 },
1438
1439 {
1440         .descr = "fwd type (invalid name, invalid identifier)",
1441         .raw_types = {
1442                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1443                 BTF_TYPE_ENC(NAME_TBD,
1444                              BTF_INFO_ENC(BTF_KIND_FWD, 0, 0), 0),      /* [2] */
1445                 BTF_END_RAW,
1446         },
1447         .str_sec = "\0__!skb",
1448         .str_sec_size = sizeof("\0__!skb"),
1449         .map_type = BPF_MAP_TYPE_ARRAY,
1450         .map_name = "fwd_type_check_btf",
1451         .key_size = sizeof(int),
1452         .value_size = sizeof(int),
1453         .key_type_id = 1,
1454         .value_type_id = 1,
1455         .max_entries = 4,
1456         .btf_load_err = true,
1457         .err_str = "Invalid name",
1458 },
1459
1460 {
1461         .descr = "array type (invalid name, name_off <> 0)",
1462         .raw_types = {
1463                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1464                 BTF_TYPE_ENC(NAME_TBD,
1465                              BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 0),    /* [2] */
1466                 BTF_ARRAY_ENC(1, 1, 4),
1467                 BTF_END_RAW,
1468         },
1469         .str_sec = "\0__skb",
1470         .str_sec_size = sizeof("\0__skb"),
1471         .map_type = BPF_MAP_TYPE_ARRAY,
1472         .map_name = "array_type_check_btf",
1473         .key_size = sizeof(int),
1474         .value_size = sizeof(int),
1475         .key_type_id = 1,
1476         .value_type_id = 1,
1477         .max_entries = 4,
1478         .btf_load_err = true,
1479         .err_str = "Invalid name",
1480 },
1481
1482 {
1483         .descr = "struct type (name_off = 0)",
1484         .raw_types = {
1485                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1486                 BTF_TYPE_ENC(0,
1487                              BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
1488                 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
1489                 BTF_END_RAW,
1490         },
1491         .str_sec = "\0A",
1492         .str_sec_size = sizeof("\0A"),
1493         .map_type = BPF_MAP_TYPE_ARRAY,
1494         .map_name = "struct_type_check_btf",
1495         .key_size = sizeof(int),
1496         .value_size = sizeof(int),
1497         .key_type_id = 1,
1498         .value_type_id = 1,
1499         .max_entries = 4,
1500 },
1501
1502 {
1503         .descr = "struct type (invalid name, invalid identifier)",
1504         .raw_types = {
1505                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1506                 BTF_TYPE_ENC(NAME_TBD,
1507                              BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
1508                 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
1509                 BTF_END_RAW,
1510         },
1511         .str_sec = "\0A!\0B",
1512         .str_sec_size = sizeof("\0A!\0B"),
1513         .map_type = BPF_MAP_TYPE_ARRAY,
1514         .map_name = "struct_type_check_btf",
1515         .key_size = sizeof(int),
1516         .value_size = sizeof(int),
1517         .key_type_id = 1,
1518         .value_type_id = 1,
1519         .max_entries = 4,
1520         .btf_load_err = true,
1521         .err_str = "Invalid name",
1522 },
1523
1524 {
1525         .descr = "struct member (name_off = 0)",
1526         .raw_types = {
1527                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1528                 BTF_TYPE_ENC(0,
1529                              BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
1530                 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
1531                 BTF_END_RAW,
1532         },
1533         .str_sec = "\0A",
1534         .str_sec_size = sizeof("\0A"),
1535         .map_type = BPF_MAP_TYPE_ARRAY,
1536         .map_name = "struct_type_check_btf",
1537         .key_size = sizeof(int),
1538         .value_size = sizeof(int),
1539         .key_type_id = 1,
1540         .value_type_id = 1,
1541         .max_entries = 4,
1542 },
1543
1544 {
1545         .descr = "struct member (invalid name, invalid identifier)",
1546         .raw_types = {
1547                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1548                 BTF_TYPE_ENC(NAME_TBD,
1549                              BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 1), 4),   /* [2] */
1550                 BTF_MEMBER_ENC(NAME_TBD, 1, 0),
1551                 BTF_END_RAW,
1552         },
1553         .str_sec = "\0A\0B*",
1554         .str_sec_size = sizeof("\0A\0B*"),
1555         .map_type = BPF_MAP_TYPE_ARRAY,
1556         .map_name = "struct_type_check_btf",
1557         .key_size = sizeof(int),
1558         .value_size = sizeof(int),
1559         .key_type_id = 1,
1560         .value_type_id = 1,
1561         .max_entries = 4,
1562         .btf_load_err = true,
1563         .err_str = "Invalid name",
1564 },
1565
1566 {
1567         .descr = "enum type (name_off = 0)",
1568         .raw_types = {
1569                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1570                 BTF_TYPE_ENC(0,
1571                              BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
1572                              sizeof(int)),                              /* [2] */
1573                 BTF_ENUM_ENC(NAME_TBD, 0),
1574                 BTF_END_RAW,
1575         },
1576         .str_sec = "\0A\0B",
1577         .str_sec_size = sizeof("\0A\0B"),
1578         .map_type = BPF_MAP_TYPE_ARRAY,
1579         .map_name = "enum_type_check_btf",
1580         .key_size = sizeof(int),
1581         .value_size = sizeof(int),
1582         .key_type_id = 1,
1583         .value_type_id = 1,
1584         .max_entries = 4,
1585 },
1586
1587 {
1588         .descr = "enum type (invalid name, invalid identifier)",
1589         .raw_types = {
1590                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1591                 BTF_TYPE_ENC(NAME_TBD,
1592                              BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
1593                              sizeof(int)),                              /* [2] */
1594                 BTF_ENUM_ENC(NAME_TBD, 0),
1595                 BTF_END_RAW,
1596         },
1597         .str_sec = "\0A!\0B",
1598         .str_sec_size = sizeof("\0A!\0B"),
1599         .map_type = BPF_MAP_TYPE_ARRAY,
1600         .map_name = "enum_type_check_btf",
1601         .key_size = sizeof(int),
1602         .value_size = sizeof(int),
1603         .key_type_id = 1,
1604         .value_type_id = 1,
1605         .max_entries = 4,
1606         .btf_load_err = true,
1607         .err_str = "Invalid name",
1608 },
1609
1610 {
1611         .descr = "enum member (invalid name, name_off = 0)",
1612         .raw_types = {
1613                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1614                 BTF_TYPE_ENC(0,
1615                              BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
1616                              sizeof(int)),                              /* [2] */
1617                 BTF_ENUM_ENC(0, 0),
1618                 BTF_END_RAW,
1619         },
1620         .str_sec = "",
1621         .str_sec_size = sizeof(""),
1622         .map_type = BPF_MAP_TYPE_ARRAY,
1623         .map_name = "enum_type_check_btf",
1624         .key_size = sizeof(int),
1625         .value_size = sizeof(int),
1626         .key_type_id = 1,
1627         .value_type_id = 1,
1628         .max_entries = 4,
1629         .btf_load_err = true,
1630         .err_str = "Invalid name",
1631 },
1632
1633 {
1634         .descr = "enum member (invalid name, invalid identifier)",
1635         .raw_types = {
1636                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),          /* [1] */
1637                 BTF_TYPE_ENC(0,
1638                              BTF_INFO_ENC(BTF_KIND_ENUM, 0, 1),
1639                              sizeof(int)),                              /* [2] */
1640                 BTF_ENUM_ENC(NAME_TBD, 0),
1641                 BTF_END_RAW,
1642         },
1643         .str_sec = "\0A!",
1644         .str_sec_size = sizeof("\0A!"),
1645         .map_type = BPF_MAP_TYPE_ARRAY,
1646         .map_name = "enum_type_check_btf",
1647         .key_size = sizeof(int),
1648         .value_size = sizeof(int),
1649         .key_type_id = 1,
1650         .value_type_id = 1,
1651         .max_entries = 4,
1652         .btf_load_err = true,
1653         .err_str = "Invalid name",
1654 },
1655 {
1656         .descr = "arraymap invalid btf key (a bit field)",
1657         .raw_types = {
1658                 /* int */                               /* [1] */
1659                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1660                 /* 32 bit int with 32 bit offset */     /* [2] */
1661                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 32, 32, 8),
1662                 BTF_END_RAW,
1663         },
1664         .str_sec = "",
1665         .str_sec_size = sizeof(""),
1666         .map_type = BPF_MAP_TYPE_ARRAY,
1667         .map_name = "array_map_check_btf",
1668         .key_size = sizeof(int),
1669         .value_size = sizeof(int),
1670         .key_type_id = 2,
1671         .value_type_id = 1,
1672         .max_entries = 4,
1673         .map_create_err = true,
1674 },
1675
1676 {
1677         .descr = "arraymap invalid btf key (!= 32 bits)",
1678         .raw_types = {
1679                 /* int */                               /* [1] */
1680                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1681                 /* 16 bit int with 0 bit offset */      /* [2] */
1682                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 16, 2),
1683                 BTF_END_RAW,
1684         },
1685         .str_sec = "",
1686         .str_sec_size = sizeof(""),
1687         .map_type = BPF_MAP_TYPE_ARRAY,
1688         .map_name = "array_map_check_btf",
1689         .key_size = sizeof(int),
1690         .value_size = sizeof(int),
1691         .key_type_id = 2,
1692         .value_type_id = 1,
1693         .max_entries = 4,
1694         .map_create_err = true,
1695 },
1696
1697 {
1698         .descr = "arraymap invalid btf value (too small)",
1699         .raw_types = {
1700                 /* int */                               /* [1] */
1701                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1702                 BTF_END_RAW,
1703         },
1704         .str_sec = "",
1705         .str_sec_size = sizeof(""),
1706         .map_type = BPF_MAP_TYPE_ARRAY,
1707         .map_name = "array_map_check_btf",
1708         .key_size = sizeof(int),
1709         /* btf_value_size < map->value_size */
1710         .value_size = sizeof(__u64),
1711         .key_type_id = 1,
1712         .value_type_id = 1,
1713         .max_entries = 4,
1714         .map_create_err = true,
1715 },
1716
1717 {
1718         .descr = "arraymap invalid btf value (too big)",
1719         .raw_types = {
1720                 /* int */                               /* [1] */
1721                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1722                 BTF_END_RAW,
1723         },
1724         .str_sec = "",
1725         .str_sec_size = sizeof(""),
1726         .map_type = BPF_MAP_TYPE_ARRAY,
1727         .map_name = "array_map_check_btf",
1728         .key_size = sizeof(int),
1729         /* btf_value_size > map->value_size */
1730         .value_size = sizeof(__u16),
1731         .key_type_id = 1,
1732         .value_type_id = 1,
1733         .max_entries = 4,
1734         .map_create_err = true,
1735 },
1736
1737 }; /* struct btf_raw_test raw_tests[] */
1738
1739 static const char *get_next_str(const char *start, const char *end)
1740 {
1741         return start < end - 1 ? start + 1 : NULL;
1742 }
1743
1744 static int get_type_sec_size(const __u32 *raw_types)
1745 {
1746         int i;
1747
1748         for (i = MAX_NR_RAW_TYPES - 1;
1749              i >= 0 && raw_types[i] != BTF_END_RAW;
1750              i--)
1751                 ;
1752
1753         return i < 0 ? i : i * sizeof(raw_types[0]);
1754 }
1755
1756 static void *btf_raw_create(const struct btf_header *hdr,
1757                             const __u32 *raw_types,
1758                             const char *str,
1759                             unsigned int str_sec_size,
1760                             unsigned int *btf_size)
1761 {
1762         const char *next_str = str, *end_str = str + str_sec_size;
1763         unsigned int size_needed, offset;
1764         struct btf_header *ret_hdr;
1765         int i, type_sec_size;
1766         uint32_t *ret_types;
1767         void *raw_btf;
1768
1769         type_sec_size = get_type_sec_size(raw_types);
1770         if (CHECK(type_sec_size < 0, "Cannot get nr_raw_types"))
1771                 return NULL;
1772
1773         size_needed = sizeof(*hdr) + type_sec_size + str_sec_size;
1774         raw_btf = malloc(size_needed);
1775         if (CHECK(!raw_btf, "Cannot allocate memory for raw_btf"))
1776                 return NULL;
1777
1778         /* Copy header */
1779         memcpy(raw_btf, hdr, sizeof(*hdr));
1780         offset = sizeof(*hdr);
1781
1782         /* Copy type section */
1783         ret_types = raw_btf + offset;
1784         for (i = 0; i < type_sec_size / sizeof(raw_types[0]); i++) {
1785                 if (raw_types[i] == NAME_TBD) {
1786                         next_str = get_next_str(next_str, end_str);
1787                         if (CHECK(!next_str, "Error in getting next_str")) {
1788                                 free(raw_btf);
1789                                 return NULL;
1790                         }
1791                         ret_types[i] = next_str - str;
1792                         next_str += strlen(next_str);
1793                 } else {
1794                         ret_types[i] = raw_types[i];
1795                 }
1796         }
1797         offset += type_sec_size;
1798
1799         /* Copy string section */
1800         memcpy(raw_btf + offset, str, str_sec_size);
1801
1802         ret_hdr = (struct btf_header *)raw_btf;
1803         ret_hdr->type_len = type_sec_size;
1804         ret_hdr->str_off = type_sec_size;
1805         ret_hdr->str_len = str_sec_size;
1806
1807         *btf_size = size_needed;
1808
1809         return raw_btf;
1810 }
1811
1812 static int do_test_raw(unsigned int test_num)
1813 {
1814         struct btf_raw_test *test = &raw_tests[test_num - 1];
1815         struct bpf_create_map_attr create_attr = {};
1816         int map_fd = -1, btf_fd = -1;
1817         unsigned int raw_btf_size;
1818         struct btf_header *hdr;
1819         void *raw_btf;
1820         int err;
1821
1822         fprintf(stderr, "BTF raw test[%u] (%s): ", test_num, test->descr);
1823         raw_btf = btf_raw_create(&hdr_tmpl,
1824                                  test->raw_types,
1825                                  test->str_sec,
1826                                  test->str_sec_size,
1827                                  &raw_btf_size);
1828
1829         if (!raw_btf)
1830                 return -1;
1831
1832         hdr = raw_btf;
1833
1834         hdr->hdr_len = (int)hdr->hdr_len + test->hdr_len_delta;
1835         hdr->type_off = (int)hdr->type_off + test->type_off_delta;
1836         hdr->str_off = (int)hdr->str_off + test->str_off_delta;
1837         hdr->str_len = (int)hdr->str_len + test->str_len_delta;
1838
1839         *btf_log_buf = '\0';
1840         btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
1841                               btf_log_buf, BTF_LOG_BUF_SIZE,
1842                               args.always_log);
1843         free(raw_btf);
1844
1845         err = ((btf_fd == -1) != test->btf_load_err);
1846         if (CHECK(err, "btf_fd:%d test->btf_load_err:%u",
1847                   btf_fd, test->btf_load_err) ||
1848             CHECK(test->err_str && !strstr(btf_log_buf, test->err_str),
1849                   "expected err_str:%s", test->err_str)) {
1850                 err = -1;
1851                 goto done;
1852         }
1853
1854         if (err || btf_fd == -1)
1855                 goto done;
1856
1857         create_attr.name = test->map_name;
1858         create_attr.map_type = test->map_type;
1859         create_attr.key_size = test->key_size;
1860         create_attr.value_size = test->value_size;
1861         create_attr.max_entries = test->max_entries;
1862         create_attr.btf_fd = btf_fd;
1863         create_attr.btf_key_type_id = test->key_type_id;
1864         create_attr.btf_value_type_id = test->value_type_id;
1865
1866         map_fd = bpf_create_map_xattr(&create_attr);
1867
1868         err = ((map_fd == -1) != test->map_create_err);
1869         CHECK(err, "map_fd:%d test->map_create_err:%u",
1870               map_fd, test->map_create_err);
1871
1872 done:
1873         if (!err)
1874                 fprintf(stderr, "OK");
1875
1876         if (*btf_log_buf && (err || args.always_log))
1877                 fprintf(stderr, "\n%s", btf_log_buf);
1878
1879         if (btf_fd != -1)
1880                 close(btf_fd);
1881         if (map_fd != -1)
1882                 close(map_fd);
1883
1884         return err;
1885 }
1886
1887 static int test_raw(void)
1888 {
1889         unsigned int i;
1890         int err = 0;
1891
1892         if (args.raw_test_num)
1893                 return count_result(do_test_raw(args.raw_test_num));
1894
1895         for (i = 1; i <= ARRAY_SIZE(raw_tests); i++)
1896                 err |= count_result(do_test_raw(i));
1897
1898         return err;
1899 }
1900
1901 struct btf_get_info_test {
1902         const char *descr;
1903         const char *str_sec;
1904         __u32 raw_types[MAX_NR_RAW_TYPES];
1905         __u32 str_sec_size;
1906         int btf_size_delta;
1907         int (*special_test)(unsigned int test_num);
1908 };
1909
1910 static int test_big_btf_info(unsigned int test_num);
1911 static int test_btf_id(unsigned int test_num);
1912
1913 const struct btf_get_info_test get_info_tests[] = {
1914 {
1915         .descr = "== raw_btf_size+1",
1916         .raw_types = {
1917                 /* int */                               /* [1] */
1918                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1919                 BTF_END_RAW,
1920         },
1921         .str_sec = "",
1922         .str_sec_size = sizeof(""),
1923         .btf_size_delta = 1,
1924 },
1925 {
1926         .descr = "== raw_btf_size-3",
1927         .raw_types = {
1928                 /* int */                               /* [1] */
1929                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1930                 BTF_END_RAW,
1931         },
1932         .str_sec = "",
1933         .str_sec_size = sizeof(""),
1934         .btf_size_delta = -3,
1935 },
1936 {
1937         .descr = "Large bpf_btf_info",
1938         .raw_types = {
1939                 /* int */                               /* [1] */
1940                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1941                 BTF_END_RAW,
1942         },
1943         .str_sec = "",
1944         .str_sec_size = sizeof(""),
1945         .special_test = test_big_btf_info,
1946 },
1947 {
1948         .descr = "BTF ID",
1949         .raw_types = {
1950                 /* int */                               /* [1] */
1951                 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),
1952                 /* unsigned int */                      /* [2] */
1953                 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),
1954                 BTF_END_RAW,
1955         },
1956         .str_sec = "",
1957         .str_sec_size = sizeof(""),
1958         .special_test = test_btf_id,
1959 },
1960 };
1961
1962 static inline __u64 ptr_to_u64(const void *ptr)
1963 {
1964         return (__u64)(unsigned long)ptr;
1965 }
1966
1967 static int test_big_btf_info(unsigned int test_num)
1968 {
1969         const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
1970         uint8_t *raw_btf = NULL, *user_btf = NULL;
1971         unsigned int raw_btf_size;
1972         struct {
1973                 struct bpf_btf_info info;
1974                 uint64_t garbage;
1975         } info_garbage;
1976         struct bpf_btf_info *info;
1977         int btf_fd = -1, err;
1978         uint32_t info_len;
1979
1980         raw_btf = btf_raw_create(&hdr_tmpl,
1981                                  test->raw_types,
1982                                  test->str_sec,
1983                                  test->str_sec_size,
1984                                  &raw_btf_size);
1985
1986         if (!raw_btf)
1987                 return -1;
1988
1989         *btf_log_buf = '\0';
1990
1991         user_btf = malloc(raw_btf_size);
1992         if (CHECK(!user_btf, "!user_btf")) {
1993                 err = -1;
1994                 goto done;
1995         }
1996
1997         btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
1998                               btf_log_buf, BTF_LOG_BUF_SIZE,
1999                               args.always_log);
2000         if (CHECK(btf_fd == -1, "errno:%d", errno)) {
2001                 err = -1;
2002                 goto done;
2003         }
2004
2005         /*
2006          * GET_INFO should error out if the userspace info
2007          * has non zero tailing bytes.
2008          */
2009         info = &info_garbage.info;
2010         memset(info, 0, sizeof(*info));
2011         info_garbage.garbage = 0xdeadbeef;
2012         info_len = sizeof(info_garbage);
2013         info->btf = ptr_to_u64(user_btf);
2014         info->btf_size = raw_btf_size;
2015
2016         err = bpf_obj_get_info_by_fd(btf_fd, info, &info_len);
2017         if (CHECK(!err, "!err")) {
2018                 err = -1;
2019                 goto done;
2020         }
2021
2022         /*
2023          * GET_INFO should succeed even info_len is larger than
2024          * the kernel supported as long as tailing bytes are zero.
2025          * The kernel supported info len should also be returned
2026          * to userspace.
2027          */
2028         info_garbage.garbage = 0;
2029         err = bpf_obj_get_info_by_fd(btf_fd, info, &info_len);
2030         if (CHECK(err || info_len != sizeof(*info),
2031                   "err:%d errno:%d info_len:%u sizeof(*info):%lu",
2032                   err, errno, info_len, sizeof(*info))) {
2033                 err = -1;
2034                 goto done;
2035         }
2036
2037         fprintf(stderr, "OK");
2038
2039 done:
2040         if (*btf_log_buf && (err || args.always_log))
2041                 fprintf(stderr, "\n%s", btf_log_buf);
2042
2043         free(raw_btf);
2044         free(user_btf);
2045
2046         if (btf_fd != -1)
2047                 close(btf_fd);
2048
2049         return err;
2050 }
2051
2052 static int test_btf_id(unsigned int test_num)
2053 {
2054         const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
2055         struct bpf_create_map_attr create_attr = {};
2056         uint8_t *raw_btf = NULL, *user_btf[2] = {};
2057         int btf_fd[2] = {-1, -1}, map_fd = -1;
2058         struct bpf_map_info map_info = {};
2059         struct bpf_btf_info info[2] = {};
2060         unsigned int raw_btf_size;
2061         uint32_t info_len;
2062         int err, i, ret;
2063
2064         raw_btf = btf_raw_create(&hdr_tmpl,
2065                                  test->raw_types,
2066                                  test->str_sec,
2067                                  test->str_sec_size,
2068                                  &raw_btf_size);
2069
2070         if (!raw_btf)
2071                 return -1;
2072
2073         *btf_log_buf = '\0';
2074
2075         for (i = 0; i < 2; i++) {
2076                 user_btf[i] = malloc(raw_btf_size);
2077                 if (CHECK(!user_btf[i], "!user_btf[%d]", i)) {
2078                         err = -1;
2079                         goto done;
2080                 }
2081                 info[i].btf = ptr_to_u64(user_btf[i]);
2082                 info[i].btf_size = raw_btf_size;
2083         }
2084
2085         btf_fd[0] = bpf_load_btf(raw_btf, raw_btf_size,
2086                                  btf_log_buf, BTF_LOG_BUF_SIZE,
2087                                  args.always_log);
2088         if (CHECK(btf_fd[0] == -1, "errno:%d", errno)) {
2089                 err = -1;
2090                 goto done;
2091         }
2092
2093         /* Test BPF_OBJ_GET_INFO_BY_ID on btf_id */
2094         info_len = sizeof(info[0]);
2095         err = bpf_obj_get_info_by_fd(btf_fd[0], &info[0], &info_len);
2096         if (CHECK(err, "errno:%d", errno)) {
2097                 err = -1;
2098                 goto done;
2099         }
2100
2101         btf_fd[1] = bpf_btf_get_fd_by_id(info[0].id);
2102         if (CHECK(btf_fd[1] == -1, "errno:%d", errno)) {
2103                 err = -1;
2104                 goto done;
2105         }
2106
2107         ret = 0;
2108         err = bpf_obj_get_info_by_fd(btf_fd[1], &info[1], &info_len);
2109         if (CHECK(err || info[0].id != info[1].id ||
2110                   info[0].btf_size != info[1].btf_size ||
2111                   (ret = memcmp(user_btf[0], user_btf[1], info[0].btf_size)),
2112                   "err:%d errno:%d id0:%u id1:%u btf_size0:%u btf_size1:%u memcmp:%d",
2113                   err, errno, info[0].id, info[1].id,
2114                   info[0].btf_size, info[1].btf_size, ret)) {
2115                 err = -1;
2116                 goto done;
2117         }
2118
2119         /* Test btf members in struct bpf_map_info */
2120         create_attr.name = "test_btf_id";
2121         create_attr.map_type = BPF_MAP_TYPE_ARRAY;
2122         create_attr.key_size = sizeof(int);
2123         create_attr.value_size = sizeof(unsigned int);
2124         create_attr.max_entries = 4;
2125         create_attr.btf_fd = btf_fd[0];
2126         create_attr.btf_key_type_id = 1;
2127         create_attr.btf_value_type_id = 2;
2128
2129         map_fd = bpf_create_map_xattr(&create_attr);
2130         if (CHECK(map_fd == -1, "errno:%d", errno)) {
2131                 err = -1;
2132                 goto done;
2133         }
2134
2135         info_len = sizeof(map_info);
2136         err = bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len);
2137         if (CHECK(err || map_info.btf_id != info[0].id ||
2138                   map_info.btf_key_type_id != 1 || map_info.btf_value_type_id != 2,
2139                   "err:%d errno:%d info.id:%u btf_id:%u btf_key_type_id:%u btf_value_type_id:%u",
2140                   err, errno, info[0].id, map_info.btf_id, map_info.btf_key_type_id,
2141                   map_info.btf_value_type_id)) {
2142                 err = -1;
2143                 goto done;
2144         }
2145
2146         for (i = 0; i < 2; i++) {
2147                 close(btf_fd[i]);
2148                 btf_fd[i] = -1;
2149         }
2150
2151         /* Test BTF ID is removed from the kernel */
2152         btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);
2153         if (CHECK(btf_fd[0] == -1, "errno:%d", errno)) {
2154                 err = -1;
2155                 goto done;
2156         }
2157         close(btf_fd[0]);
2158         btf_fd[0] = -1;
2159
2160         /* The map holds the last ref to BTF and its btf_id */
2161         close(map_fd);
2162         map_fd = -1;
2163         btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);
2164         if (CHECK(btf_fd[0] != -1, "BTF lingers")) {
2165                 err = -1;
2166                 goto done;
2167         }
2168
2169         fprintf(stderr, "OK");
2170
2171 done:
2172         if (*btf_log_buf && (err || args.always_log))
2173                 fprintf(stderr, "\n%s", btf_log_buf);
2174
2175         free(raw_btf);
2176         if (map_fd != -1)
2177                 close(map_fd);
2178         for (i = 0; i < 2; i++) {
2179                 free(user_btf[i]);
2180                 if (btf_fd[i] != -1)
2181                         close(btf_fd[i]);
2182         }
2183
2184         return err;
2185 }
2186
2187 static int do_test_get_info(unsigned int test_num)
2188 {
2189         const struct btf_get_info_test *test = &get_info_tests[test_num - 1];
2190         unsigned int raw_btf_size, user_btf_size, expected_nbytes;
2191         uint8_t *raw_btf = NULL, *user_btf = NULL;
2192         struct bpf_btf_info info = {};
2193         int btf_fd = -1, err, ret;
2194         uint32_t info_len;
2195
2196         fprintf(stderr, "BTF GET_INFO test[%u] (%s): ",
2197                 test_num, test->descr);
2198
2199         if (test->special_test)
2200                 return test->special_test(test_num);
2201
2202         raw_btf = btf_raw_create(&hdr_tmpl,
2203                                  test->raw_types,
2204                                  test->str_sec,
2205                                  test->str_sec_size,
2206                                  &raw_btf_size);
2207
2208         if (!raw_btf)
2209                 return -1;
2210
2211         *btf_log_buf = '\0';
2212
2213         user_btf = malloc(raw_btf_size);
2214         if (CHECK(!user_btf, "!user_btf")) {
2215                 err = -1;
2216                 goto done;
2217         }
2218
2219         btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
2220                               btf_log_buf, BTF_LOG_BUF_SIZE,
2221                               args.always_log);
2222         if (CHECK(btf_fd == -1, "errno:%d", errno)) {
2223                 err = -1;
2224                 goto done;
2225         }
2226
2227         user_btf_size = (int)raw_btf_size + test->btf_size_delta;
2228         expected_nbytes = min(raw_btf_size, user_btf_size);
2229         if (raw_btf_size > expected_nbytes)
2230                 memset(user_btf + expected_nbytes, 0xff,
2231                        raw_btf_size - expected_nbytes);
2232
2233         info_len = sizeof(info);
2234         info.btf = ptr_to_u64(user_btf);
2235         info.btf_size = user_btf_size;
2236
2237         ret = 0;
2238         err = bpf_obj_get_info_by_fd(btf_fd, &info, &info_len);
2239         if (CHECK(err || !info.id || info_len != sizeof(info) ||
2240                   info.btf_size != raw_btf_size ||
2241                   (ret = memcmp(raw_btf, user_btf, expected_nbytes)),
2242                   "err:%d errno:%d info.id:%u info_len:%u sizeof(info):%lu raw_btf_size:%u info.btf_size:%u expected_nbytes:%u memcmp:%d",
2243                   err, errno, info.id, info_len, sizeof(info),
2244                   raw_btf_size, info.btf_size, expected_nbytes, ret)) {
2245                 err = -1;
2246                 goto done;
2247         }
2248
2249         while (expected_nbytes < raw_btf_size) {
2250                 fprintf(stderr, "%u...", expected_nbytes);
2251                 if (CHECK(user_btf[expected_nbytes++] != 0xff,
2252                           "user_btf[%u]:%x != 0xff", expected_nbytes - 1,
2253                           user_btf[expected_nbytes - 1])) {
2254                         err = -1;
2255                         goto done;
2256                 }
2257         }
2258
2259         fprintf(stderr, "OK");
2260
2261 done:
2262         if (*btf_log_buf && (err || args.always_log))
2263                 fprintf(stderr, "\n%s", btf_log_buf);
2264
2265         free(raw_btf);
2266         free(user_btf);
2267
2268         if (btf_fd != -1)
2269                 close(btf_fd);
2270
2271         return err;
2272 }
2273
2274 static int test_get_info(void)
2275 {
2276         unsigned int i;
2277         int err = 0;
2278
2279         if (args.get_info_test_num)
2280                 return count_result(do_test_get_info(args.get_info_test_num));
2281
2282         for (i = 1; i <= ARRAY_SIZE(get_info_tests); i++)
2283                 err |= count_result(do_test_get_info(i));
2284
2285         return err;
2286 }
2287
2288 struct btf_file_test {
2289         const char *file;
2290         bool btf_kv_notfound;
2291 };
2292
2293 static struct btf_file_test file_tests[] = {
2294 {
2295         .file = "test_btf_haskv.o",
2296 },
2297 {
2298         .file = "test_btf_nokv.o",
2299         .btf_kv_notfound = true,
2300 },
2301 };
2302
2303 static int file_has_btf_elf(const char *fn)
2304 {
2305         Elf_Scn *scn = NULL;
2306         GElf_Ehdr ehdr;
2307         int elf_fd;
2308         Elf *elf;
2309         int ret;
2310
2311         if (CHECK(elf_version(EV_CURRENT) == EV_NONE,
2312                   "elf_version(EV_CURRENT) == EV_NONE"))
2313                 return -1;
2314
2315         elf_fd = open(fn, O_RDONLY);
2316         if (CHECK(elf_fd == -1, "open(%s): errno:%d", fn, errno))
2317                 return -1;
2318
2319         elf = elf_begin(elf_fd, ELF_C_READ, NULL);
2320         if (CHECK(!elf, "elf_begin(%s): %s", fn, elf_errmsg(elf_errno()))) {
2321                 ret = -1;
2322                 goto done;
2323         }
2324
2325         if (CHECK(!gelf_getehdr(elf, &ehdr), "!gelf_getehdr(%s)", fn)) {
2326                 ret = -1;
2327                 goto done;
2328         }
2329
2330         while ((scn = elf_nextscn(elf, scn))) {
2331                 const char *sh_name;
2332                 GElf_Shdr sh;
2333
2334                 if (CHECK(gelf_getshdr(scn, &sh) != &sh,
2335                           "file:%s gelf_getshdr != &sh", fn)) {
2336                         ret = -1;
2337                         goto done;
2338                 }
2339
2340                 sh_name = elf_strptr(elf, ehdr.e_shstrndx, sh.sh_name);
2341                 if (!strcmp(sh_name, BTF_ELF_SEC)) {
2342                         ret = 1;
2343                         goto done;
2344                 }
2345         }
2346
2347         ret = 0;
2348
2349 done:
2350         close(elf_fd);
2351         elf_end(elf);
2352         return ret;
2353 }
2354
2355 static int do_test_file(unsigned int test_num)
2356 {
2357         const struct btf_file_test *test = &file_tests[test_num - 1];
2358         struct bpf_object *obj = NULL;
2359         struct bpf_program *prog;
2360         struct bpf_map *map;
2361         int err;
2362
2363         fprintf(stderr, "BTF libbpf test[%u] (%s): ", test_num,
2364                 test->file);
2365
2366         err = file_has_btf_elf(test->file);
2367         if (err == -1)
2368                 return err;
2369
2370         if (err == 0) {
2371                 fprintf(stderr, "SKIP. No ELF %s found", BTF_ELF_SEC);
2372                 skip_cnt++;
2373                 return 0;
2374         }
2375
2376         obj = bpf_object__open(test->file);
2377         if (CHECK(IS_ERR(obj), "obj: %ld", PTR_ERR(obj)))
2378                 return PTR_ERR(obj);
2379
2380         err = bpf_object__btf_fd(obj);
2381         if (CHECK(err == -1, "bpf_object__btf_fd: -1"))
2382                 goto done;
2383
2384         prog = bpf_program__next(NULL, obj);
2385         if (CHECK(!prog, "Cannot find bpf_prog")) {
2386                 err = -1;
2387                 goto done;
2388         }
2389
2390         bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);
2391         err = bpf_object__load(obj);
2392         if (CHECK(err < 0, "bpf_object__load: %d", err))
2393                 goto done;
2394
2395         map = bpf_object__find_map_by_name(obj, "btf_map");
2396         if (CHECK(!map, "btf_map not found")) {
2397                 err = -1;
2398                 goto done;
2399         }
2400
2401         err = (bpf_map__btf_key_type_id(map) == 0 || bpf_map__btf_value_type_id(map) == 0)
2402                 != test->btf_kv_notfound;
2403         if (CHECK(err, "btf_key_type_id:%u btf_value_type_id:%u test->btf_kv_notfound:%u",
2404                   bpf_map__btf_key_type_id(map), bpf_map__btf_value_type_id(map),
2405                   test->btf_kv_notfound))
2406                 goto done;
2407
2408         fprintf(stderr, "OK");
2409
2410 done:
2411         bpf_object__close(obj);
2412         return err;
2413 }
2414
2415 static int test_file(void)
2416 {
2417         unsigned int i;
2418         int err = 0;
2419
2420         if (args.file_test_num)
2421                 return count_result(do_test_file(args.file_test_num));
2422
2423         for (i = 1; i <= ARRAY_SIZE(file_tests); i++)
2424                 err |= count_result(do_test_file(i));
2425
2426         return err;
2427 }
2428
2429 const char *pprint_enum_str[] = {
2430         "ENUM_ZERO",
2431         "ENUM_ONE",
2432         "ENUM_TWO",
2433         "ENUM_THREE",
2434 };
2435
2436 struct pprint_mapv {
2437         uint32_t ui32;
2438         uint16_t ui16;
2439         /* 2 bytes hole */
2440         int32_t si32;
2441         uint32_t unused_bits2a:2,
2442                 bits28:28,
2443                 unused_bits2b:2;
2444         union {
2445                 uint64_t ui64;
2446                 uint8_t ui8a[8];
2447         };
2448         enum {
2449                 ENUM_ZERO,
2450                 ENUM_ONE,
2451                 ENUM_TWO,
2452                 ENUM_THREE,
2453         } aenum;
2454 };
2455
2456 static struct btf_raw_test pprint_test_template = {
2457         .raw_types = {
2458                 /* unsighed char */                     /* [1] */
2459                 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 8, 1),
2460                 /* unsigned short */                    /* [2] */
2461                 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 16, 2),
2462                 /* unsigned int */                      /* [3] */
2463                 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 32, 4),
2464                 /* int */                               /* [4] */
2465                 BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 4),
2466                 /* unsigned long long */                /* [5] */
2467                 BTF_TYPE_INT_ENC(NAME_TBD, 0, 0, 64, 8),
2468                 /* 2 bits */                            /* [6] */
2469                 BTF_TYPE_INT_ENC(0, 0, 0, 2, 2),
2470                 /* 28 bits */                           /* [7] */
2471                 BTF_TYPE_INT_ENC(0, 0, 0, 28, 4),
2472                 /* uint8_t[8] */                        /* [8] */
2473                 BTF_TYPE_ARRAY_ENC(9, 1, 8),
2474                 /* typedef unsigned char uint8_t */     /* [9] */
2475                 BTF_TYPEDEF_ENC(NAME_TBD, 1),
2476                 /* typedef unsigned short uint16_t */   /* [10] */
2477                 BTF_TYPEDEF_ENC(NAME_TBD, 2),
2478                 /* typedef unsigned int uint32_t */     /* [11] */
2479                 BTF_TYPEDEF_ENC(NAME_TBD, 3),
2480                 /* typedef int int32_t */               /* [12] */
2481                 BTF_TYPEDEF_ENC(NAME_TBD, 4),
2482                 /* typedef unsigned long long uint64_t *//* [13] */
2483                 BTF_TYPEDEF_ENC(NAME_TBD, 5),
2484                 /* union (anon) */                      /* [14] */
2485                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_UNION, 0, 2), 8),
2486                 BTF_MEMBER_ENC(NAME_TBD, 13, 0),/* uint64_t ui64; */
2487                 BTF_MEMBER_ENC(NAME_TBD, 8, 0), /* uint8_t ui8a[8]; */
2488                 /* enum (anon) */                       /* [15] */
2489                 BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 4), 4),
2490                 BTF_ENUM_ENC(NAME_TBD, 0),
2491                 BTF_ENUM_ENC(NAME_TBD, 1),
2492                 BTF_ENUM_ENC(NAME_TBD, 2),
2493                 BTF_ENUM_ENC(NAME_TBD, 3),
2494                 /* struct pprint_mapv */                /* [16] */
2495                 BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 8), 32),
2496                 BTF_MEMBER_ENC(NAME_TBD, 11, 0),        /* uint32_t ui32 */
2497                 BTF_MEMBER_ENC(NAME_TBD, 10, 32),       /* uint16_t ui16 */
2498                 BTF_MEMBER_ENC(NAME_TBD, 12, 64),       /* int32_t si32 */
2499                 BTF_MEMBER_ENC(NAME_TBD, 6, 96),        /* unused_bits2a */
2500                 BTF_MEMBER_ENC(NAME_TBD, 7, 98),        /* bits28 */
2501                 BTF_MEMBER_ENC(NAME_TBD, 6, 126),       /* unused_bits2b */
2502                 BTF_MEMBER_ENC(0, 14, 128),             /* union (anon) */
2503                 BTF_MEMBER_ENC(NAME_TBD, 15, 192),      /* aenum */
2504                 BTF_END_RAW,
2505         },
2506         .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",
2507         .str_sec_size = sizeof("\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"),
2508         .key_size = sizeof(unsigned int),
2509         .value_size = sizeof(struct pprint_mapv),
2510         .key_type_id = 3,       /* unsigned int */
2511         .value_type_id = 16,    /* struct pprint_mapv */
2512         .max_entries = 128 * 1024,
2513 };
2514
2515 static struct btf_pprint_test_meta {
2516         const char *descr;
2517         enum bpf_map_type map_type;
2518         const char *map_name;
2519         bool ordered_map;
2520         bool lossless_map;
2521 } pprint_tests_meta[] = {
2522 {
2523         .descr = "BTF pretty print array",
2524         .map_type = BPF_MAP_TYPE_ARRAY,
2525         .map_name = "pprint_test_array",
2526         .ordered_map = true,
2527         .lossless_map = true,
2528 },
2529
2530 {
2531         .descr = "BTF pretty print hash",
2532         .map_type = BPF_MAP_TYPE_HASH,
2533         .map_name = "pprint_test_hash",
2534         .ordered_map = false,
2535         .lossless_map = true,
2536 },
2537
2538 {
2539         .descr = "BTF pretty print lru hash",
2540         .map_type = BPF_MAP_TYPE_LRU_HASH,
2541         .map_name = "pprint_test_lru_hash",
2542         .ordered_map = false,
2543         .lossless_map = false,
2544 },
2545
2546 };
2547
2548
2549 static void set_pprint_mapv(struct pprint_mapv *v, uint32_t i)
2550 {
2551         v->ui32 = i;
2552         v->si32 = -i;
2553         v->unused_bits2a = 3;
2554         v->bits28 = i;
2555         v->unused_bits2b = 3;
2556         v->ui64 = i;
2557         v->aenum = i & 0x03;
2558 }
2559
2560 static int do_test_pprint(void)
2561 {
2562         const struct btf_raw_test *test = &pprint_test_template;
2563         struct bpf_create_map_attr create_attr = {};
2564         unsigned int key, nr_read_elems;
2565         bool ordered_map, lossless_map;
2566         int map_fd = -1, btf_fd = -1;
2567         struct pprint_mapv mapv = {};
2568         unsigned int raw_btf_size;
2569         char expected_line[255];
2570         FILE *pin_file = NULL;
2571         char pin_path[255];
2572         size_t line_len = 0;
2573         char *line = NULL;
2574         uint8_t *raw_btf;
2575         ssize_t nread;
2576         int err, ret;
2577
2578         fprintf(stderr, "%s......", test->descr);
2579         raw_btf = btf_raw_create(&hdr_tmpl, test->raw_types,
2580                                  test->str_sec, test->str_sec_size,
2581                                  &raw_btf_size);
2582
2583         if (!raw_btf)
2584                 return -1;
2585
2586         *btf_log_buf = '\0';
2587         btf_fd = bpf_load_btf(raw_btf, raw_btf_size,
2588                               btf_log_buf, BTF_LOG_BUF_SIZE,
2589                               args.always_log);
2590         free(raw_btf);
2591
2592         if (CHECK(btf_fd == -1, "errno:%d", errno)) {
2593                 err = -1;
2594                 goto done;
2595         }
2596
2597         create_attr.name = test->map_name;
2598         create_attr.map_type = test->map_type;
2599         create_attr.key_size = test->key_size;
2600         create_attr.value_size = test->value_size;
2601         create_attr.max_entries = test->max_entries;
2602         create_attr.btf_fd = btf_fd;
2603         create_attr.btf_key_type_id = test->key_type_id;
2604         create_attr.btf_value_type_id = test->value_type_id;
2605
2606         map_fd = bpf_create_map_xattr(&create_attr);
2607         if (CHECK(map_fd == -1, "errno:%d", errno)) {
2608                 err = -1;
2609                 goto done;
2610         }
2611
2612         ret = snprintf(pin_path, sizeof(pin_path), "%s/%s",
2613                        "/sys/fs/bpf", test->map_name);
2614
2615         if (CHECK(ret == sizeof(pin_path), "pin_path %s/%s is too long",
2616                   "/sys/fs/bpf", test->map_name)) {
2617                 err = -1;
2618                 goto done;
2619         }
2620
2621         err = bpf_obj_pin(map_fd, pin_path);
2622         if (CHECK(err, "bpf_obj_pin(%s): errno:%d.", pin_path, errno))
2623                 goto done;
2624
2625         for (key = 0; key < test->max_entries; key++) {
2626                 set_pprint_mapv(&mapv, key);
2627                 bpf_map_update_elem(map_fd, &key, &mapv, 0);
2628         }
2629
2630         pin_file = fopen(pin_path, "r");
2631         if (CHECK(!pin_file, "fopen(%s): errno:%d", pin_path, errno)) {
2632                 err = -1;
2633                 goto done;
2634         }
2635
2636         /* Skip lines start with '#' */
2637         while ((nread = getline(&line, &line_len, pin_file)) > 0 &&
2638                *line == '#')
2639                 ;
2640
2641         if (CHECK(nread <= 0, "Unexpected EOF")) {
2642                 err = -1;
2643                 goto done;
2644         }
2645
2646         nr_read_elems = 0;
2647         ordered_map = test->ordered_map;
2648         lossless_map = test->lossless_map;
2649         do {
2650                 ssize_t nexpected_line;
2651                 unsigned int next_key;
2652
2653                 next_key = ordered_map ? nr_read_elems : atoi(line);
2654                 set_pprint_mapv(&mapv, next_key);
2655                 nexpected_line = snprintf(expected_line, sizeof(expected_line),
2656                                           "%u: {%u,0,%d,0x%x,0x%x,0x%x,{%lu|[%u,%u,%u,%u,%u,%u,%u,%u]},%s}\n",
2657                                           next_key,
2658                                           mapv.ui32, mapv.si32,
2659                                           mapv.unused_bits2a, mapv.bits28, mapv.unused_bits2b,
2660                                           mapv.ui64,
2661                                           mapv.ui8a[0], mapv.ui8a[1], mapv.ui8a[2], mapv.ui8a[3],
2662                                           mapv.ui8a[4], mapv.ui8a[5], mapv.ui8a[6], mapv.ui8a[7],
2663                                           pprint_enum_str[mapv.aenum]);
2664
2665                 if (CHECK(nexpected_line == sizeof(expected_line),
2666                           "expected_line is too long")) {
2667                         err = -1;
2668                         goto done;
2669                 }
2670
2671                 if (strcmp(expected_line, line)) {
2672                         err = -1;
2673                         fprintf(stderr, "unexpected pprint output\n");
2674                         fprintf(stderr, "expected: %s", expected_line);
2675                         fprintf(stderr, "    read: %s", line);
2676                         goto done;
2677                 }
2678
2679                 nread = getline(&line, &line_len, pin_file);
2680         } while (++nr_read_elems < test->max_entries && nread > 0);
2681
2682         if (lossless_map &&
2683             CHECK(nr_read_elems < test->max_entries,
2684                   "Unexpected EOF. nr_read_elems:%u test->max_entries:%u",
2685                   nr_read_elems, test->max_entries)) {
2686                 err = -1;
2687                 goto done;
2688         }
2689
2690         if (CHECK(nread > 0, "Unexpected extra pprint output: %s", line)) {
2691                 err = -1;
2692                 goto done;
2693         }
2694
2695         err = 0;
2696
2697 done:
2698         if (!err)
2699                 fprintf(stderr, "OK");
2700         if (*btf_log_buf && (err || args.always_log))
2701                 fprintf(stderr, "\n%s", btf_log_buf);
2702         if (btf_fd != -1)
2703                 close(btf_fd);
2704         if (map_fd != -1)
2705                 close(map_fd);
2706         if (pin_file)
2707                 fclose(pin_file);
2708         unlink(pin_path);
2709         free(line);
2710
2711         return err;
2712 }
2713
2714 static int test_pprint(void)
2715 {
2716         unsigned int i;
2717         int err = 0;
2718
2719         for (i = 0; i < ARRAY_SIZE(pprint_tests_meta); i++) {
2720                 pprint_test_template.descr = pprint_tests_meta[i].descr;
2721                 pprint_test_template.map_type = pprint_tests_meta[i].map_type;
2722                 pprint_test_template.map_name = pprint_tests_meta[i].map_name;
2723                 pprint_test_template.ordered_map = pprint_tests_meta[i].ordered_map;
2724                 pprint_test_template.lossless_map = pprint_tests_meta[i].lossless_map;
2725
2726                 err |= count_result(do_test_pprint());
2727         }
2728
2729         return err;
2730 }
2731
2732 static void usage(const char *cmd)
2733 {
2734         fprintf(stderr, "Usage: %s [-l] [[-r test_num (1 - %zu)] | [-g test_num (1 - %zu)] | [-f test_num (1 - %zu)] | [-p]]\n",
2735                 cmd, ARRAY_SIZE(raw_tests), ARRAY_SIZE(get_info_tests),
2736                 ARRAY_SIZE(file_tests));
2737 }
2738
2739 static int parse_args(int argc, char **argv)
2740 {
2741         const char *optstr = "lpf:r:g:";
2742         int opt;
2743
2744         while ((opt = getopt(argc, argv, optstr)) != -1) {
2745                 switch (opt) {
2746                 case 'l':
2747                         args.always_log = true;
2748                         break;
2749                 case 'f':
2750                         args.file_test_num = atoi(optarg);
2751                         args.file_test = true;
2752                         break;
2753                 case 'r':
2754                         args.raw_test_num = atoi(optarg);
2755                         args.raw_test = true;
2756                         break;
2757                 case 'g':
2758                         args.get_info_test_num = atoi(optarg);
2759                         args.get_info_test = true;
2760                         break;
2761                 case 'p':
2762                         args.pprint_test = true;
2763                         break;
2764                 case 'h':
2765                         usage(argv[0]);
2766                         exit(0);
2767                 default:
2768                                 usage(argv[0]);
2769                                 return -1;
2770                 }
2771         }
2772
2773         if (args.raw_test_num &&
2774             (args.raw_test_num < 1 ||
2775              args.raw_test_num > ARRAY_SIZE(raw_tests))) {
2776                 fprintf(stderr, "BTF raw test number must be [1 - %zu]\n",
2777                         ARRAY_SIZE(raw_tests));
2778                 return -1;
2779         }
2780
2781         if (args.file_test_num &&
2782             (args.file_test_num < 1 ||
2783              args.file_test_num > ARRAY_SIZE(file_tests))) {
2784                 fprintf(stderr, "BTF file test number must be [1 - %zu]\n",
2785                         ARRAY_SIZE(file_tests));
2786                 return -1;
2787         }
2788
2789         if (args.get_info_test_num &&
2790             (args.get_info_test_num < 1 ||
2791              args.get_info_test_num > ARRAY_SIZE(get_info_tests))) {
2792                 fprintf(stderr, "BTF get info test number must be [1 - %zu]\n",
2793                         ARRAY_SIZE(get_info_tests));
2794                 return -1;
2795         }
2796
2797         return 0;
2798 }
2799
2800 static void print_summary(void)
2801 {
2802         fprintf(stderr, "PASS:%u SKIP:%u FAIL:%u\n",
2803                 pass_cnt - skip_cnt, skip_cnt, error_cnt);
2804 }
2805
2806 int main(int argc, char **argv)
2807 {
2808         int err = 0;
2809
2810         err = parse_args(argc, argv);
2811         if (err)
2812                 return err;
2813
2814         if (args.always_log)
2815                 libbpf_set_print(__base_pr, __base_pr, __base_pr);
2816
2817         if (args.raw_test)
2818                 err |= test_raw();
2819
2820         if (args.get_info_test)
2821                 err |= test_get_info();
2822
2823         if (args.file_test)
2824                 err |= test_file();
2825
2826         if (args.pprint_test)
2827                 err |= test_pprint();
2828
2829         if (args.raw_test || args.get_info_test || args.file_test ||
2830             args.pprint_test)
2831                 goto done;
2832
2833         err |= test_raw();
2834         err |= test_get_info();
2835         err |= test_file();
2836
2837 done:
2838         print_summary();
2839         return err;
2840 }