tools/testing/selftests/bpf/progs/map_ptr_kern.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2020 Facebook
   3
   4 #include <linux/bpf.h>
   5 #include <bpf/bpf_helpers.h>
   6
   7 #define LOOP_BOUND 0xf
   8 #define MAX_ENTRIES 8
   9 #define HALF_ENTRIES (MAX_ENTRIES >> 1)
  10
  11 _Static_assert(MAX_ENTRIES < LOOP_BOUND, "MAX_ENTRIES must be < LOOP_BOUND");
  12
  13 enum bpf_map_type g_map_type = BPF_MAP_TYPE_UNSPEC;
  14 __u32 g_line = 0;
  15 int page_size = 0; /* userspace should set it */
  16
  17 #define VERIFY_TYPE(type, func) ({      \
  18         g_map_type = type;              \
  19         if (!func())                    \
  20                 return 0;               \
  21 })
  22
  23
  24 #define VERIFY(expr) ({         \
  25         g_line = __LINE__;      \
  26         if (!(expr))            \
  27                 return 0;       \
  28 })
  29
  30 struct bpf_map {
  31         enum bpf_map_type map_type;
  32         __u32 key_size;
  33         __u32 value_size;
  34         __u32 max_entries;
  35         __u32 id;
  36 } __attribute__((preserve_access_index));
  37
  38 static inline int check_bpf_map_fields(struct bpf_map *map, __u32 key_size,
  39                                        __u32 value_size, __u32 max_entries)
  40 {
  41         VERIFY(map->map_type == g_map_type);
  42         VERIFY(map->key_size == key_size);
  43         VERIFY(map->value_size == value_size);
  44         VERIFY(map->max_entries == max_entries);
  45         VERIFY(map->id > 0);
  46
  47         return 1;
  48 }
  49
  50 static inline int check_bpf_map_ptr(struct bpf_map *indirect,
  51                                     struct bpf_map *direct)
  52 {
  53         VERIFY(indirect->map_type == direct->map_type);
  54         VERIFY(indirect->key_size == direct->key_size);
  55         VERIFY(indirect->value_size == direct->value_size);
  56         VERIFY(indirect->max_entries == direct->max_entries);
  57         VERIFY(indirect->id == direct->id);
  58
  59         return 1;
  60 }
  61
  62 static inline int check(struct bpf_map *indirect, struct bpf_map *direct,
  63                         __u32 key_size, __u32 value_size, __u32 max_entries)
  64 {
  65         VERIFY(check_bpf_map_ptr(indirect, direct));
  66         VERIFY(check_bpf_map_fields(indirect, key_size, value_size,
  67                                     max_entries));
  68         return 1;
  69 }
  70
  71 static inline int check_default(struct bpf_map *indirect,
  72                                 struct bpf_map *direct)
  73 {
  74         VERIFY(check(indirect, direct, sizeof(__u32), sizeof(__u32),
  75                      MAX_ENTRIES));
  76         return 1;
  77 }
  78
  79 static __noinline int
  80 check_default_noinline(struct bpf_map *indirect, struct bpf_map *direct)
  81 {
  82         VERIFY(check(indirect, direct, sizeof(__u32), sizeof(__u32),
  83                      MAX_ENTRIES));
  84         return 1;
  85 }
  86
  87 typedef struct {
  88         int counter;
  89 } atomic_t;
  90
  91 struct bpf_htab {
  92         struct bpf_map map;
  93         atomic_t count;
  94         __u32 n_buckets;
  95         __u32 elem_size;
  96 } __attribute__((preserve_access_index));
  97
  98 struct {
  99         __uint(type, BPF_MAP_TYPE_HASH);
 100         __uint(map_flags, BPF_F_NO_PREALLOC); /* to test bpf_htab.count */
 101         __uint(max_entries, MAX_ENTRIES);
 102         __type(key, __u32);
 103         __type(value, __u32);
 104 } m_hash SEC(".maps");
 105
 106 __s64 bpf_map_sum_elem_count(struct bpf_map *map) __ksym;
 107
 108 static inline int check_hash(void)
 109 {
 110         struct bpf_htab *hash = (struct bpf_htab *)&m_hash;
 111         struct bpf_map *map = (struct bpf_map *)&m_hash;
 112         int i;
 113
 114         VERIFY(check_default_noinline(&hash->map, map));
 115
 116         VERIFY(hash->n_buckets == MAX_ENTRIES);
 117         VERIFY(hash->elem_size == 64);
 118
 119         VERIFY(hash->count.counter == 0);
 120         VERIFY(bpf_map_sum_elem_count(map) == 0);
 121
 122         for (i = 0; i < HALF_ENTRIES; ++i) {
 123                 const __u32 key = i;
 124                 const __u32 val = 1;
 125
 126                 if (bpf_map_update_elem(hash, &key, &val, 0))
 127                         return 0;
 128         }
 129         VERIFY(hash->count.counter == HALF_ENTRIES);
 130         VERIFY(bpf_map_sum_elem_count(map) == HALF_ENTRIES);
 131
 132         return 1;
 133 }
 134
 135 struct bpf_array {
 136         struct bpf_map map;
 137         __u32 elem_size;
 138 } __attribute__((preserve_access_index));
 139
 140 struct {
 141         __uint(type, BPF_MAP_TYPE_ARRAY);
 142         __uint(max_entries, MAX_ENTRIES);
 143         __type(key, __u32);
 144         __type(value, __u32);
 145 } m_array SEC(".maps");
 146
 147 static inline int check_array(void)
 148 {
 149         struct bpf_array *array = (struct bpf_array *)&m_array;
 150         struct bpf_map *map = (struct bpf_map *)&m_array;
 151         int i, n_lookups = 0, n_keys = 0;
 152
 153         VERIFY(check_default(&array->map, map));
 154
 155         VERIFY(array->elem_size == 8);
 156
 157         for (i = 0; i < array->map.max_entries && i < LOOP_BOUND; ++i) {
 158                 const __u32 key = i;
 159                 __u32 *val = bpf_map_lookup_elem(array, &key);
 160
 161                 ++n_lookups;
 162                 if (val)
 163                         ++n_keys;
 164         }
 165
 166         VERIFY(n_lookups == MAX_ENTRIES);
 167         VERIFY(n_keys == MAX_ENTRIES);
 168
 169         return 1;
 170 }
 171
 172 struct {
 173         __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
 174         __uint(max_entries, MAX_ENTRIES);
 175         __type(key, __u32);
 176         __type(value, __u32);
 177 } m_prog_array SEC(".maps");
 178
 179 static inline int check_prog_array(void)
 180 {
 181         struct bpf_array *prog_array = (struct bpf_array *)&m_prog_array;
 182         struct bpf_map *map = (struct bpf_map *)&m_prog_array;
 183
 184         VERIFY(check_default(&prog_array->map, map));
 185
 186         return 1;
 187 }
 188
 189 struct {
 190         __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
 191         __uint(max_entries, MAX_ENTRIES);
 192         __type(key, __u32);
 193         __type(value, __u32);
 194 } m_perf_event_array SEC(".maps");
 195
 196 static inline int check_perf_event_array(void)
 197 {
 198         struct bpf_array *perf_event_array = (struct bpf_array *)&m_perf_event_array;
 199         struct bpf_map *map = (struct bpf_map *)&m_perf_event_array;
 200
 201         VERIFY(check_default(&perf_event_array->map, map));
 202
 203         return 1;
 204 }
 205
 206 struct {
 207         __uint(type, BPF_MAP_TYPE_PERCPU_HASH);
 208         __uint(max_entries, MAX_ENTRIES);
 209         __type(key, __u32);
 210         __type(value, __u32);
 211 } m_percpu_hash SEC(".maps");
 212
 213 static inline int check_percpu_hash(void)
 214 {
 215         struct bpf_htab *percpu_hash = (struct bpf_htab *)&m_percpu_hash;
 216         struct bpf_map *map = (struct bpf_map *)&m_percpu_hash;
 217
 218         VERIFY(check_default(&percpu_hash->map, map));
 219
 220         return 1;
 221 }
 222
 223 struct {
 224         __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
 225         __uint(max_entries, MAX_ENTRIES);
 226         __type(key, __u32);
 227         __type(value, __u32);
 228 } m_percpu_array SEC(".maps");
 229
 230 static inline int check_percpu_array(void)
 231 {
 232         struct bpf_array *percpu_array = (struct bpf_array *)&m_percpu_array;
 233         struct bpf_map *map = (struct bpf_map *)&m_percpu_array;
 234
 235         VERIFY(check_default(&percpu_array->map, map));
 236
 237         return 1;
 238 }
 239
 240 struct bpf_stack_map {
 241         struct bpf_map map;
 242 } __attribute__((preserve_access_index));
 243
 244 struct {
 245         __uint(type, BPF_MAP_TYPE_STACK_TRACE);
 246         __uint(max_entries, MAX_ENTRIES);
 247         __type(key, __u32);
 248         __type(value, __u64);
 249 } m_stack_trace SEC(".maps");
 250
 251 static inline int check_stack_trace(void)
 252 {
 253         struct bpf_stack_map *stack_trace =
 254                 (struct bpf_stack_map *)&m_stack_trace;
 255         struct bpf_map *map = (struct bpf_map *)&m_stack_trace;
 256
 257         VERIFY(check(&stack_trace->map, map, sizeof(__u32), sizeof(__u64),
 258                      MAX_ENTRIES));
 259
 260         return 1;
 261 }
 262
 263 struct {
 264         __uint(type, BPF_MAP_TYPE_CGROUP_ARRAY);
 265         __uint(max_entries, MAX_ENTRIES);
 266         __type(key, __u32);
 267         __type(value, __u32);
 268 } m_cgroup_array SEC(".maps");
 269
 270 static inline int check_cgroup_array(void)
 271 {
 272         struct bpf_array *cgroup_array = (struct bpf_array *)&m_cgroup_array;
 273         struct bpf_map *map = (struct bpf_map *)&m_cgroup_array;
 274
 275         VERIFY(check_default(&cgroup_array->map, map));
 276
 277         return 1;
 278 }
 279
 280 struct {
 281         __uint(type, BPF_MAP_TYPE_LRU_HASH);
 282         __uint(max_entries, MAX_ENTRIES);
 283         __type(key, __u32);
 284         __type(value, __u32);
 285 } m_lru_hash SEC(".maps");
 286
 287 static inline int check_lru_hash(void)
 288 {
 289         struct bpf_htab *lru_hash = (struct bpf_htab *)&m_lru_hash;
 290         struct bpf_map *map = (struct bpf_map *)&m_lru_hash;
 291
 292         VERIFY(check_default(&lru_hash->map, map));
 293
 294         return 1;
 295 }
 296
 297 struct {
 298         __uint(type, BPF_MAP_TYPE_LRU_PERCPU_HASH);
 299         __uint(max_entries, MAX_ENTRIES);
 300         __type(key, __u32);
 301         __type(value, __u32);
 302 } m_lru_percpu_hash SEC(".maps");
 303
 304 static inline int check_lru_percpu_hash(void)
 305 {
 306         struct bpf_htab *lru_percpu_hash = (struct bpf_htab *)&m_lru_percpu_hash;
 307         struct bpf_map *map = (struct bpf_map *)&m_lru_percpu_hash;
 308
 309         VERIFY(check_default(&lru_percpu_hash->map, map));
 310
 311         return 1;
 312 }
 313
 314 struct lpm_trie {
 315         struct bpf_map map;
 316 } __attribute__((preserve_access_index));
 317
 318 struct lpm_key {
 319         struct bpf_lpm_trie_key_hdr trie_key;
 320         __u32 data;
 321 };
 322
 323 struct {
 324         __uint(type, BPF_MAP_TYPE_LPM_TRIE);
 325         __uint(map_flags, BPF_F_NO_PREALLOC);
 326         __uint(max_entries, MAX_ENTRIES);
 327         __type(key, struct lpm_key);
 328         __type(value, __u32);
 329 } m_lpm_trie SEC(".maps");
 330
 331 static inline int check_lpm_trie(void)
 332 {
 333         struct lpm_trie *lpm_trie = (struct lpm_trie *)&m_lpm_trie;
 334         struct bpf_map *map = (struct bpf_map *)&m_lpm_trie;
 335
 336         VERIFY(check(&lpm_trie->map, map, sizeof(struct lpm_key), sizeof(__u32),
 337                      MAX_ENTRIES));
 338
 339         return 1;
 340 }
 341
 342 #define INNER_MAX_ENTRIES 1234
 343
 344 struct inner_map {
 345         __uint(type, BPF_MAP_TYPE_ARRAY);
 346         __uint(max_entries, INNER_MAX_ENTRIES);
 347         __type(key, __u32);
 348         __type(value, __u32);
 349 } inner_map SEC(".maps");
 350
 351 struct {
 352         __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
 353         __uint(max_entries, MAX_ENTRIES);
 354         __type(key, __u32);
 355         __type(value, __u32);
 356         __array(values, struct {
 357                 __uint(type, BPF_MAP_TYPE_ARRAY);
 358                 __uint(max_entries, INNER_MAX_ENTRIES);
 359                 __type(key, __u32);
 360                 __type(value, __u32);
 361         });
 362 } m_array_of_maps SEC(".maps") = {
 363         .values = { (void *)&inner_map, 0, 0, 0, 0, 0, 0, 0, 0 },
 364 };
 365
 366 static inline int check_array_of_maps(void)
 367 {
 368         struct bpf_array *array_of_maps = (struct bpf_array *)&m_array_of_maps;
 369         struct bpf_map *map = (struct bpf_map *)&m_array_of_maps;
 370         struct bpf_array *inner_map;
 371         int key = 0;
 372
 373         VERIFY(check_default(&array_of_maps->map, map));
 374         inner_map = bpf_map_lookup_elem(array_of_maps, &key);
 375         VERIFY(inner_map != NULL);
 376         VERIFY(inner_map->map.max_entries == INNER_MAX_ENTRIES);
 377
 378         return 1;
 379 }
 380
 381 struct {
 382         __uint(type, BPF_MAP_TYPE_HASH_OF_MAPS);
 383         __uint(max_entries, MAX_ENTRIES);
 384         __type(key, __u32);
 385         __type(value, __u32);
 386         __array(values, struct inner_map);
 387 } m_hash_of_maps SEC(".maps") = {
 388         .values = {
 389                 [2] = &inner_map,
 390         },
 391 };
 392
 393 static inline int check_hash_of_maps(void)
 394 {
 395         struct bpf_htab *hash_of_maps = (struct bpf_htab *)&m_hash_of_maps;
 396         struct bpf_map *map = (struct bpf_map *)&m_hash_of_maps;
 397         struct bpf_htab *inner_map;
 398         int key = 2;
 399
 400         VERIFY(check_default(&hash_of_maps->map, map));
 401         inner_map = bpf_map_lookup_elem(hash_of_maps, &key);
 402         VERIFY(inner_map != NULL);
 403         VERIFY(inner_map->map.max_entries == INNER_MAX_ENTRIES);
 404
 405         return 1;
 406 }
 407
 408 struct bpf_dtab {
 409         struct bpf_map map;
 410 } __attribute__((preserve_access_index));
 411
 412 struct {
 413         __uint(type, BPF_MAP_TYPE_DEVMAP);
 414         __uint(max_entries, MAX_ENTRIES);
 415         __type(key, __u32);
 416         __type(value, __u32);
 417 } m_devmap SEC(".maps");
 418
 419 static inline int check_devmap(void)
 420 {
 421         struct bpf_dtab *devmap = (struct bpf_dtab *)&m_devmap;
 422         struct bpf_map *map = (struct bpf_map *)&m_devmap;
 423
 424         VERIFY(check_default(&devmap->map, map));
 425
 426         return 1;
 427 }
 428
 429 struct bpf_stab {
 430         struct bpf_map map;
 431 } __attribute__((preserve_access_index));
 432
 433 struct {
 434         __uint(type, BPF_MAP_TYPE_SOCKMAP);
 435         __uint(max_entries, MAX_ENTRIES);
 436         __type(key, __u32);
 437         __type(value, __u32);
 438 } m_sockmap SEC(".maps");
 439
 440 static inline int check_sockmap(void)
 441 {
 442         struct bpf_stab *sockmap = (struct bpf_stab *)&m_sockmap;
 443         struct bpf_map *map = (struct bpf_map *)&m_sockmap;
 444
 445         VERIFY(check_default(&sockmap->map, map));
 446
 447         return 1;
 448 }
 449
 450 struct bpf_cpu_map {
 451         struct bpf_map map;
 452 } __attribute__((preserve_access_index));
 453
 454 struct {
 455         __uint(type, BPF_MAP_TYPE_CPUMAP);
 456         __uint(max_entries, MAX_ENTRIES);
 457         __type(key, __u32);
 458         __type(value, __u32);
 459 } m_cpumap SEC(".maps");
 460
 461 static inline int check_cpumap(void)
 462 {
 463         struct bpf_cpu_map *cpumap = (struct bpf_cpu_map *)&m_cpumap;
 464         struct bpf_map *map = (struct bpf_map *)&m_cpumap;
 465
 466         VERIFY(check_default(&cpumap->map, map));
 467
 468         return 1;
 469 }
 470
 471 struct xsk_map {
 472         struct bpf_map map;
 473 } __attribute__((preserve_access_index));
 474
 475 struct {
 476         __uint(type, BPF_MAP_TYPE_XSKMAP);
 477         __uint(max_entries, MAX_ENTRIES);
 478         __type(key, __u32);
 479         __type(value, __u32);
 480 } m_xskmap SEC(".maps");
 481
 482 static inline int check_xskmap(void)
 483 {
 484         struct xsk_map *xskmap = (struct xsk_map *)&m_xskmap;
 485         struct bpf_map *map = (struct bpf_map *)&m_xskmap;
 486
 487         VERIFY(check_default(&xskmap->map, map));
 488
 489         return 1;
 490 }
 491
 492 struct bpf_shtab {
 493         struct bpf_map map;
 494 } __attribute__((preserve_access_index));
 495
 496 struct {
 497         __uint(type, BPF_MAP_TYPE_SOCKHASH);
 498         __uint(max_entries, MAX_ENTRIES);
 499         __type(key, __u32);
 500         __type(value, __u32);
 501 } m_sockhash SEC(".maps");
 502
 503 static inline int check_sockhash(void)
 504 {
 505         struct bpf_shtab *sockhash = (struct bpf_shtab *)&m_sockhash;
 506         struct bpf_map *map = (struct bpf_map *)&m_sockhash;
 507
 508         VERIFY(check_default(&sockhash->map, map));
 509
 510         return 1;
 511 }
 512
 513 struct bpf_cgroup_storage_map {
 514         struct bpf_map map;
 515 } __attribute__((preserve_access_index));
 516
 517 struct {
 518         __uint(type, BPF_MAP_TYPE_CGROUP_STORAGE);
 519         __type(key, struct bpf_cgroup_storage_key);
 520         __type(value, __u32);
 521 } m_cgroup_storage SEC(".maps");
 522
 523 static inline int check_cgroup_storage(void)
 524 {
 525         struct bpf_cgroup_storage_map *cgroup_storage =
 526                 (struct bpf_cgroup_storage_map *)&m_cgroup_storage;
 527         struct bpf_map *map = (struct bpf_map *)&m_cgroup_storage;
 528
 529         VERIFY(check(&cgroup_storage->map, map,
 530                      sizeof(struct bpf_cgroup_storage_key), sizeof(__u32), 0));
 531
 532         return 1;
 533 }
 534
 535 struct reuseport_array {
 536         struct bpf_map map;
 537 } __attribute__((preserve_access_index));
 538
 539 struct {
 540         __uint(type, BPF_MAP_TYPE_REUSEPORT_SOCKARRAY);
 541         __uint(max_entries, MAX_ENTRIES);
 542         __type(key, __u32);
 543         __type(value, __u32);
 544 } m_reuseport_sockarray SEC(".maps");
 545
 546 static inline int check_reuseport_sockarray(void)
 547 {
 548         struct reuseport_array *reuseport_sockarray =
 549                 (struct reuseport_array *)&m_reuseport_sockarray;
 550         struct bpf_map *map = (struct bpf_map *)&m_reuseport_sockarray;
 551
 552         VERIFY(check_default(&reuseport_sockarray->map, map));
 553
 554         return 1;
 555 }
 556
 557 struct {
 558         __uint(type, BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE);
 559         __type(key, struct bpf_cgroup_storage_key);
 560         __type(value, __u32);
 561 } m_percpu_cgroup_storage SEC(".maps");
 562
 563 static inline int check_percpu_cgroup_storage(void)
 564 {
 565         struct bpf_cgroup_storage_map *percpu_cgroup_storage =
 566                 (struct bpf_cgroup_storage_map *)&m_percpu_cgroup_storage;
 567         struct bpf_map *map = (struct bpf_map *)&m_percpu_cgroup_storage;
 568
 569         VERIFY(check(&percpu_cgroup_storage->map, map,
 570                      sizeof(struct bpf_cgroup_storage_key), sizeof(__u32), 0));
 571
 572         return 1;
 573 }
 574
 575 struct bpf_queue_stack {
 576         struct bpf_map map;
 577 } __attribute__((preserve_access_index));
 578
 579 struct {
 580         __uint(type, BPF_MAP_TYPE_QUEUE);
 581         __uint(max_entries, MAX_ENTRIES);
 582         __type(value, __u32);
 583 } m_queue SEC(".maps");
 584
 585 static inline int check_queue(void)
 586 {
 587         struct bpf_queue_stack *queue = (struct bpf_queue_stack *)&m_queue;
 588         struct bpf_map *map = (struct bpf_map *)&m_queue;
 589
 590         VERIFY(check(&queue->map, map, 0, sizeof(__u32), MAX_ENTRIES));
 591
 592         return 1;
 593 }
 594
 595 struct {
 596         __uint(type, BPF_MAP_TYPE_STACK);
 597         __uint(max_entries, MAX_ENTRIES);
 598         __type(value, __u32);
 599 } m_stack SEC(".maps");
 600
 601 static inline int check_stack(void)
 602 {
 603         struct bpf_queue_stack *stack = (struct bpf_queue_stack *)&m_stack;
 604         struct bpf_map *map = (struct bpf_map *)&m_stack;
 605
 606         VERIFY(check(&stack->map, map, 0, sizeof(__u32), MAX_ENTRIES));
 607
 608         return 1;
 609 }
 610
 611 struct bpf_local_storage_map {
 612         struct bpf_map map;
 613 } __attribute__((preserve_access_index));
 614
 615 struct {
 616         __uint(type, BPF_MAP_TYPE_SK_STORAGE);
 617         __uint(map_flags, BPF_F_NO_PREALLOC);
 618         __type(key, __u32);
 619         __type(value, __u32);
 620 } m_sk_storage SEC(".maps");
 621
 622 static inline int check_sk_storage(void)
 623 {
 624         struct bpf_local_storage_map *sk_storage =
 625                 (struct bpf_local_storage_map *)&m_sk_storage;
 626         struct bpf_map *map = (struct bpf_map *)&m_sk_storage;
 627
 628         VERIFY(check(&sk_storage->map, map, sizeof(__u32), sizeof(__u32), 0));
 629
 630         return 1;
 631 }
 632
 633 struct {
 634         __uint(type, BPF_MAP_TYPE_DEVMAP_HASH);
 635         __uint(max_entries, MAX_ENTRIES);
 636         __type(key, __u32);
 637         __type(value, __u32);
 638 } m_devmap_hash SEC(".maps");
 639
 640 static inline int check_devmap_hash(void)
 641 {
 642         struct bpf_dtab *devmap_hash = (struct bpf_dtab *)&m_devmap_hash;
 643         struct bpf_map *map = (struct bpf_map *)&m_devmap_hash;
 644
 645         VERIFY(check_default(&devmap_hash->map, map));
 646
 647         return 1;
 648 }
 649
 650 struct bpf_ringbuf_map {
 651         struct bpf_map map;
 652 } __attribute__((preserve_access_index));
 653
 654 struct {
 655         __uint(type, BPF_MAP_TYPE_RINGBUF);
 656 } m_ringbuf SEC(".maps");
 657
 658 static inline int check_ringbuf(void)
 659 {
 660         struct bpf_ringbuf_map *ringbuf = (struct bpf_ringbuf_map *)&m_ringbuf;
 661         struct bpf_map *map = (struct bpf_map *)&m_ringbuf;
 662
 663         VERIFY(check(&ringbuf->map, map, 0, 0, page_size));
 664
 665         return 1;
 666 }
 667
 668 SEC("cgroup_skb/egress")
 669 int cg_skb(void *ctx)
 670 {
 671         VERIFY_TYPE(BPF_MAP_TYPE_HASH, check_hash);
 672         VERIFY_TYPE(BPF_MAP_TYPE_ARRAY, check_array);
 673         VERIFY_TYPE(BPF_MAP_TYPE_PROG_ARRAY, check_prog_array);
 674         VERIFY_TYPE(BPF_MAP_TYPE_PERF_EVENT_ARRAY, check_perf_event_array);
 675         VERIFY_TYPE(BPF_MAP_TYPE_PERCPU_HASH, check_percpu_hash);
 676         VERIFY_TYPE(BPF_MAP_TYPE_PERCPU_ARRAY, check_percpu_array);
 677         VERIFY_TYPE(BPF_MAP_TYPE_STACK_TRACE, check_stack_trace);
 678         VERIFY_TYPE(BPF_MAP_TYPE_CGROUP_ARRAY, check_cgroup_array);
 679         VERIFY_TYPE(BPF_MAP_TYPE_LRU_HASH, check_lru_hash);
 680         VERIFY_TYPE(BPF_MAP_TYPE_LRU_PERCPU_HASH, check_lru_percpu_hash);
 681         VERIFY_TYPE(BPF_MAP_TYPE_LPM_TRIE, check_lpm_trie);
 682         VERIFY_TYPE(BPF_MAP_TYPE_ARRAY_OF_MAPS, check_array_of_maps);
 683         VERIFY_TYPE(BPF_MAP_TYPE_HASH_OF_MAPS, check_hash_of_maps);
 684         VERIFY_TYPE(BPF_MAP_TYPE_DEVMAP, check_devmap);
 685         VERIFY_TYPE(BPF_MAP_TYPE_SOCKMAP, check_sockmap);
 686         VERIFY_TYPE(BPF_MAP_TYPE_CPUMAP, check_cpumap);
 687         VERIFY_TYPE(BPF_MAP_TYPE_XSKMAP, check_xskmap);
 688         VERIFY_TYPE(BPF_MAP_TYPE_SOCKHASH, check_sockhash);
 689         VERIFY_TYPE(BPF_MAP_TYPE_CGROUP_STORAGE, check_cgroup_storage);
 690         VERIFY_TYPE(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
 691                     check_reuseport_sockarray);
 692         VERIFY_TYPE(BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE,
 693                     check_percpu_cgroup_storage);
 694         VERIFY_TYPE(BPF_MAP_TYPE_QUEUE, check_queue);
 695         VERIFY_TYPE(BPF_MAP_TYPE_STACK, check_stack);
 696         VERIFY_TYPE(BPF_MAP_TYPE_SK_STORAGE, check_sk_storage);
 697         VERIFY_TYPE(BPF_MAP_TYPE_DEVMAP_HASH, check_devmap_hash);
 698         VERIFY_TYPE(BPF_MAP_TYPE_RINGBUF, check_ringbuf);
 699
 700         return 1;
 701 }
 702
 703 char _license[] SEC("license") = "GPL";