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