Commit cb1c9ddd authored by Andrii Nakryiko's avatar Andrii Nakryiko Committed by Alexei Starovoitov
Browse files

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: default avatarAndrii Nakryiko <andriin@fb.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20200529075424.3139988-4-andriin@fb.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent bf99c936

tools/testing/selftests/bpf/prog_tests/ringbuf.c

0 → 100644
+211 −0
Original line number Diff line number Diff line 
// 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);

}

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

0 → 100644
+102 −0
Original line number Diff line number Diff line 
// 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);

}

tools/testing/selftests/bpf/progs/test_ringbuf.c

0 → 100644
+78 −0
Original line number Diff line number Diff line 
// 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;

}

tools/testing/selftests/bpf/progs/test_ringbuf_multi.c

0 → 100644
+77 −0
Original line number Diff line number Diff line 
// 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;

}