1 // SPDX-License-Identifier: GPL-2.0
3 #include <linux/compiler.h>
4 #include <asm/barrier.h>
5 #include <test_progs.h>
12 #include <sys/sysinfo.h>
13 #include <linux/perf_event.h>
14 #include <linux/ring_buffer.h>
15 #include "test_ringbuf.skel.h"
19 static int duration = 0;
28 static int sample_cnt;
30 static void atomic_inc(int *cnt)
32 __atomic_add_fetch(cnt, 1, __ATOMIC_SEQ_CST);
35 static int atomic_xchg(int *cnt, int val)
37 return __atomic_exchange_n(cnt, val, __ATOMIC_SEQ_CST);
40 static int process_sample(void *ctx, void *data, size_t len)
42 struct sample *s = data;
44 atomic_inc(&sample_cnt);
48 CHECK(s->value != 333, "sample1_value", "exp %ld, got %ld\n",
52 CHECK(s->value != 777, "sample2_value", "exp %ld, got %ld\n",
56 /* we don't care about the rest */
61 static struct test_ringbuf *skel;
62 static struct ring_buffer *ringbuf;
64 static void trigger_samples()
66 skel->bss->dropped = 0;
68 skel->bss->discarded = 0;
70 /* trigger exactly two samples */
71 skel->bss->value = 333;
72 syscall(__NR_getpgid);
73 skel->bss->value = 777;
74 syscall(__NR_getpgid);
77 static void *poll_thread(void *input)
79 long timeout = (long)input;
81 return (void *)(long)ring_buffer__poll(ringbuf, timeout);
84 void test_ringbuf(void)
86 const size_t rec_sz = BPF_RINGBUF_HDR_SZ + sizeof(struct sample);
90 int page_size = getpagesize();
92 skel = test_ringbuf__open();
93 if (CHECK(!skel, "skel_open", "skeleton open failed\n"))
96 err = bpf_map__set_max_entries(skel->maps.ringbuf, page_size);
97 if (CHECK(err != 0, "bpf_map__set_max_entries", "bpf_map__set_max_entries failed\n"))
100 err = test_ringbuf__load(skel);
101 if (CHECK(err != 0, "skel_load", "skeleton load failed\n"))
104 /* only trigger BPF program for current process */
105 skel->bss->pid = getpid();
107 ringbuf = ring_buffer__new(bpf_map__fd(skel->maps.ringbuf),
108 process_sample, NULL, NULL);
109 if (CHECK(!ringbuf, "ringbuf_create", "failed to create ringbuf\n"))
112 err = test_ringbuf__attach(skel);
113 if (CHECK(err, "skel_attach", "skeleton attachment failed: %d\n", err))
118 /* 2 submitted + 1 discarded records */
119 CHECK(skel->bss->avail_data != 3 * rec_sz,
120 "err_avail_size", "exp %ld, got %ld\n",
121 3L * rec_sz, skel->bss->avail_data);
122 CHECK(skel->bss->ring_size != page_size,
123 "err_ring_size", "exp %ld, got %ld\n",
124 (long)page_size, skel->bss->ring_size);
125 CHECK(skel->bss->cons_pos != 0,
126 "err_cons_pos", "exp %ld, got %ld\n",
127 0L, skel->bss->cons_pos);
128 CHECK(skel->bss->prod_pos != 3 * rec_sz,
129 "err_prod_pos", "exp %ld, got %ld\n",
130 3L * rec_sz, skel->bss->prod_pos);
132 /* poll for samples */
133 err = ring_buffer__poll(ringbuf, -1);
135 /* -EDONE is used as an indicator that we are done */
136 if (CHECK(err != -EDONE, "err_done", "done err: %d\n", err))
138 cnt = atomic_xchg(&sample_cnt, 0);
139 CHECK(cnt != 2, "cnt", "exp %d samples, got %d\n", 2, cnt);
141 /* we expect extra polling to return nothing */
142 err = ring_buffer__poll(ringbuf, 0);
143 if (CHECK(err != 0, "extra_samples", "poll result: %d\n", err))
145 cnt = atomic_xchg(&sample_cnt, 0);
146 CHECK(cnt != 0, "cnt", "exp %d samples, got %d\n", 0, cnt);
148 CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
149 0L, skel->bss->dropped);
150 CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
151 2L, skel->bss->total);
152 CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
153 1L, skel->bss->discarded);
155 /* now validate consumer position is updated and returned */
157 CHECK(skel->bss->cons_pos != 3 * rec_sz,
158 "err_cons_pos", "exp %ld, got %ld\n",
159 3L * rec_sz, skel->bss->cons_pos);
160 err = ring_buffer__poll(ringbuf, -1);
161 CHECK(err <= 0, "poll_err", "err %d\n", err);
162 cnt = atomic_xchg(&sample_cnt, 0);
163 CHECK(cnt != 2, "cnt", "exp %d samples, got %d\n", 2, cnt);
165 /* start poll in background w/ long timeout */
166 err = pthread_create(&thread, NULL, poll_thread, (void *)(long)10000);
167 if (CHECK(err, "bg_poll", "pthread_create failed: %d\n", err))
170 /* turn off notifications now */
171 skel->bss->flags = BPF_RB_NO_WAKEUP;
173 /* give background thread a bit of a time */
176 /* sleeping arbitrarily is bad, but no better way to know that
177 * epoll_wait() **DID NOT** unblock in background thread
180 /* background poll should still be blocked */
181 err = pthread_tryjoin_np(thread, (void **)&bg_ret);
182 if (CHECK(err != EBUSY, "try_join", "err %d\n", err))
185 /* BPF side did everything right */
186 CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
187 0L, skel->bss->dropped);
188 CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
189 2L, skel->bss->total);
190 CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
191 1L, skel->bss->discarded);
192 cnt = atomic_xchg(&sample_cnt, 0);
193 CHECK(cnt != 0, "cnt", "exp %d samples, got %d\n", 0, cnt);
195 /* clear flags to return to "adaptive" notification mode */
196 skel->bss->flags = 0;
198 /* produce new samples, no notification should be triggered, because
199 * consumer is now behind
203 /* background poll should still be blocked */
204 err = pthread_tryjoin_np(thread, (void **)&bg_ret);
205 if (CHECK(err != EBUSY, "try_join", "err %d\n", err))
208 /* still no samples, because consumer is behind */
209 cnt = atomic_xchg(&sample_cnt, 0);
210 CHECK(cnt != 0, "cnt", "exp %d samples, got %d\n", 0, cnt);
212 skel->bss->dropped = 0;
213 skel->bss->total = 0;
214 skel->bss->discarded = 0;
216 skel->bss->value = 333;
217 syscall(__NR_getpgid);
218 /* now force notifications */
219 skel->bss->flags = BPF_RB_FORCE_WAKEUP;
220 skel->bss->value = 777;
221 syscall(__NR_getpgid);
223 /* now we should get a pending notification */
225 err = pthread_tryjoin_np(thread, (void **)&bg_ret);
226 if (CHECK(err, "join_bg", "err %d\n", err))
229 if (CHECK(bg_ret <= 0, "bg_ret", "epoll_wait result: %ld", bg_ret))
232 /* due to timing variations, there could still be non-notified
233 * samples, so consume them here to collect all the samples
235 err = ring_buffer__consume(ringbuf);
236 CHECK(err < 0, "rb_consume", "failed: %d\b", err);
238 /* 3 rounds, 2 samples each */
239 cnt = atomic_xchg(&sample_cnt, 0);
240 CHECK(cnt != 6, "cnt", "exp %d samples, got %d\n", 6, cnt);
242 /* BPF side did everything right */
243 CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
244 0L, skel->bss->dropped);
245 CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
246 2L, skel->bss->total);
247 CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
248 1L, skel->bss->discarded);
250 test_ringbuf__detach(skel);
252 ring_buffer__free(ringbuf);
253 test_ringbuf__destroy(skel);