1
2
3
4
5
6
7#include <linux/skbuff.h>
8#include <linux/netdevice.h>
9#include <linux/version.h>
10#include <uapi/linux/bpf.h>
11#include "bpf_helpers.h"
12
13#define MAX_ENTRIES 1000
14#define MAX_NR_CPUS 1024
15
16struct bpf_map_def SEC("maps") hash_map = {
17 .type = BPF_MAP_TYPE_HASH,
18 .key_size = sizeof(u32),
19 .value_size = sizeof(long),
20 .max_entries = MAX_ENTRIES,
21};
22
23struct bpf_map_def SEC("maps") lru_hash_map = {
24 .type = BPF_MAP_TYPE_LRU_HASH,
25 .key_size = sizeof(u32),
26 .value_size = sizeof(long),
27 .max_entries = 10000,
28};
29
30struct bpf_map_def SEC("maps") nocommon_lru_hash_map = {
31 .type = BPF_MAP_TYPE_LRU_HASH,
32 .key_size = sizeof(u32),
33 .value_size = sizeof(long),
34 .max_entries = 10000,
35 .map_flags = BPF_F_NO_COMMON_LRU,
36};
37
38struct bpf_map_def SEC("maps") inner_lru_hash_map = {
39 .type = BPF_MAP_TYPE_LRU_HASH,
40 .key_size = sizeof(u32),
41 .value_size = sizeof(long),
42 .max_entries = MAX_ENTRIES,
43 .map_flags = BPF_F_NUMA_NODE,
44 .numa_node = 0,
45};
46
47struct bpf_map_def SEC("maps") array_of_lru_hashs = {
48 .type = BPF_MAP_TYPE_ARRAY_OF_MAPS,
49 .key_size = sizeof(u32),
50 .max_entries = MAX_NR_CPUS,
51};
52
53struct bpf_map_def SEC("maps") percpu_hash_map = {
54 .type = BPF_MAP_TYPE_PERCPU_HASH,
55 .key_size = sizeof(u32),
56 .value_size = sizeof(long),
57 .max_entries = MAX_ENTRIES,
58};
59
60struct bpf_map_def SEC("maps") hash_map_alloc = {
61 .type = BPF_MAP_TYPE_HASH,
62 .key_size = sizeof(u32),
63 .value_size = sizeof(long),
64 .max_entries = MAX_ENTRIES,
65 .map_flags = BPF_F_NO_PREALLOC,
66};
67
68struct bpf_map_def SEC("maps") percpu_hash_map_alloc = {
69 .type = BPF_MAP_TYPE_PERCPU_HASH,
70 .key_size = sizeof(u32),
71 .value_size = sizeof(long),
72 .max_entries = MAX_ENTRIES,
73 .map_flags = BPF_F_NO_PREALLOC,
74};
75
76struct bpf_map_def SEC("maps") lpm_trie_map_alloc = {
77 .type = BPF_MAP_TYPE_LPM_TRIE,
78 .key_size = 8,
79 .value_size = sizeof(long),
80 .max_entries = 10000,
81 .map_flags = BPF_F_NO_PREALLOC,
82};
83
84struct bpf_map_def SEC("maps") array_map = {
85 .type = BPF_MAP_TYPE_ARRAY,
86 .key_size = sizeof(u32),
87 .value_size = sizeof(long),
88 .max_entries = MAX_ENTRIES,
89};
90
91struct bpf_map_def SEC("maps") lru_hash_lookup_map = {
92 .type = BPF_MAP_TYPE_LRU_HASH,
93 .key_size = sizeof(u32),
94 .value_size = sizeof(long),
95 .max_entries = MAX_ENTRIES,
96};
97
98SEC("kprobe/sys_getuid")
99int stress_hmap(struct pt_regs *ctx)
100{
101 u32 key = bpf_get_current_pid_tgid();
102 long init_val = 1;
103 long *value;
104
105 bpf_map_update_elem(&hash_map, &key, &init_val, BPF_ANY);
106 value = bpf_map_lookup_elem(&hash_map, &key);
107 if (value)
108 bpf_map_delete_elem(&hash_map, &key);
109
110 return 0;
111}
112
113SEC("kprobe/sys_geteuid")
114int stress_percpu_hmap(struct pt_regs *ctx)
115{
116 u32 key = bpf_get_current_pid_tgid();
117 long init_val = 1;
118 long *value;
119
120 bpf_map_update_elem(&percpu_hash_map, &key, &init_val, BPF_ANY);
121 value = bpf_map_lookup_elem(&percpu_hash_map, &key);
122 if (value)
123 bpf_map_delete_elem(&percpu_hash_map, &key);
124 return 0;
125}
126
127SEC("kprobe/sys_getgid")
128int stress_hmap_alloc(struct pt_regs *ctx)
129{
130 u32 key = bpf_get_current_pid_tgid();
131 long init_val = 1;
132 long *value;
133
134 bpf_map_update_elem(&hash_map_alloc, &key, &init_val, BPF_ANY);
135 value = bpf_map_lookup_elem(&hash_map_alloc, &key);
136 if (value)
137 bpf_map_delete_elem(&hash_map_alloc, &key);
138 return 0;
139}
140
141SEC("kprobe/sys_getegid")
142int stress_percpu_hmap_alloc(struct pt_regs *ctx)
143{
144 u32 key = bpf_get_current_pid_tgid();
145 long init_val = 1;
146 long *value;
147
148 bpf_map_update_elem(&percpu_hash_map_alloc, &key, &init_val, BPF_ANY);
149 value = bpf_map_lookup_elem(&percpu_hash_map_alloc, &key);
150 if (value)
151 bpf_map_delete_elem(&percpu_hash_map_alloc, &key);
152 return 0;
153}
154
155SEC("kprobe/sys_connect")
156int stress_lru_hmap_alloc(struct pt_regs *ctx)
157{
158 char fmt[] = "Failed at stress_lru_hmap_alloc. ret:%dn";
159 union {
160 u16 dst6[8];
161 struct {
162 u16 magic0;
163 u16 magic1;
164 u16 tcase;
165 u16 unused16;
166 u32 unused32;
167 u32 key;
168 };
169 } test_params;
170 struct sockaddr_in6 *in6;
171 u16 test_case;
172 int addrlen, ret;
173 long val = 1;
174 u32 key = 0;
175
176 in6 = (struct sockaddr_in6 *)PT_REGS_PARM2(ctx);
177 addrlen = (int)PT_REGS_PARM3(ctx);
178
179 if (addrlen != sizeof(*in6))
180 return 0;
181
182 ret = bpf_probe_read(test_params.dst6, sizeof(test_params.dst6),
183 &in6->sin6_addr);
184 if (ret)
185 goto done;
186
187 if (test_params.magic0 != 0xdead ||
188 test_params.magic1 != 0xbeef)
189 return 0;
190
191 test_case = test_params.tcase;
192 if (test_case != 3)
193 key = bpf_get_prandom_u32();
194
195 if (test_case == 0) {
196 ret = bpf_map_update_elem(&lru_hash_map, &key, &val, BPF_ANY);
197 } else if (test_case == 1) {
198 ret = bpf_map_update_elem(&nocommon_lru_hash_map, &key, &val,
199 BPF_ANY);
200 } else if (test_case == 2) {
201 void *nolocal_lru_map;
202 int cpu = bpf_get_smp_processor_id();
203
204 nolocal_lru_map = bpf_map_lookup_elem(&array_of_lru_hashs,
205 &cpu);
206 if (!nolocal_lru_map) {
207 ret = -ENOENT;
208 goto done;
209 }
210
211 ret = bpf_map_update_elem(nolocal_lru_map, &key, &val,
212 BPF_ANY);
213 } else if (test_case == 3) {
214 u32 i;
215
216 key = test_params.key;
217
218#pragma clang loop unroll(full)
219 for (i = 0; i < 32; i++) {
220 bpf_map_lookup_elem(&lru_hash_lookup_map, &key);
221 key++;
222 }
223 } else {
224 ret = -EINVAL;
225 }
226
227done:
228 if (ret)
229 bpf_trace_printk(fmt, sizeof(fmt), ret);
230
231 return 0;
232}
233
234SEC("kprobe/sys_gettid")
235int stress_lpm_trie_map_alloc(struct pt_regs *ctx)
236{
237 union {
238 u32 b32[2];
239 u8 b8[8];
240 } key;
241 unsigned int i;
242
243 key.b32[0] = 32;
244 key.b8[4] = 192;
245 key.b8[5] = 168;
246 key.b8[6] = 0;
247 key.b8[7] = 1;
248
249#pragma clang loop unroll(full)
250 for (i = 0; i < 32; ++i)
251 bpf_map_lookup_elem(&lpm_trie_map_alloc, &key);
252
253 return 0;
254}
255
256SEC("kprobe/sys_getpgid")
257int stress_hash_map_lookup(struct pt_regs *ctx)
258{
259 u32 key = 1, i;
260 long *value;
261
262#pragma clang loop unroll(full)
263 for (i = 0; i < 64; ++i)
264 value = bpf_map_lookup_elem(&hash_map, &key);
265
266 return 0;
267}
268
269SEC("kprobe/sys_getpgrp")
270int stress_array_map_lookup(struct pt_regs *ctx)
271{
272 u32 key = 1, i;
273 long *value;
274
275#pragma clang loop unroll(full)
276 for (i = 0; i < 64; ++i)
277 value = bpf_map_lookup_elem(&array_map, &key);
278
279 return 0;
280}
281
282char _license[] SEC("license") = "GPL";
283u32 _version SEC("version") = LINUX_VERSION_CODE;
284
