1
2
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
13enum bpf_map_type g_map_type = BPF_MAP_TYPE_UNSPEC;
14__u32 g_line = 0;
15int page_size = 0;
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
30struct 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
38static 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
50static 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
62static 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
71static 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
79static __noinline int
80check_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
87typedef struct {
88 int counter;
89} atomic_t;
90
91struct 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
98struct {
99 __uint(type, BPF_MAP_TYPE_HASH);
100 __uint(map_flags, BPF_F_NO_PREALLOC);
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
108static 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
135struct bpf_array {
136 struct bpf_map map;
137 __u32 elem_size;
138} __attribute__((preserve_access_index));
139
140struct {
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
147static 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
172struct {
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
179static 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
189struct {
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
196static 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
206struct {
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
213static 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
223struct {
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
230static 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
240struct bpf_stack_map {
241 struct bpf_map map;
242} __attribute__((preserve_access_index));
243
244struct {
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
251static 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
263struct {
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
270static 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
280struct {
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
287static 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
297struct {
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
304static 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
314struct lpm_trie {
315 struct bpf_map map;
316} __attribute__((preserve_access_index));
317
318struct lpm_key {
319 struct bpf_lpm_trie_key_hdr trie_key;
320 __u32 data;
321};
322
323struct {
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
331static 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
344struct 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
351struct {
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
366static 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
381struct {
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
393static 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
408struct bpf_dtab {
409 struct bpf_map map;
410} __attribute__((preserve_access_index));
411
412struct {
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
419static 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
429struct bpf_stab {
430 struct bpf_map map;
431} __attribute__((preserve_access_index));
432
433struct {
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
440static 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
450struct bpf_cpu_map {
451 struct bpf_map map;
452} __attribute__((preserve_access_index));
453
454struct {
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
461static 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
471struct xsk_map {
472 struct bpf_map map;
473} __attribute__((preserve_access_index));
474
475struct {
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
482static 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
492struct bpf_shtab {
493 struct bpf_map map;
494} __attribute__((preserve_access_index));
495
496struct {
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
503static 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
513struct bpf_cgroup_storage_map {
514 struct bpf_map map;
515} __attribute__((preserve_access_index));
516
517struct {
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
523static 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
535struct reuseport_array {
536 struct bpf_map map;
537} __attribute__((preserve_access_index));
538
539struct {
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
546static 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
557struct {
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
563static 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
575struct bpf_queue_stack {
576 struct bpf_map map;
577} __attribute__((preserve_access_index));
578
579struct {
580 __uint(type, BPF_MAP_TYPE_QUEUE);
581 __uint(max_entries, MAX_ENTRIES);
582 __type(value, __u32);
583} m_queue SEC(".maps");
584
585static 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
595struct {
596 __uint(type, BPF_MAP_TYPE_STACK);
597 __uint(max_entries, MAX_ENTRIES);
598 __type(value, __u32);
599} m_stack SEC(".maps");
600
601static 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
611struct bpf_local_storage_map {
612 struct bpf_map map;
613} __attribute__((preserve_access_index));
614
615struct {
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
622static 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
633struct {
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
640static 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
650struct bpf_ringbuf_map {
651 struct bpf_map map;
652} __attribute__((preserve_access_index));
653
654struct {
655 __uint(type, BPF_MAP_TYPE_RINGBUF);
656} m_ringbuf SEC(".maps");
657
658static 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
668SEC("cgroup_skb/egress")
669int 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
703char _license[] SEC("license") = "GPL";
704
