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 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";
704