Commit 6879c042 authored by Yonghong Song's avatar Yonghong Song Committed by Alexei Starovoitov
Browse files

tools/bpf: selftests: Add bpf_iter selftests 



The added test includes the following subtests:
  - test verifier change for btf_id_or_null
  - test load/create_iter/read for
    ipv6_route/netlink/bpf_map/task/task_file
  - test anon bpf iterator
  - test anon bpf iterator reading one char at a time
  - test file bpf iterator
  - test overflow (single bpf program output not overflow)
  - test overflow (single bpf program output overflows)
  - test bpf prog returning 1

The ipv6_route tests the following verifier change
  - access fields in the variable length array of the structure.

The netlink load tests the following verifier change
  - put a btf_id ptr value in a stack and accessible to
    tracing/iter programs.

The anon bpf iterator also tests link auto attach through skeleton.

  $ test_progs -n 2
  #2/1 btf_id_or_null:OK
  #2/2 ipv6_route:OK
  #2/3 netlink:OK
  #2/4 bpf_map:OK
  #2/5 task:OK
  #2/6 task_file:OK
  #2/7 anon:OK
  #2/8 anon-read-one-char:OK
  #2/9 file:OK
  #2/10 overflow:OK
  #2/11 overflow-e2big:OK
  #2/12 prog-ret-1:OK
  #2 bpf_iter:OK
  Summary: 1/12 PASSED, 0 SKIPPED, 0 FAILED

Signed-off-by: default avatarYonghong Song <yhs@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Acked-by: default avatarAndrii Nakryiko <andriin@fb.com>
Link: https://lore.kernel.org/bpf/20200509175923.2477637-1-yhs@fb.com
parent acf61631

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

0 → 100644
+409 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#include <test_progs.h>

#include "bpf_iter_ipv6_route.skel.h"

#include "bpf_iter_netlink.skel.h"

#include "bpf_iter_bpf_map.skel.h"

#include "bpf_iter_task.skel.h"

#include "bpf_iter_task_file.skel.h"

#include "bpf_iter_test_kern1.skel.h"

#include "bpf_iter_test_kern2.skel.h"

#include "bpf_iter_test_kern3.skel.h"

#include "bpf_iter_test_kern4.skel.h"



static int duration;



static void test_btf_id_or_null(void)

{

	struct bpf_iter_test_kern3 *skel;



	skel = bpf_iter_test_kern3__open_and_load();

	if (CHECK(skel, "bpf_iter_test_kern3__open_and_load",

		  "skeleton open_and_load unexpectedly succeeded\n")) {

		bpf_iter_test_kern3__destroy(skel);

		return;

	}

}



static void do_dummy_read(struct bpf_program *prog)

{

	struct bpf_link *link;

	char buf[16] = {};

	int iter_fd, len;



	link = bpf_program__attach_iter(prog, NULL);

	if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))

		return;



	iter_fd = bpf_iter_create(bpf_link__fd(link));

	if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))

		goto free_link;



	/* not check contents, but ensure read() ends without error */

	while ((len = read(iter_fd, buf, sizeof(buf))) > 0)

		;

	CHECK(len < 0, "read", "read failed: %s\n", strerror(errno));



	close(iter_fd);



free_link:

	bpf_link__destroy(link);

}



static void test_ipv6_route(void)

{

	struct bpf_iter_ipv6_route *skel;



	skel = bpf_iter_ipv6_route__open_and_load();

	if (CHECK(!skel, "bpf_iter_ipv6_route__open_and_load",

		  "skeleton open_and_load failed\n"))

		return;



	do_dummy_read(skel->progs.dump_ipv6_route);



	bpf_iter_ipv6_route__destroy(skel);

}



static void test_netlink(void)

{

	struct bpf_iter_netlink *skel;



	skel = bpf_iter_netlink__open_and_load();

	if (CHECK(!skel, "bpf_iter_netlink__open_and_load",

		  "skeleton open_and_load failed\n"))

		return;



	do_dummy_read(skel->progs.dump_netlink);



	bpf_iter_netlink__destroy(skel);

}



static void test_bpf_map(void)

{

	struct bpf_iter_bpf_map *skel;



	skel = bpf_iter_bpf_map__open_and_load();

	if (CHECK(!skel, "bpf_iter_bpf_map__open_and_load",

		  "skeleton open_and_load failed\n"))

		return;



	do_dummy_read(skel->progs.dump_bpf_map);



	bpf_iter_bpf_map__destroy(skel);

}



static void test_task(void)

{

	struct bpf_iter_task *skel;



	skel = bpf_iter_task__open_and_load();

	if (CHECK(!skel, "bpf_iter_task__open_and_load",

		  "skeleton open_and_load failed\n"))

		return;



	do_dummy_read(skel->progs.dump_task);



	bpf_iter_task__destroy(skel);

}



static void test_task_file(void)

{

	struct bpf_iter_task_file *skel;



	skel = bpf_iter_task_file__open_and_load();

	if (CHECK(!skel, "bpf_iter_task_file__open_and_load",

		  "skeleton open_and_load failed\n"))

		return;



	do_dummy_read(skel->progs.dump_task_file);



	bpf_iter_task_file__destroy(skel);

}



/* The expected string is less than 16 bytes */

static int do_read_with_fd(int iter_fd, const char *expected,

			   bool read_one_char)

{

	int err = -1, len, read_buf_len, start;

	char buf[16] = {};



	read_buf_len = read_one_char ? 1 : 16;

	start = 0;

	while ((len = read(iter_fd, buf + start, read_buf_len)) > 0) {

		start += len;

		if (CHECK(start >= 16, "read", "read len %d\n", len))

			return -1;

		read_buf_len = read_one_char ? 1 : 16 - start;

	}

	if (CHECK(len < 0, "read", "read failed: %s\n", strerror(errno)))

		return -1;



	err = strcmp(buf, expected);

	if (CHECK(err, "read", "incorrect read result: buf %s, expected %s\n",

		  buf, expected))

		return -1;



	return 0;

}



static void test_anon_iter(bool read_one_char)

{

	struct bpf_iter_test_kern1 *skel;

	struct bpf_link *link;

	int iter_fd, err;



	skel = bpf_iter_test_kern1__open_and_load();

	if (CHECK(!skel, "bpf_iter_test_kern1__open_and_load",

		  "skeleton open_and_load failed\n"))

		return;



	err = bpf_iter_test_kern1__attach(skel);

	if (CHECK(err, "bpf_iter_test_kern1__attach",

		  "skeleton attach failed\n")) {

		goto out;

	}



	link = skel->links.dump_task;

	iter_fd = bpf_iter_create(bpf_link__fd(link));

	if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))

		goto out;



	do_read_with_fd(iter_fd, "abcd", read_one_char);

	close(iter_fd);



out:

	bpf_iter_test_kern1__destroy(skel);

}



static int do_read(const char *path, const char *expected)

{

	int err, iter_fd;



	iter_fd = open(path, O_RDONLY);

	if (CHECK(iter_fd < 0, "open", "open %s failed: %s\n",

		  path, strerror(errno)))

		return -1;



	err = do_read_with_fd(iter_fd, expected, false);

	close(iter_fd);

	return err;

}



static void test_file_iter(void)

{

	const char *path = "/sys/fs/bpf/bpf_iter_test1";

	struct bpf_iter_test_kern1 *skel1;

	struct bpf_iter_test_kern2 *skel2;

	struct bpf_link *link;

	int err;



	skel1 = bpf_iter_test_kern1__open_and_load();

	if (CHECK(!skel1, "bpf_iter_test_kern1__open_and_load",

		  "skeleton open_and_load failed\n"))

		return;



	link = bpf_program__attach_iter(skel1->progs.dump_task, NULL);

	if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))

		goto out;



	/* unlink this path if it exists. */

	unlink(path);



	err = bpf_link__pin(link, path);

	if (CHECK(err, "pin_iter", "pin_iter to %s failed: %d\n", path, err))

		goto free_link;



	err = do_read(path, "abcd");

	if (err)

		goto unlink_path;



	/* file based iterator seems working fine. Let us a link update

	 * of the underlying link and `cat` the iterator again, its content

	 * should change.

	 */

	skel2 = bpf_iter_test_kern2__open_and_load();

	if (CHECK(!skel2, "bpf_iter_test_kern2__open_and_load",

		  "skeleton open_and_load failed\n"))

		goto unlink_path;



	err = bpf_link__update_program(link, skel2->progs.dump_task);

	if (CHECK(err, "update_prog", "update_prog failed\n"))

		goto destroy_skel2;



	do_read(path, "ABCD");



destroy_skel2:

	bpf_iter_test_kern2__destroy(skel2);

unlink_path:

	unlink(path);

free_link:

	bpf_link__destroy(link);

out:

	bpf_iter_test_kern1__destroy(skel1);

}



static void test_overflow(bool test_e2big_overflow, bool ret1)

{

	__u32 map_info_len, total_read_len, expected_read_len;

	int err, iter_fd, map1_fd, map2_fd, len;

	struct bpf_map_info map_info = {};

	struct bpf_iter_test_kern4 *skel;

	struct bpf_link *link;

	__u32 page_size;

	char *buf;



	skel = bpf_iter_test_kern4__open();

	if (CHECK(!skel, "bpf_iter_test_kern4__open",

		  "skeleton open failed\n"))

		return;



	/* create two maps: bpf program will only do bpf_seq_write

	 * for these two maps. The goal is one map output almost

	 * fills seq_file buffer and then the other will trigger

	 * overflow and needs restart.

	 */

	map1_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, 4, 8, 1, 0);

	if (CHECK(map1_fd < 0, "bpf_create_map",

		  "map_creation failed: %s\n", strerror(errno)))

		goto out;

	map2_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, 4, 8, 1, 0);

	if (CHECK(map2_fd < 0, "bpf_create_map",

		  "map_creation failed: %s\n", strerror(errno)))

		goto free_map1;



	/* bpf_seq_printf kernel buffer is one page, so one map

	 * bpf_seq_write will mostly fill it, and the other map

	 * will partially fill and then trigger overflow and need

	 * bpf_seq_read restart.

	 */

	page_size = sysconf(_SC_PAGE_SIZE);



	if (test_e2big_overflow) {

		skel->rodata->print_len = (page_size + 8) / 8;

		expected_read_len = 2 * (page_size + 8);

	} else if (!ret1) {

		skel->rodata->print_len = (page_size - 8) / 8;

		expected_read_len = 2 * (page_size - 8);

	} else {

		skel->rodata->print_len = 1;

		expected_read_len = 2 * 8;

	}

	skel->rodata->ret1 = ret1;



	if (CHECK(bpf_iter_test_kern4__load(skel),

		  "bpf_iter_test_kern4__load", "skeleton load failed\n"))

		goto free_map2;



	/* setup filtering map_id in bpf program */

	map_info_len = sizeof(map_info);

	err = bpf_obj_get_info_by_fd(map1_fd, &map_info, &map_info_len);

	if (CHECK(err, "get_map_info", "get map info failed: %s\n",

		  strerror(errno)))

		goto free_map2;

	skel->bss->map1_id = map_info.id;



	err = bpf_obj_get_info_by_fd(map2_fd, &map_info, &map_info_len);

	if (CHECK(err, "get_map_info", "get map info failed: %s\n",

		  strerror(errno)))

		goto free_map2;

	skel->bss->map2_id = map_info.id;



	link = bpf_program__attach_iter(skel->progs.dump_bpf_map, NULL);

	if (CHECK(IS_ERR(link), "attach_iter", "attach_iter failed\n"))

		goto free_map2;



	iter_fd = bpf_iter_create(bpf_link__fd(link));

	if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))

		goto free_link;



	buf = malloc(expected_read_len);

	if (!buf)

		goto close_iter;



	/* do read */

	total_read_len = 0;

	if (test_e2big_overflow) {

		while ((len = read(iter_fd, buf, expected_read_len)) > 0)

			total_read_len += len;



		CHECK(len != -1 || errno != E2BIG, "read",

		      "expected ret -1, errno E2BIG, but get ret %d, error %s\n",

			  len, strerror(errno));

		goto free_buf;

	} else if (!ret1) {

		while ((len = read(iter_fd, buf, expected_read_len)) > 0)

			total_read_len += len;



		if (CHECK(len < 0, "read", "read failed: %s\n",

			  strerror(errno)))

			goto free_buf;

	} else {

		do {

			len = read(iter_fd, buf, expected_read_len);

			if (len > 0)

				total_read_len += len;

		} while (len > 0 || len == -EAGAIN);



		if (CHECK(len < 0, "read", "read failed: %s\n",

			  strerror(errno)))

			goto free_buf;

	}



	if (CHECK(total_read_len != expected_read_len, "read",

		  "total len %u, expected len %u\n", total_read_len,

		  expected_read_len))

		goto free_buf;



	if (CHECK(skel->bss->map1_accessed != 1, "map1_accessed",

		  "expected 1 actual %d\n", skel->bss->map1_accessed))

		goto free_buf;



	if (CHECK(skel->bss->map2_accessed != 2, "map2_accessed",

		  "expected 2 actual %d\n", skel->bss->map2_accessed))

		goto free_buf;



	CHECK(skel->bss->map2_seqnum1 != skel->bss->map2_seqnum2,

	      "map2_seqnum", "two different seqnum %lld %lld\n",

	      skel->bss->map2_seqnum1, skel->bss->map2_seqnum2);



free_buf:

	free(buf);

close_iter:

	close(iter_fd);

free_link:

	bpf_link__destroy(link);

free_map2:

	close(map2_fd);

free_map1:

	close(map1_fd);

out:

	bpf_iter_test_kern4__destroy(skel);

}



void test_bpf_iter(void)

{

	if (test__start_subtest("btf_id_or_null"))

		test_btf_id_or_null();

	if (test__start_subtest("ipv6_route"))

		test_ipv6_route();

	if (test__start_subtest("netlink"))

		test_netlink();

	if (test__start_subtest("bpf_map"))

		test_bpf_map();

	if (test__start_subtest("task"))

		test_task();

	if (test__start_subtest("task_file"))

		test_task_file();

	if (test__start_subtest("anon"))

		test_anon_iter(false);

	if (test__start_subtest("anon-read-one-char"))

		test_anon_iter(true);

	if (test__start_subtest("file"))

		test_file_iter();

	if (test__start_subtest("overflow"))

		test_overflow(false, false);

	if (test__start_subtest("overflow-e2big"))

		test_overflow(true, false);

	if (test__start_subtest("prog-ret-1"))

		test_overflow(false, true);

}

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

0 → 100644
+4 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#define START_CHAR 'a'

#include "bpf_iter_test_kern_common.h"

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

0 → 100644
+4 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#define START_CHAR 'A'

#include "bpf_iter_test_kern_common.h"

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

0 → 100644
+18 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#include "vmlinux.h"

#include <bpf/bpf_helpers.h>



char _license[] SEC("license") = "GPL";



SEC("iter/task")

int dump_task(struct bpf_iter__task *ctx)

{

	struct seq_file *seq = ctx->meta->seq;

	struct task_struct *task = ctx->task;

	int tgid;



	tgid = task->tgid;

	bpf_seq_write(seq, &tgid, sizeof(tgid));

	return 0;

}

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

0 → 100644
+52 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2020 Facebook */

#include "vmlinux.h"

#include <bpf/bpf_helpers.h>



char _license[] SEC("license") = "GPL";



__u32 map1_id = 0, map2_id = 0;

__u32 map1_accessed = 0, map2_accessed = 0;

__u64 map1_seqnum = 0, map2_seqnum1 = 0, map2_seqnum2 = 0;



static volatile const __u32 print_len;

static volatile const __u32 ret1;



SEC("iter/bpf_map")

int dump_bpf_map(struct bpf_iter__bpf_map *ctx)

{

	struct seq_file *seq = ctx->meta->seq;

	struct bpf_map *map = ctx->map;

	__u64 seq_num;

	int i, ret = 0;



	if (map == (void *)0)

		return 0;



	/* only dump map1_id and map2_id */

	if (map->id != map1_id && map->id != map2_id)

		return 0;



	seq_num = ctx->meta->seq_num;

	if (map->id == map1_id) {

		map1_seqnum = seq_num;

		map1_accessed++;

	}



	if (map->id == map2_id) {

		if (map2_accessed == 0) {

			map2_seqnum1 = seq_num;

			if (ret1)

				ret = 1;

		} else {

			map2_seqnum2 = seq_num;

		}

		map2_accessed++;

	}



	/* fill seq_file buffer */

	for (i = 0; i < print_len; i++)

		bpf_seq_write(seq, &seq_num, sizeof(seq_num));



	return ret;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE