Commit d3813ea1 authored by Alexander Duyck's avatar Alexander Duyck Committed by Alexei Starovoitov

selftests/bpf: Replace EXPECT_EQ with ASSERT_EQ and refactor verify_results

There is already logic in test_progs.h for asserting that a value is
expected to be another value. So instead of reinventing it we should just
make use of ASSERT_EQ in tcpbpf_user.c. This will allow for better
debugging and integrates much more closely with the test_progs framework.

In addition we can refactor the code a bit to merge together the two
verify functions and tie them together into a single function. Doing this
helps to clean the code up a bit and makes it more readable as all the
verification is now done in one function.

Lastly we can relocate the verification to the end of the run_test since it
is logically part of the test itself. With this we can drop the need for a
return value from run_test since verification becomes the last step of the
call and then immediately following is the tear down of the test setup.
Signed-off-by: default avatarAlexander Duyck <alexanderduyck@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Acked-by: default avatarMartin KaFai Lau <kafai@fb.com>
Link: https://lore.kernel.org/bpf/160443930408.1086697.16101205859962113000.stgit@localhost.localdomain
parent 247f0ec3
// SPDX-License-Identifier: GPL-2.0 // SPDX-License-Identifier: GPL-2.0
#include <inttypes.h>
#include <test_progs.h> #include <test_progs.h>
#include <network_helpers.h> #include <network_helpers.h>
...@@ -10,66 +9,56 @@ ...@@ -10,66 +9,56 @@
static __u32 duration; static __u32 duration;
#define EXPECT_EQ(expected, actual, fmt) \ static void verify_result(int map_fd, int sock_map_fd)
do { \
if ((expected) != (actual)) { \
printf(" Value of: " #actual "\n" \
" Actual: %" fmt "\n" \
" Expected: %" fmt "\n", \
(actual), (expected)); \
ret--; \
} \
} while (0)
int verify_result(const struct tcpbpf_globals *result)
{ {
__u32 expected_events; __u32 expected_events = ((1 << BPF_SOCK_OPS_TIMEOUT_INIT) |
int ret = 0; (1 << BPF_SOCK_OPS_RWND_INIT) |
(1 << BPF_SOCK_OPS_TCP_CONNECT_CB) |
expected_events = ((1 << BPF_SOCK_OPS_TIMEOUT_INIT) | (1 << BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB) |
(1 << BPF_SOCK_OPS_RWND_INIT) | (1 << BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB) |
(1 << BPF_SOCK_OPS_TCP_CONNECT_CB) | (1 << BPF_SOCK_OPS_NEEDS_ECN) |
(1 << BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB) | (1 << BPF_SOCK_OPS_STATE_CB) |
(1 << BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB) | (1 << BPF_SOCK_OPS_TCP_LISTEN_CB));
(1 << BPF_SOCK_OPS_NEEDS_ECN) | struct tcpbpf_globals result;
(1 << BPF_SOCK_OPS_STATE_CB) | __u32 key = 0;
(1 << BPF_SOCK_OPS_TCP_LISTEN_CB)); int res, rv;
EXPECT_EQ(expected_events, result->event_map, "#" PRIx32); rv = bpf_map_lookup_elem(map_fd, &key, &result);
EXPECT_EQ(501ULL, result->bytes_received, "llu"); if (CHECK(rv, "bpf_map_lookup_elem(map_fd)", "err:%d errno:%d",
EXPECT_EQ(1002ULL, result->bytes_acked, "llu"); rv, errno))
EXPECT_EQ(1, result->data_segs_in, PRIu32); return;
EXPECT_EQ(1, result->data_segs_out, PRIu32);
EXPECT_EQ(0x80, result->bad_cb_test_rv, PRIu32); /* check global map */
EXPECT_EQ(0, result->good_cb_test_rv, PRIu32); CHECK(expected_events != result.event_map, "event_map",
EXPECT_EQ(1, result->num_listen, PRIu32); "unexpected event_map: actual 0x%08x != expected 0x%08x\n",
result.event_map, expected_events);
ASSERT_EQ(result.bytes_received, 501, "bytes_received");
ASSERT_EQ(result.bytes_acked, 1002, "bytes_acked");
ASSERT_EQ(result.data_segs_in, 1, "data_segs_in");
ASSERT_EQ(result.data_segs_out, 1, "data_segs_out");
ASSERT_EQ(result.bad_cb_test_rv, 0x80, "bad_cb_test_rv");
ASSERT_EQ(result.good_cb_test_rv, 0, "good_cb_test_rv");
ASSERT_EQ(result.num_listen, 1, "num_listen");
/* 3 comes from one listening socket + both ends of the connection */ /* 3 comes from one listening socket + both ends of the connection */
EXPECT_EQ(3, result->num_close_events, PRIu32); ASSERT_EQ(result.num_close_events, 3, "num_close_events");
return ret;
}
int verify_sockopt_result(int sock_map_fd)
{
__u32 key = 0;
int ret = 0;
int res;
int rv;
/* check setsockopt for SAVE_SYN */ /* check setsockopt for SAVE_SYN */
rv = bpf_map_lookup_elem(sock_map_fd, &key, &res); rv = bpf_map_lookup_elem(sock_map_fd, &key, &res);
EXPECT_EQ(0, rv, "d"); CHECK(rv, "bpf_map_lookup_elem(sock_map_fd)", "err:%d errno:%d",
EXPECT_EQ(0, res, "d"); rv, errno);
key = 1; ASSERT_EQ(res, 0, "bpf_setsockopt(TCP_SAVE_SYN)");
/* check getsockopt for SAVED_SYN */ /* check getsockopt for SAVED_SYN */
key = 1;
rv = bpf_map_lookup_elem(sock_map_fd, &key, &res); rv = bpf_map_lookup_elem(sock_map_fd, &key, &res);
EXPECT_EQ(0, rv, "d"); CHECK(rv, "bpf_map_lookup_elem(sock_map_fd)", "err:%d errno:%d",
EXPECT_EQ(1, res, "d"); rv, errno);
return ret; ASSERT_EQ(res, 1, "bpf_getsockopt(TCP_SAVED_SYN)");
} }
static int run_test(void) static void run_test(int map_fd, int sock_map_fd)
{ {
int listen_fd = -1, cli_fd = -1, accept_fd = -1; int listen_fd = -1, cli_fd = -1, accept_fd = -1;
char buf[1000]; char buf[1000];
...@@ -135,18 +124,17 @@ static int run_test(void) ...@@ -135,18 +124,17 @@ static int run_test(void)
if (listen_fd != -1) if (listen_fd != -1)
close(listen_fd); close(listen_fd);
return err; if (!err)
verify_result(map_fd, sock_map_fd);
} }
void test_tcpbpf_user(void) void test_tcpbpf_user(void)
{ {
const char *file = "test_tcpbpf_kern.o"; const char *file = "test_tcpbpf_kern.o";
int prog_fd, map_fd, sock_map_fd; int prog_fd, map_fd, sock_map_fd;
struct tcpbpf_globals g = {0};
int error = EXIT_FAILURE; int error = EXIT_FAILURE;
struct bpf_object *obj; struct bpf_object *obj;
int cg_fd = -1; int cg_fd = -1;
__u32 key = 0;
int rv; int rv;
cg_fd = test__join_cgroup(CG_NAME); cg_fd = test__join_cgroup(CG_NAME);
...@@ -173,24 +161,7 @@ void test_tcpbpf_user(void) ...@@ -173,24 +161,7 @@ void test_tcpbpf_user(void)
if (sock_map_fd < 0) if (sock_map_fd < 0)
goto err; goto err;
if (run_test()) run_test(map_fd, sock_map_fd);
goto err;
rv = bpf_map_lookup_elem(map_fd, &key, &g);
if (rv != 0) {
printf("FAILED: bpf_map_lookup_elem returns %d\n", rv);
goto err;
}
if (verify_result(&g)) {
printf("FAILED: Wrong stats\n");
goto err;
}
if (verify_sockopt_result(sock_map_fd)) {
printf("FAILED: Wrong sockopt stats\n");
goto err;
}
error = 0; error = 0;
err: err:
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment