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