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";
704
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.