iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'test_progs-stdio'

Browse Source 
Stanislav Fomichev says:

====================
I was looking into converting test_sockops* to test_progs framework
and that requires using cgroup_helpers.c which rely on stdio/stderr.
Let's use open_memstream to override stdout into buffer during
subtests instead of custom test_{v,}printf wrappers. That lets
us continue to use stdio in the subtests and dump it on failure
if required.

That would also fix bpf_find_map which currently uses printf to
signal failure (missed during test_printf conversion).
====================

Signed-off-by: Alexei Starovoitov <ast@kernel.org>
This commit is contained in:
Alexei Starovoitov 2019-08-06 17:17:52 -07:00
commit 682cdbdc21
10 changed files with 84 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c
View File

@ -5,13 +5,13 @@ static int libbpf_debug_print(enum libbpf_print_level level,
const char *format, va_list args)
{
if (level != LIBBPF_DEBUG) {
test__vprintf(format, args);
vprintf(format, args);
return 0;
}
if (!strstr(format, "verifier log"))
return 0;
test__vprintf("%s", args);
vprintf("%s", args);
return 0;
}

2
tools/testing/selftests/bpf/prog_tests/l4lb_all.c
View File

@ -74,7 +74,7 @@ static void test_l4lb(const char *file)
}
if (bytes != MAGIC_BYTES * NUM_ITER * 2 || pkts != NUM_ITER * 2) {
error_cnt++;
test__printf("test_l4lb:FAIL:stats %lld %lld\n", bytes, pkts);
printf("test_l4lb:FAIL:stats %lld %lld\n", bytes, pkts);
}
out:
bpf_object__close(obj);

10
tools/testing/selftests/bpf/prog_tests/map_lock.c
View File

@ -9,12 +9,12 @@ static void *parallel_map_access(void *arg)
for (i = 0; i < 10000; i++) {
err = bpf_map_lookup_elem_flags(map_fd, &key, vars, BPF_F_LOCK);
if (err) {
test__printf("lookup failed\n");
printf("lookup failed\n");
error_cnt++;
goto out;
}
if (vars[0] != 0) {
test__printf("lookup #%d var[0]=%d\n", i, vars[0]);
printf("lookup #%d var[0]=%d\n", i, vars[0]);
error_cnt++;
goto out;
}
@ -22,8 +22,8 @@ static void *parallel_map_access(void *arg)
for (j = 2; j < 17; j++) {
if (vars[j] == rnd)
continue;
test__printf("lookup #%d var[1]=%d var[%d]=%d\n",
i, rnd, j, vars[j]);
printf("lookup #%d var[1]=%d var[%d]=%d\n",
i, rnd, j, vars[j]);
error_cnt++;
goto out;
}
@ -43,7 +43,7 @@ void test_map_lock(void)
err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
if (err) {
test__printf("test_map_lock:bpf_prog_load errno %d\n", errno);
printf("test_map_lock:bpf_prog_load errno %d\n", errno);
goto close_prog;
}
map_fd[0] = bpf_find_map(__func__, obj, "hash_map");

4
tools/testing/selftests/bpf/prog_tests/send_signal.c
View File

@ -202,8 +202,8 @@ static int test_send_signal_nmi(void)
-1 /* cpu */, -1 /* group_fd */, 0 /* flags */);
if (pmu_fd == -1) {
if (errno == ENOENT) {
test__printf("%s:SKIP:no PERF_COUNT_HW_CPU_CYCLES\n",
__func__);
printf("%s:SKIP:no PERF_COUNT_HW_CPU_CYCLES\n",
__func__);
return 0;
}
/* Let the test fail with a more informative message */

2
tools/testing/selftests/bpf/prog_tests/spinlock.c
View File

@ -12,7 +12,7 @@ void test_spinlock(void)
err = bpf_prog_load(file, BPF_PROG_TYPE_CGROUP_SKB, &obj, &prog_fd);
if (err) {
test__printf("test_spin_lock:bpf_prog_load errno %d\n", errno);
printf("test_spin_lock:bpf_prog_load errno %d\n", errno);
goto close_prog;
}
for (i = 0; i < 4; i++)

4
tools/testing/selftests/bpf/prog_tests/stacktrace_build_id.c
View File

@ -109,8 +109,8 @@ retry:
if (build_id_matches < 1 && retry--) {
bpf_link__destroy(link);
bpf_object__close(obj);
test__printf("%s:WARN:Didn't find expected build ID from the map, retrying\n",
__func__);
printf("%s:WARN:Didn't find expected build ID from the map, retrying\n",
__func__);
goto retry;
}

4
tools/testing/selftests/bpf/prog_tests/stacktrace_build_id_nmi.c
View File

@ -140,8 +140,8 @@ retry:
if (build_id_matches < 1 && retry--) {
bpf_link__destroy(link);
bpf_object__close(obj);
test__printf("%s:WARN:Didn't find expected build ID from the map, retrying\n",
__func__);
printf("%s:WARN:Didn't find expected build ID from the map, retrying\n",
__func__);
goto retry;
}

4
tools/testing/selftests/bpf/prog_tests/xdp_noinline.c
View File

@ -75,8 +75,8 @@ void test_xdp_noinline(void)
}
if (bytes != MAGIC_BYTES * NUM_ITER * 2 || pkts != NUM_ITER * 2) {
error_cnt++;
test__printf("test_xdp_noinline:FAIL:stats %lld %lld\n",
bytes, pkts);
printf("test_xdp_noinline:FAIL:stats %lld %lld\n",
bytes, pkts);
}
out:
bpf_object__close(obj);

131
tools/testing/selftests/bpf/test_progs.c
View File

@ -40,14 +40,20 @@ static bool should_run(struct test_selector *sel, int num, const char *name)
static void dump_test_log(const struct prog_test_def *test, bool failed)
{
if (stdout == env.stdout)
return;
fflush(stdout); /* exports env.log_buf & env.log_cnt */
if (env.verbose || test->force_log || failed) {
if (env.log_cnt) {
fprintf(stdout, "%s", env.log_buf);
fprintf(env.stdout, "%s", env.log_buf);
if (env.log_buf[env.log_cnt - 1] != '\n')
fprintf(stdout, "\n");
fprintf(env.stdout, "\n");
}
}
env.log_cnt = 0;
fseeko(stdout, 0, SEEK_SET); /* rewind */
}
void test__end_subtest()
@ -62,7 +68,7 @@ void test__end_subtest()
dump_test_log(test, sub_error_cnt);
printf("#%d/%d %s:%s\n",
fprintf(env.stdout, "#%d/%d %s:%s\n",
test->test_num, test->subtest_num,
test->subtest_name, sub_error_cnt ? "FAIL" : "OK");
}
@ -79,7 +85,8 @@ bool test__start_subtest(const char *name)
test->subtest_num++;
if (!name || !name[0]) {
fprintf(stderr, "Subtest #%d didn't provide sub-test name!\n",
fprintf(env.stderr,
"Subtest #%d didn't provide sub-test name!\n",
test->subtest_num);
return false;
}
@ -98,66 +105,6 @@ void test__force_log() {
env.test->force_log = true;
}
void test__vprintf(const char *fmt, va_list args)
{
size_t rem_sz;
int ret = 0;
if (env.verbose || (env.test && env.test->force_log)) {
vfprintf(stderr, fmt, args);
return;
}
try_again:
rem_sz = env.log_cap - env.log_cnt;
if (rem_sz) {
va_list ap;
va_copy(ap, args);
/* we reserved extra byte for \0 at the end */
ret = vsnprintf(env.log_buf + env.log_cnt, rem_sz + 1, fmt, ap);
va_end(ap);
if (ret < 0) {
env.log_buf[env.log_cnt] = '\0';
fprintf(stderr, "failed to log w/ fmt '%s'\n", fmt);
return;
}
}
if (!rem_sz || ret > rem_sz) {
size_t new_sz = env.log_cap * 3 / 2;
char *new_buf;
if (new_sz < 4096)
new_sz = 4096;
if (new_sz < ret + env.log_cnt)
new_sz = ret + env.log_cnt;
/* +1 for guaranteed space for terminating \0 */
new_buf = realloc(env.log_buf, new_sz + 1);
if (!new_buf) {
fprintf(stderr, "failed to realloc log buffer: %d\n",
errno);
return;
}
env.log_buf = new_buf;
env.log_cap = new_sz;
goto try_again;
}
env.log_cnt += ret;
}
void test__printf(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
test__vprintf(fmt, args);
va_end(args);
}
struct ipv4_packet pkt_v4 = {
.eth.h_proto = __bpf_constant_htons(ETH_P_IP),
.iph.ihl = 5,
@ -331,7 +278,7 @@ enum ARG_KEYS {
ARG_VERIFIER_STATS = 's',
ARG_VERBOSE = 'v',
};
static const struct argp_option opts[] = {
{ "num", ARG_TEST_NUM, "NUM", 0,
"Run test number NUM only " },
@ -349,7 +296,7 @@ static int libbpf_print_fn(enum libbpf_print_level level,
{
if (!env.very_verbose && level == LIBBPF_DEBUG)
return 0;
test__vprintf(format, args);
vprintf(format, args);
return 0;
}
@ -477,6 +424,48 @@ static error_t parse_arg(int key, char *arg, struct argp_state *state)
return 0;
}
static void stdio_hijack(void)
{
#ifdef __GLIBC__
env.stdout = stdout;
env.stderr = stderr;
if (env.verbose) {
/* nothing to do, output to stdout by default */
return;
}
/* stdout and stderr -> buffer */
fflush(stdout);
stdout = open_memstream(&env.log_buf, &env.log_cnt);
if (!stdout) {
stdout = env.stdout;
perror("open_memstream");
return;
}
stderr = stdout;
#endif
}
static void stdio_restore(void)
{
#ifdef __GLIBC__
if (stdout == env.stdout)
return;
fclose(stdout);
free(env.log_buf);
env.log_buf = NULL;
env.log_cnt = 0;
stdout = env.stdout;
stderr = env.stderr;
#endif
}
int main(int argc, char **argv)
{
static const struct argp argp = {
@ -496,6 +485,7 @@ int main(int argc, char **argv)
env.jit_enabled = is_jit_enabled();
stdio_hijack();
for (i = 0; i < prog_test_cnt; i++) {
struct prog_test_def *test = &prog_test_defs[i];
int old_pass_cnt = pass_cnt;
@ -523,13 +513,14 @@ int main(int argc, char **argv)
dump_test_log(test, test->error_cnt);
printf("#%d %s:%s\n", test->test_num, test->test_name,
test->error_cnt ? "FAIL" : "OK");
fprintf(env.stdout, "#%d %s:%s\n",
test->test_num, test->test_name,
test->error_cnt ? "FAIL" : "OK");
}
stdio_restore();
printf("Summary: %d/%d PASSED, %d FAILED\n",
env.succ_cnt, env.sub_succ_cnt, env.fail_cnt);
free(env.log_buf);
free(env.test_selector.num_set);
free(env.subtest_selector.num_set);

13
tools/testing/selftests/bpf/test_progs.h
View File

@ -56,9 +56,10 @@ struct test_env {
bool jit_enabled;
struct prog_test_def *test;
FILE *stdout;
FILE *stderr;
char *log_buf;
size_t log_cnt;
size_t log_cap;
int succ_cnt; /* successful tests */
int sub_succ_cnt; /* successful sub-tests */
@ -69,8 +70,6 @@ extern int error_cnt;
extern int pass_cnt;
extern struct test_env env;
extern void test__printf(const char *fmt, ...);
extern void test__vprintf(const char *fmt, va_list args);
extern void test__force_log();
extern bool test__start_subtest(const char *name);
@ -96,12 +95,12 @@ extern struct ipv6_packet pkt_v6;
int __ret = !!(condition); \
if (__ret) { \
error_cnt++; \
test__printf("%s:FAIL:%s ", __func__, tag); \
test__printf(format); \
printf("%s:FAIL:%s ", __func__, tag); \
printf(format); \
} else { \
pass_cnt++; \
test__printf("%s:PASS:%s %d nsec\n", \
__func__, tag, duration); \
printf("%s:PASS:%s %d nsec\n", \
__func__, tag, duration); \
} \
__ret; \
})