selftests/bpf: Add BPF ringbuf selftests
Both singleton BPF ringbuf and BPF ringbuf with map-in-map use cases are tested. Also reserve+submit/discards and output variants of API are validated. Signed-off-by: Andrii Nakryiko <andriin@fb.com> Signed-off-by: Daniel Borkmann <daniel@iogearbox.net> Link: https://lore.kernel.org/bpf/20200529075424.3139988-4-andriin@fb.com Signed-off-by: Alexei Starovoitov <ast@kernel.org>
This commit is contained in:
Andrii Nakryiko
Alexei Starovoitov
parent
bf99c936f9
commit
cb1c9ddd55
|
|
@ -0,0 +1,211 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
#define _GNU_SOURCE
|
||||
#include <linux/compiler.h>
|
||||
#include <asm/barrier.h>
|
||||
#include <test_progs.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/epoll.h>
|
||||
#include <time.h>
|
||||
#include <sched.h>
|
||||
#include <signal.h>
|
||||
#include <pthread.h>
|
||||
#include <sys/sysinfo.h>
|
||||
#include <linux/perf_event.h>
|
||||
#include <linux/ring_buffer.h>
|
||||
#include "test_ringbuf.skel.h"
|
||||
|
||||
#define EDONE 7777
|
||||
|
||||
static int duration = 0;
|
||||
|
||||
struct sample {
|
||||
int pid;
|
||||
int seq;
|
||||
long value;
|
||||
char comm[16];
|
||||
};
|
||||
|
||||
static int sample_cnt;
|
||||
|
||||
static int process_sample(void *ctx, void *data, size_t len)
|
||||
{
|
||||
struct sample *s = data;
|
||||
|
||||
sample_cnt++;
|
||||
|
||||
switch (s->seq) {
|
||||
case 0:
|
||||
CHECK(s->value != 333, "sample1_value", "exp %ld, got %ld\n",
|
||||
333L, s->value);
|
||||
return 0;
|
||||
case 1:
|
||||
CHECK(s->value != 777, "sample2_value", "exp %ld, got %ld\n",
|
||||
777L, s->value);
|
||||
return -EDONE;
|
||||
default:
|
||||
/* we don't care about the rest */
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static struct test_ringbuf *skel;
|
||||
static struct ring_buffer *ringbuf;
|
||||
|
||||
static void trigger_samples()
|
||||
{
|
||||
skel->bss->dropped = 0;
|
||||
skel->bss->total = 0;
|
||||
skel->bss->discarded = 0;
|
||||
|
||||
/* trigger exactly two samples */
|
||||
skel->bss->value = 333;
|
||||
syscall(__NR_getpgid);
|
||||
skel->bss->value = 777;
|
||||
syscall(__NR_getpgid);
|
||||
}
|
||||
|
||||
static void *poll_thread(void *input)
|
||||
{
|
||||
long timeout = (long)input;
|
||||
|
||||
return (void *)(long)ring_buffer__poll(ringbuf, timeout);
|
||||
}
|
||||
|
||||
void test_ringbuf(void)
|
||||
{
|
||||
const size_t rec_sz = BPF_RINGBUF_HDR_SZ + sizeof(struct sample);
|
||||
pthread_t thread;
|
||||
long bg_ret = -1;
|
||||
int err;
|
||||
|
||||
skel = test_ringbuf__open_and_load();
|
||||
if (CHECK(!skel, "skel_open_load", "skeleton open&load failed\n"))
|
||||
return;
|
||||
|
||||
/* only trigger BPF program for current process */
|
||||
skel->bss->pid = getpid();
|
||||
|
||||
ringbuf = ring_buffer__new(bpf_map__fd(skel->maps.ringbuf),
|
||||
process_sample, NULL, NULL);
|
||||
if (CHECK(!ringbuf, "ringbuf_create", "failed to create ringbuf\n"))
|
||||
goto cleanup;
|
||||
|
||||
err = test_ringbuf__attach(skel);
|
||||
if (CHECK(err, "skel_attach", "skeleton attachment failed: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
trigger_samples();
|
||||
|
||||
/* 2 submitted + 1 discarded records */
|
||||
CHECK(skel->bss->avail_data != 3 * rec_sz,
|
||||
"err_avail_size", "exp %ld, got %ld\n",
|
||||
3L * rec_sz, skel->bss->avail_data);
|
||||
CHECK(skel->bss->ring_size != 4096,
|
||||
"err_ring_size", "exp %ld, got %ld\n",
|
||||
4096L, skel->bss->ring_size);
|
||||
CHECK(skel->bss->cons_pos != 0,
|
||||
"err_cons_pos", "exp %ld, got %ld\n",
|
||||
0L, skel->bss->cons_pos);
|
||||
CHECK(skel->bss->prod_pos != 3 * rec_sz,
|
||||
"err_prod_pos", "exp %ld, got %ld\n",
|
||||
3L * rec_sz, skel->bss->prod_pos);
|
||||
|
||||
/* poll for samples */
|
||||
err = ring_buffer__poll(ringbuf, -1);
|
||||
|
||||
/* -EDONE is used as an indicator that we are done */
|
||||
if (CHECK(err != -EDONE, "err_done", "done err: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
/* we expect extra polling to return nothing */
|
||||
err = ring_buffer__poll(ringbuf, 0);
|
||||
if (CHECK(err != 0, "extra_samples", "poll result: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
|
||||
0L, skel->bss->dropped);
|
||||
CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
|
||||
2L, skel->bss->total);
|
||||
CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
|
||||
1L, skel->bss->discarded);
|
||||
|
||||
/* now validate consumer position is updated and returned */
|
||||
trigger_samples();
|
||||
CHECK(skel->bss->cons_pos != 3 * rec_sz,
|
||||
"err_cons_pos", "exp %ld, got %ld\n",
|
||||
3L * rec_sz, skel->bss->cons_pos);
|
||||
err = ring_buffer__poll(ringbuf, -1);
|
||||
CHECK(err <= 0, "poll_err", "err %d\n", err);
|
||||
|
||||
/* start poll in background w/ long timeout */
|
||||
err = pthread_create(&thread, NULL, poll_thread, (void *)(long)10000);
|
||||
if (CHECK(err, "bg_poll", "pthread_create failed: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
/* turn off notifications now */
|
||||
skel->bss->flags = BPF_RB_NO_WAKEUP;
|
||||
|
||||
/* give background thread a bit of a time */
|
||||
usleep(50000);
|
||||
trigger_samples();
|
||||
/* sleeping arbitrarily is bad, but no better way to know that
|
||||
* epoll_wait() **DID NOT** unblock in background thread
|
||||
*/
|
||||
usleep(50000);
|
||||
/* background poll should still be blocked */
|
||||
err = pthread_tryjoin_np(thread, (void **)&bg_ret);
|
||||
if (CHECK(err != EBUSY, "try_join", "err %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
/* BPF side did everything right */
|
||||
CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
|
||||
0L, skel->bss->dropped);
|
||||
CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
|
||||
2L, skel->bss->total);
|
||||
CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
|
||||
1L, skel->bss->discarded);
|
||||
|
||||
/* clear flags to return to "adaptive" notification mode */
|
||||
skel->bss->flags = 0;
|
||||
|
||||
/* produce new samples, no notification should be triggered, because
|
||||
* consumer is now behind
|
||||
*/
|
||||
trigger_samples();
|
||||
|
||||
/* background poll should still be blocked */
|
||||
err = pthread_tryjoin_np(thread, (void **)&bg_ret);
|
||||
if (CHECK(err != EBUSY, "try_join", "err %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
/* now force notifications */
|
||||
skel->bss->flags = BPF_RB_FORCE_WAKEUP;
|
||||
sample_cnt = 0;
|
||||
trigger_samples();
|
||||
|
||||
/* now we should get a pending notification */
|
||||
usleep(50000);
|
||||
err = pthread_tryjoin_np(thread, (void **)&bg_ret);
|
||||
if (CHECK(err, "join_bg", "err %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
if (CHECK(bg_ret != 1, "bg_ret", "epoll_wait result: %ld", bg_ret))
|
||||
goto cleanup;
|
||||
|
||||
/* 3 rounds, 2 samples each */
|
||||
CHECK(sample_cnt != 6, "wrong_sample_cnt",
|
||||
"expected to see %d samples, got %d\n", 6, sample_cnt);
|
||||
|
||||
/* BPF side did everything right */
|
||||
CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
|
||||
0L, skel->bss->dropped);
|
||||
CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
|
||||
2L, skel->bss->total);
|
||||
CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
|
||||
1L, skel->bss->discarded);
|
||||
|
||||
test_ringbuf__detach(skel);
|
||||
cleanup:
|
||||
ring_buffer__free(ringbuf);
|
||||
test_ringbuf__destroy(skel);
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
#define _GNU_SOURCE
|
||||
#include <test_progs.h>
|
||||
#include <sys/epoll.h>
|
||||
#include "test_ringbuf_multi.skel.h"
|
||||
|
||||
static int duration = 0;
|
||||
|
||||
struct sample {
|
||||
int pid;
|
||||
int seq;
|
||||
long value;
|
||||
char comm[16];
|
||||
};
|
||||
|
||||
static int process_sample(void *ctx, void *data, size_t len)
|
||||
{
|
||||
int ring = (unsigned long)ctx;
|
||||
struct sample *s = data;
|
||||
|
||||
switch (s->seq) {
|
||||
case 0:
|
||||
CHECK(ring != 1, "sample1_ring", "exp %d, got %d\n", 1, ring);
|
||||
CHECK(s->value != 333, "sample1_value", "exp %ld, got %ld\n",
|
||||
333L, s->value);
|
||||
break;
|
||||
case 1:
|
||||
CHECK(ring != 2, "sample2_ring", "exp %d, got %d\n", 2, ring);
|
||||
CHECK(s->value != 777, "sample2_value", "exp %ld, got %ld\n",
|
||||
777L, s->value);
|
||||
break;
|
||||
default:
|
||||
CHECK(true, "extra_sample", "unexpected sample seq %d, val %ld\n",
|
||||
s->seq, s->value);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void test_ringbuf_multi(void)
|
||||
{
|
||||
struct test_ringbuf_multi *skel;
|
||||
struct ring_buffer *ringbuf;
|
||||
int err;
|
||||
|
||||
skel = test_ringbuf_multi__open_and_load();
|
||||
if (CHECK(!skel, "skel_open_load", "skeleton open&load failed\n"))
|
||||
return;
|
||||
|
||||
/* only trigger BPF program for current process */
|
||||
skel->bss->pid = getpid();
|
||||
|
||||
ringbuf = ring_buffer__new(bpf_map__fd(skel->maps.ringbuf1),
|
||||
process_sample, (void *)(long)1, NULL);
|
||||
if (CHECK(!ringbuf, "ringbuf_create", "failed to create ringbuf\n"))
|
||||
goto cleanup;
|
||||
|
||||
err = ring_buffer__add(ringbuf, bpf_map__fd(skel->maps.ringbuf2),
|
||||
process_sample, (void *)(long)2);
|
||||
if (CHECK(err, "ringbuf_add", "failed to add another ring\n"))
|
||||
goto cleanup;
|
||||
|
||||
err = test_ringbuf_multi__attach(skel);
|
||||
if (CHECK(err, "skel_attach", "skeleton attachment failed: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
/* trigger few samples, some will be skipped */
|
||||
skel->bss->target_ring = 0;
|
||||
skel->bss->value = 333;
|
||||
syscall(__NR_getpgid);
|
||||
|
||||
/* skipped, no ringbuf in slot 1 */
|
||||
skel->bss->target_ring = 1;
|
||||
skel->bss->value = 555;
|
||||
syscall(__NR_getpgid);
|
||||
|
||||
skel->bss->target_ring = 2;
|
||||
skel->bss->value = 777;
|
||||
syscall(__NR_getpgid);
|
||||
|
||||
/* poll for samples, should get 2 ringbufs back */
|
||||
err = ring_buffer__poll(ringbuf, -1);
|
||||
if (CHECK(err != 4, "poll_res", "expected 4 records, got %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
/* expect extra polling to return nothing */
|
||||
err = ring_buffer__poll(ringbuf, 0);
|
||||
if (CHECK(err < 0, "extra_samples", "poll result: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
CHECK(skel->bss->dropped != 0, "err_dropped", "exp %ld, got %ld\n",
|
||||
0L, skel->bss->dropped);
|
||||
CHECK(skel->bss->skipped != 1, "err_skipped", "exp %ld, got %ld\n",
|
||||
1L, skel->bss->skipped);
|
||||
CHECK(skel->bss->total != 2, "err_total", "exp %ld, got %ld\n",
|
||||
2L, skel->bss->total);
|
||||
|
||||
cleanup:
|
||||
ring_buffer__free(ringbuf);
|
||||
test_ringbuf_multi__destroy(skel);
|
||||
}
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
// Copyright (c) 2020 Facebook
|
||||
|
||||
#include <linux/bpf.h>
|
||||
#include <bpf/bpf_helpers.h>
|
||||
|
||||
char _license[] SEC("license") = "GPL";
|
||||
|
||||
struct sample {
|
||||
int pid;
|
||||
int seq;
|
||||
long value;
|
||||
char comm[16];
|
||||
};
|
||||
|
||||
struct {
|
||||
__uint(type, BPF_MAP_TYPE_RINGBUF);
|
||||
__uint(max_entries, 1 << 12);
|
||||
} ringbuf SEC(".maps");
|
||||
|
||||
/* inputs */
|
||||
int pid = 0;
|
||||
long value = 0;
|
||||
long flags = 0;
|
||||
|
||||
/* outputs */
|
||||
long total = 0;
|
||||
long discarded = 0;
|
||||
long dropped = 0;
|
||||
|
||||
long avail_data = 0;
|
||||
long ring_size = 0;
|
||||
long cons_pos = 0;
|
||||
long prod_pos = 0;
|
||||
|
||||
/* inner state */
|
||||
long seq = 0;
|
||||
|
||||
SEC("tp/syscalls/sys_enter_getpgid")
|
||||
int test_ringbuf(void *ctx)
|
||||
{
|
||||
int cur_pid = bpf_get_current_pid_tgid() >> 32;
|
||||
struct sample *sample;
|
||||
int zero = 0;
|
||||
|
||||
if (cur_pid != pid)
|
||||
return 0;
|
||||
|
||||
sample = bpf_ringbuf_reserve(&ringbuf, sizeof(*sample), 0);
|
||||
if (!sample) {
|
||||
__sync_fetch_and_add(&dropped, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
sample->pid = pid;
|
||||
bpf_get_current_comm(sample->comm, sizeof(sample->comm));
|
||||
sample->value = value;
|
||||
|
||||
sample->seq = seq++;
|
||||
__sync_fetch_and_add(&total, 1);
|
||||
|
||||
if (sample->seq & 1) {
|
||||
/* copy from reserved sample to a new one... */
|
||||
bpf_ringbuf_output(&ringbuf, sample, sizeof(*sample), flags);
|
||||
/* ...and then discard reserved sample */
|
||||
bpf_ringbuf_discard(sample, flags);
|
||||
__sync_fetch_and_add(&discarded, 1);
|
||||
} else {
|
||||
bpf_ringbuf_submit(sample, flags);
|
||||
}
|
||||
|
||||
avail_data = bpf_ringbuf_query(&ringbuf, BPF_RB_AVAIL_DATA);
|
||||
ring_size = bpf_ringbuf_query(&ringbuf, BPF_RB_RING_SIZE);
|
||||
cons_pos = bpf_ringbuf_query(&ringbuf, BPF_RB_CONS_POS);
|
||||
prod_pos = bpf_ringbuf_query(&ringbuf, BPF_RB_PROD_POS);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
// Copyright (c) 2020 Facebook
|
||||
|
||||
#include <linux/bpf.h>
|
||||
#include <bpf/bpf_helpers.h>
|
||||
|
||||
char _license[] SEC("license") = "GPL";
|
||||
|
||||
struct sample {
|
||||
int pid;
|
||||
int seq;
|
||||
long value;
|
||||
char comm[16];
|
||||
};
|
||||
|
||||
struct ringbuf_map {
|
||||
__uint(type, BPF_MAP_TYPE_RINGBUF);
|
||||
__uint(max_entries, 1 << 12);
|
||||
} ringbuf1 SEC(".maps"),
|
||||
ringbuf2 SEC(".maps");
|
||||
|
||||
struct {
|
||||
__uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
|
||||
__uint(max_entries, 4);
|
||||
__type(key, int);
|
||||
__array(values, struct ringbuf_map);
|
||||
} ringbuf_arr SEC(".maps") = {
|
||||
.values = {
|
||||
[0] = &ringbuf1,
|
||||
[2] = &ringbuf2,
|
||||
},
|
||||
};
|
||||
|
||||
/* inputs */
|
||||
int pid = 0;
|
||||
int target_ring = 0;
|
||||
long value = 0;
|
||||
|
||||
/* outputs */
|
||||
long total = 0;
|
||||
long dropped = 0;
|
||||
long skipped = 0;
|
||||
|
||||
SEC("tp/syscalls/sys_enter_getpgid")
|
||||
int test_ringbuf(void *ctx)
|
||||
{
|
||||
int cur_pid = bpf_get_current_pid_tgid() >> 32;
|
||||
struct sample *sample;
|
||||
void *rb;
|
||||
int zero = 0;
|
||||
|
||||
if (cur_pid != pid)
|
||||
return 0;
|
||||
|
||||
rb = bpf_map_lookup_elem(&ringbuf_arr, &target_ring);
|
||||
if (!rb) {
|
||||
skipped += 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
sample = bpf_ringbuf_reserve(rb, sizeof(*sample), 0);
|
||||
if (!sample) {
|
||||
dropped += 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
sample->pid = pid;
|
||||
bpf_get_current_comm(sample->comm, sizeof(sample->comm));
|
||||
sample->value = value;
|
||||
|
||||
sample->seq = total;
|
||||
total += 1;
|
||||
|
||||
bpf_ringbuf_submit(sample, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue