1 /* Copyright (c) 2016 Facebook
2 *
3 * This program is free software; you can redistribute it and/or
4 * modify it under the terms of version 2 of the GNU General Public
5 * License as published by the Free Software Foundation.
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
16 struct 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
23 struct 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
30 struct 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
38 struct 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
47 struct 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
53 struct 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
60 struct 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
68 struct 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
76 struct 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
84 struct 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
91 struct 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
98 SEC("kprobe/sys_getuid")
stress_hmap(struct pt_regs * ctx)99 int 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
113 SEC("kprobe/sys_geteuid")
stress_percpu_hmap(struct pt_regs * ctx)114 int 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
127 SEC("kprobe/sys_getgid")
stress_hmap_alloc(struct pt_regs * ctx)128 int 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
141 SEC("kprobe/sys_getegid")
stress_percpu_hmap_alloc(struct pt_regs * ctx)142 int 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
155 SEC("kprobe/sys_connect")
stress_lru_hmap_alloc(struct pt_regs * ctx)156 int 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
227 done:
228 if (ret)
229 bpf_trace_printk(fmt, sizeof(fmt), ret);
230
231 return 0;
232 }
233
234 SEC("kprobe/sys_gettid")
stress_lpm_trie_map_alloc(struct pt_regs * ctx)235 int 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
256 SEC("kprobe/sys_getpgid")
stress_hash_map_lookup(struct pt_regs * ctx)257 int 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
269 SEC("kprobe/sys_getppid")
stress_array_map_lookup(struct pt_regs * ctx)270 int 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
282 char _license[] SEC("license") = "GPL";
283 u32 _version SEC("version") = LINUX_VERSION_CODE;
284
