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