Loading...
1// SPDX-License-Identifier: GPL-2.0
2#define _GNU_SOURCE
3#include <linux/compiler.h>
4#include <asm/barrier.h>
5#include <test_progs.h>
6#include <sys/mman.h>
7#include <sys/epoll.h>
8#include <time.h>
9#include <sched.h>
10#include <signal.h>
11#include <pthread.h>
12#include <sys/sysinfo.h>
13#include <linux/perf_event.h>
14#include <linux/ring_buffer.h>
15#include "test_ringbuf.lskel.h"
16#include "test_ringbuf_map_key.lskel.h"
17
18#define EDONE 7777
19
20static int duration = 0;
21
22struct sample {
23 int pid;
24 int seq;
25 long value;
26 char comm[16];
27};
28
29static int sample_cnt;
30
31static void atomic_inc(int *cnt)
32{
33 __atomic_add_fetch(cnt, 1, __ATOMIC_SEQ_CST);
34}
35
36static int atomic_xchg(int *cnt, int val)
37{
38 return __atomic_exchange_n(cnt, val, __ATOMIC_SEQ_CST);
39}
40
41static int process_sample(void *ctx, void *data, size_t len)
42{
43 struct sample *s = data;
44
45 atomic_inc(&sample_cnt);
46
47 switch (s->seq) {
48 case 0:
49 CHECK(s->value != 333, "sample1_value", "exp %ld, got %ld\n",
50 333L, s->value);
51 return 0;
52 case 1:
53 CHECK(s->value != 777, "sample2_value", "exp %ld, got %ld\n",
54 777L, s->value);
55 return -EDONE;
56 default:
57 /* we don't care about the rest */
58 return 0;
59 }
60}
61
62static struct test_ringbuf_map_key_lskel *skel_map_key;
63static struct test_ringbuf_lskel *skel;
64static struct ring_buffer *ringbuf;
65
66static void trigger_samples()
67{
68 skel->bss->dropped = 0;
69 skel->bss->total = 0;
70 skel->bss->discarded = 0;
71
72 /* trigger exactly two samples */
73 skel->bss->value = 333;
74 syscall(__NR_getpgid);
75 skel->bss->value = 777;
76 syscall(__NR_getpgid);
77}
78
79static void *poll_thread(void *input)
80{
81 long timeout = (long)input;
82
83 return (void *)(long)ring_buffer__poll(ringbuf, timeout);
84}
85
86static void ringbuf_subtest(void)
87{
88 const size_t rec_sz = BPF_RINGBUF_HDR_SZ + sizeof(struct sample);
89 pthread_t thread;
90 long bg_ret = -1;
91 int err, cnt, rb_fd;
92 int page_size = getpagesize();
93 void *mmap_ptr, *tmp_ptr;
94 struct ring *ring;
95 int map_fd;
96 unsigned long avail_data, ring_size, cons_pos, prod_pos;
97
98 skel = test_ringbuf_lskel__open();
99 if (CHECK(!skel, "skel_open", "skeleton open failed\n"))
100 return;
101
102 skel->maps.ringbuf.max_entries = page_size;
103
104 err = test_ringbuf_lskel__load(skel);
105 if (CHECK(err != 0, "skel_load", "skeleton load failed\n"))
106 goto cleanup;
107
108 rb_fd = skel->maps.ringbuf.map_fd;
109 /* good read/write cons_pos */
110 mmap_ptr = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, rb_fd, 0);
111 ASSERT_OK_PTR(mmap_ptr, "rw_cons_pos");
112 tmp_ptr = mremap(mmap_ptr, page_size, 2 * page_size, MREMAP_MAYMOVE);
113 if (!ASSERT_ERR_PTR(tmp_ptr, "rw_extend"))
114 goto cleanup;
115 ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_EXEC), "exec_cons_pos_protect");
116 ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_rw");
117
118 /* bad writeable prod_pos */
119 mmap_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd, page_size);
120 err = -errno;
121 ASSERT_ERR_PTR(mmap_ptr, "wr_prod_pos");
122 ASSERT_EQ(err, -EPERM, "wr_prod_pos_err");
123
124 /* bad writeable data pages */
125 mmap_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd, 2 * page_size);
126 err = -errno;
127 ASSERT_ERR_PTR(mmap_ptr, "wr_data_page_one");
128 ASSERT_EQ(err, -EPERM, "wr_data_page_one_err");
129 mmap_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd, 3 * page_size);
130 ASSERT_ERR_PTR(mmap_ptr, "wr_data_page_two");
131 mmap_ptr = mmap(NULL, 2 * page_size, PROT_WRITE, MAP_SHARED, rb_fd, 2 * page_size);
132 ASSERT_ERR_PTR(mmap_ptr, "wr_data_page_all");
133
134 /* good read-only pages */
135 mmap_ptr = mmap(NULL, 4 * page_size, PROT_READ, MAP_SHARED, rb_fd, 0);
136 if (!ASSERT_OK_PTR(mmap_ptr, "ro_prod_pos"))
137 goto cleanup;
138
139 ASSERT_ERR(mprotect(mmap_ptr, 4 * page_size, PROT_WRITE), "write_protect");
140 ASSERT_ERR(mprotect(mmap_ptr, 4 * page_size, PROT_EXEC), "exec_protect");
141 ASSERT_ERR_PTR(mremap(mmap_ptr, 0, 4 * page_size, MREMAP_MAYMOVE), "ro_remap");
142 ASSERT_OK(munmap(mmap_ptr, 4 * page_size), "unmap_ro");
143
144 /* good read-only pages with initial offset */
145 mmap_ptr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, rb_fd, page_size);
146 if (!ASSERT_OK_PTR(mmap_ptr, "ro_prod_pos"))
147 goto cleanup;
148
149 ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_WRITE), "write_protect");
150 ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_EXEC), "exec_protect");
151 ASSERT_ERR_PTR(mremap(mmap_ptr, 0, 3 * page_size, MREMAP_MAYMOVE), "ro_remap");
152 ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_ro");
153
154 /* only trigger BPF program for current process */
155 skel->bss->pid = getpid();
156
157 ringbuf = ring_buffer__new(skel->maps.ringbuf.map_fd,
158 process_sample, NULL, NULL);
159 if (CHECK(!ringbuf, "ringbuf_create", "failed to create ringbuf\n"))
160 goto cleanup;
161
162 err = test_ringbuf_lskel__attach(skel);
163 if (CHECK(err, "skel_attach", "skeleton attachment failed: %d\n", err))
164 goto cleanup;
165
166 trigger_samples();
167
168 ring = ring_buffer__ring(ringbuf, 0);
169 if (!ASSERT_OK_PTR(ring, "ring_buffer__ring_idx_0"))
170 goto cleanup;
171
172 map_fd = ring__map_fd(ring);
173 ASSERT_EQ(map_fd, skel->maps.ringbuf.map_fd, "ring_map_fd");
174
175 /* 2 submitted + 1 discarded records */
176 CHECK(skel->bss->avail_data != 3 * rec_sz,
177 "err_avail_size", "exp %ld, got %ld\n",
178 3L * rec_sz, skel->bss->avail_data);
179 CHECK(skel->bss->ring_size != page_size,
180 "err_ring_size", "exp %ld, got %ld\n",
181 (long)page_size, skel->bss->ring_size);
182 CHECK(skel->bss->cons_pos != 0,
183 "err_cons_pos", "exp %ld, got %ld\n",
184 0L, skel->bss->cons_pos);
185 CHECK(skel->bss->prod_pos != 3 * rec_sz,
186 "err_prod_pos", "exp %ld, got %ld\n",
187 3L * rec_sz, skel->bss->prod_pos);
188
189 /* verify getting this data directly via the ring object yields the same
190 * results
191 */
192 avail_data = ring__avail_data_size(ring);
193 ASSERT_EQ(avail_data, 3 * rec_sz, "ring_avail_size");
194 ring_size = ring__size(ring);
195 ASSERT_EQ(ring_size, page_size, "ring_ring_size");
196 cons_pos = ring__consumer_pos(ring);
197 ASSERT_EQ(cons_pos, 0, "ring_cons_pos");
198 prod_pos = ring__producer_pos(ring);
199 ASSERT_EQ(prod_pos, 3 * rec_sz, "ring_prod_pos");
200
201 /* poll for samples */
202 err = ring_buffer__poll(ringbuf, -1);
203
204 /* -EDONE is used as an indicator that we are done */
205 if (CHECK(err != -EDONE, "err_done", "done err: %d\n", err))
206 goto cleanup;
207 cnt = atomic_xchg(&sample_cnt, 0);
208 CHECK(cnt != 2, "cnt", "exp %d samples, got %d\n", 2, cnt);
209
210 /* we expect extra polling to return nothing */
211 err = ring_buffer__poll(ringbuf, 0);
212 if (CHECK(err != 0, "extra_samples", "poll result: %d\n", err))
213 goto cleanup;
214 cnt = atomic_xchg(&sample_cnt, 0);
215 CHECK(cnt != 0, "cnt", "exp %d samples, got %d\n", 0, cnt);
216
217 CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
218 0L, skel->bss->dropped);
219 CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
220 2L, skel->bss->total);
221 CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
222 1L, skel->bss->discarded);
223
224 /* now validate consumer position is updated and returned */
225 trigger_samples();
226 CHECK(skel->bss->cons_pos != 3 * rec_sz,
227 "err_cons_pos", "exp %ld, got %ld\n",
228 3L * rec_sz, skel->bss->cons_pos);
229 err = ring_buffer__poll(ringbuf, -1);
230 CHECK(err <= 0, "poll_err", "err %d\n", err);
231 cnt = atomic_xchg(&sample_cnt, 0);
232 CHECK(cnt != 2, "cnt", "exp %d samples, got %d\n", 2, cnt);
233
234 /* start poll in background w/ long timeout */
235 err = pthread_create(&thread, NULL, poll_thread, (void *)(long)10000);
236 if (CHECK(err, "bg_poll", "pthread_create failed: %d\n", err))
237 goto cleanup;
238
239 /* turn off notifications now */
240 skel->bss->flags = BPF_RB_NO_WAKEUP;
241
242 /* give background thread a bit of a time */
243 usleep(50000);
244 trigger_samples();
245 /* sleeping arbitrarily is bad, but no better way to know that
246 * epoll_wait() **DID NOT** unblock in background thread
247 */
248 usleep(50000);
249 /* background poll should still be blocked */
250 err = pthread_tryjoin_np(thread, (void **)&bg_ret);
251 if (CHECK(err != EBUSY, "try_join", "err %d\n", err))
252 goto cleanup;
253
254 /* BPF side did everything right */
255 CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
256 0L, skel->bss->dropped);
257 CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
258 2L, skel->bss->total);
259 CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
260 1L, skel->bss->discarded);
261 cnt = atomic_xchg(&sample_cnt, 0);
262 CHECK(cnt != 0, "cnt", "exp %d samples, got %d\n", 0, cnt);
263
264 /* clear flags to return to "adaptive" notification mode */
265 skel->bss->flags = 0;
266
267 /* produce new samples, no notification should be triggered, because
268 * consumer is now behind
269 */
270 trigger_samples();
271
272 /* background poll should still be blocked */
273 err = pthread_tryjoin_np(thread, (void **)&bg_ret);
274 if (CHECK(err != EBUSY, "try_join", "err %d\n", err))
275 goto cleanup;
276
277 /* still no samples, because consumer is behind */
278 cnt = atomic_xchg(&sample_cnt, 0);
279 CHECK(cnt != 0, "cnt", "exp %d samples, got %d\n", 0, cnt);
280
281 skel->bss->dropped = 0;
282 skel->bss->total = 0;
283 skel->bss->discarded = 0;
284
285 skel->bss->value = 333;
286 syscall(__NR_getpgid);
287 /* now force notifications */
288 skel->bss->flags = BPF_RB_FORCE_WAKEUP;
289 skel->bss->value = 777;
290 syscall(__NR_getpgid);
291
292 /* now we should get a pending notification */
293 usleep(50000);
294 err = pthread_tryjoin_np(thread, (void **)&bg_ret);
295 if (CHECK(err, "join_bg", "err %d\n", err))
296 goto cleanup;
297
298 if (CHECK(bg_ret <= 0, "bg_ret", "epoll_wait result: %ld", bg_ret))
299 goto cleanup;
300
301 /* due to timing variations, there could still be non-notified
302 * samples, so consume them here to collect all the samples
303 */
304 err = ring_buffer__consume(ringbuf);
305 CHECK(err < 0, "rb_consume", "failed: %d\b", err);
306
307 /* also consume using ring__consume to make sure it works the same */
308 err = ring__consume(ring);
309 ASSERT_GE(err, 0, "ring_consume");
310
311 /* 3 rounds, 2 samples each */
312 cnt = atomic_xchg(&sample_cnt, 0);
313 CHECK(cnt != 6, "cnt", "exp %d samples, got %d\n", 6, cnt);
314
315 /* BPF side did everything right */
316 CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
317 0L, skel->bss->dropped);
318 CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
319 2L, skel->bss->total);
320 CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
321 1L, skel->bss->discarded);
322
323 test_ringbuf_lskel__detach(skel);
324cleanup:
325 ring_buffer__free(ringbuf);
326 test_ringbuf_lskel__destroy(skel);
327}
328
329static int process_map_key_sample(void *ctx, void *data, size_t len)
330{
331 struct sample *s;
332 int err, val;
333
334 s = data;
335 switch (s->seq) {
336 case 1:
337 ASSERT_EQ(s->value, 42, "sample_value");
338 err = bpf_map_lookup_elem(skel_map_key->maps.hash_map.map_fd,
339 s, &val);
340 ASSERT_OK(err, "hash_map bpf_map_lookup_elem");
341 ASSERT_EQ(val, 1, "hash_map val");
342 return -EDONE;
343 default:
344 return 0;
345 }
346}
347
348static void ringbuf_map_key_subtest(void)
349{
350 int err;
351
352 skel_map_key = test_ringbuf_map_key_lskel__open();
353 if (!ASSERT_OK_PTR(skel_map_key, "test_ringbuf_map_key_lskel__open"))
354 return;
355
356 skel_map_key->maps.ringbuf.max_entries = getpagesize();
357 skel_map_key->bss->pid = getpid();
358
359 err = test_ringbuf_map_key_lskel__load(skel_map_key);
360 if (!ASSERT_OK(err, "test_ringbuf_map_key_lskel__load"))
361 goto cleanup;
362
363 ringbuf = ring_buffer__new(skel_map_key->maps.ringbuf.map_fd,
364 process_map_key_sample, NULL, NULL);
365 if (!ASSERT_OK_PTR(ringbuf, "ring_buffer__new"))
366 goto cleanup;
367
368 err = test_ringbuf_map_key_lskel__attach(skel_map_key);
369 if (!ASSERT_OK(err, "test_ringbuf_map_key_lskel__attach"))
370 goto cleanup_ringbuf;
371
372 syscall(__NR_getpgid);
373 ASSERT_EQ(skel_map_key->bss->seq, 1, "skel_map_key->bss->seq");
374 err = ring_buffer__poll(ringbuf, -1);
375 ASSERT_EQ(err, -EDONE, "ring_buffer__poll");
376
377cleanup_ringbuf:
378 ring_buffer__free(ringbuf);
379cleanup:
380 test_ringbuf_map_key_lskel__destroy(skel_map_key);
381}
382
383void test_ringbuf(void)
384{
385 if (test__start_subtest("ringbuf"))
386 ringbuf_subtest();
387 if (test__start_subtest("ringbuf_map_key"))
388 ringbuf_map_key_subtest();
389}