Merge branch 'regular-expression-support-for-test-output-matching' (2807db78) · Commits · git / linux-net

tools/testing/selftests/bpf/progs/bpf_misc.h

+8 −3

Original line number	Diff line number	Diff line
		@@ -7,9 +7,9 @@
		*
		* The test_loader sequentially loads each program in a skeleton.
		* Programs could be loaded in privileged and unprivileged modes.
		* - __success, __failure, __msg imply privileged mode;
		* - __success_unpriv, __failure_unpriv, __msg_unpriv imply
		* unprivileged mode.
		* - __success, __failure, __msg, __regex imply privileged mode;
		* - __success_unpriv, __failure_unpriv, __msg_unpriv, __regex_unpriv
		* imply unprivileged mode.
		* If combination of privileged and unprivileged attributes is present
		* both modes are used. If none are present privileged mode is implied.
		*
		@@ -24,6 +24,9 @@
		* Multiple __msg attributes could be specified.
		* __msg_unpriv Same as __msg but for unprivileged mode.
		*
		* __regex Same as __msg, but using a regular expression.
		* __regex_unpriv Same as __msg_unpriv but using a regular expression.
		*
		* __success Expect program load success in privileged mode.
		* __success_unpriv Expect program load success in unprivileged mode.
		*
		@@ -59,10 +62,12 @@
		* __auxiliary_unpriv Same, but load program in unprivileged mode.
		*/
		#define __msg(msg) __attribute__((btf_decl_tag("comment:test_expect_msg=" msg)))
		#define __regex(regex) __attribute__((btf_decl_tag("comment:test_expect_regex=" regex)))
		#define __failure __attribute__((btf_decl_tag("comment:test_expect_failure")))
		#define __success __attribute__((btf_decl_tag("comment:test_expect_success")))
		#define __description(desc) __attribute__((btf_decl_tag("comment:test_description=" desc)))
		#define __msg_unpriv(msg) __attribute__((btf_decl_tag("comment:test_expect_msg_unpriv=" msg)))
		#define __regex_unpriv(regex) __attribute__((btf_decl_tag("comment:test_expect_regex_unpriv=" regex)))
		#define __failure_unpriv __attribute__((btf_decl_tag("comment:test_expect_failure_unpriv")))
		#define __success_unpriv __attribute__((btf_decl_tag("comment:test_expect_success_unpriv")))
		#define __log_level(lvl) __attribute__((btf_decl_tag("comment:test_log_level="#lvl)))

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

+3 −3

Original line number	Diff line number	Diff line
		@@ -964,7 +964,7 @@ int dynptr_invalidate_slice_reinit(void *ctx)
		* mem_or_null pointers.
		*/
		SEC("?raw_tp")
		__failure __msg("R1 type=scalar expected=percpu_ptr_")
		__failure __regex("R[0-9]+ type=scalar expected=percpu_ptr_")
		int dynptr_invalidate_slice_or_null(void *ctx)
		{
		struct bpf_dynptr ptr;
		@@ -982,7 +982,7 @@ int dynptr_invalidate_slice_or_null(void *ctx)

		/* Destruction of dynptr should also any slices obtained from it */
		SEC("?raw_tp")
		__failure __msg("R7 invalid mem access 'scalar'")
		__failure __regex("R[0-9]+ invalid mem access 'scalar'")
		int dynptr_invalidate_slice_failure(void *ctx)
		{
		struct bpf_dynptr ptr1;
		@@ -1069,7 +1069,7 @@ int dynptr_read_into_slot(void *ctx)

		/* bpf_dynptr_slice()s are read-only and cannot be written to */
		SEC("?tc")
		__failure __msg("R0 cannot write into rdonly_mem")
		__failure __regex("R[0-9]+ cannot write into rdonly_mem")
		int skb_invalid_slice_write(struct __sk_buff *skb)
		{
		struct bpf_dynptr ptr;

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

+1 −1

Original line number	Diff line number	Diff line
		@@ -105,7 +105,7 @@ long rbtree_api_remove_unadded_node(void *ctx)
		}

		SEC("?tc")
		__failure __msg("Unreleased reference id=3 alloc_insn=10")
		__failure __regex("Unreleased reference id=3 alloc_insn=[0-9]+")
		long rbtree_api_remove_no_drop(void *ctx)
		{
		struct bpf_rb_node *res;

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

+2 −2

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@ static bool less(struct bpf_rb_node a, const struct bpf_rb_node b)
		}

		SEC("?tc")
		__failure __msg("Unreleased reference id=4 alloc_insn=21")
		__failure __regex("Unreleased reference id=4 alloc_insn=[0-9]+")
		long rbtree_refcounted_node_ref_escapes(void *ctx)
		{
		struct node_acquire n, m;
		@@ -73,7 +73,7 @@ long refcount_acquire_maybe_null(void *ctx)
		}

		SEC("?tc")
		__failure __msg("Unreleased reference id=3 alloc_insn=9")
		__failure __regex("Unreleased reference id=3 alloc_insn=[0-9]+")
		long rbtree_refcounted_node_ref_escapes_owning_input(void *ctx)
		{
		struct node_acquire n, m;

tools/testing/selftests/bpf/test_loader.c

+88 −27

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@
		/* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */
		#include <linux/capability.h>
		#include <stdlib.h>
		#include <regex.h>
		#include <test_progs.h>
		#include <bpf/btf.h>

		@@ -17,9 +18,11 @@
		#define TEST_TAG_EXPECT_FAILURE "comment:test_expect_failure"
		#define TEST_TAG_EXPECT_SUCCESS "comment:test_expect_success"
		#define TEST_TAG_EXPECT_MSG_PFX "comment:test_expect_msg="
		#define TEST_TAG_EXPECT_REGEX_PFX "comment:test_expect_regex="
		#define TEST_TAG_EXPECT_FAILURE_UNPRIV "comment:test_expect_failure_unpriv"
		#define TEST_TAG_EXPECT_SUCCESS_UNPRIV "comment:test_expect_success_unpriv"
		#define TEST_TAG_EXPECT_MSG_PFX_UNPRIV "comment:test_expect_msg_unpriv="
		#define TEST_TAG_EXPECT_REGEX_PFX_UNPRIV "comment:test_expect_regex_unpriv="
		#define TEST_TAG_LOG_LEVEL_PFX "comment:test_log_level="
		#define TEST_TAG_PROG_FLAGS_PFX "comment:test_prog_flags="
		#define TEST_TAG_DESCRIPTION_PFX "comment:test_description="
		@@ -46,10 +49,16 @@ enum mode {
		UNPRIV = 2
		};

		struct expect_msg {
		const char substr; / substring match */
		const char regex_str; / regex-based match */
		regex_t regex;
		};

		struct test_subspec {
		char *name;
		bool expect_failure;
		const char **expect_msgs;
		struct expect_msg *expect_msgs;
		size_t expect_msg_cnt;
		int retval;
		bool execute;
		@@ -89,6 +98,16 @@ void test_loader_fini(struct test_loader *tester)

		static void free_test_spec(struct test_spec *spec)
		{
		int i;

		/* Deallocate expect_msgs arrays. */
		for (i = 0; i < spec->priv.expect_msg_cnt; i++)
		if (spec->priv.expect_msgs[i].regex_str)
		regfree(&spec->priv.expect_msgs[i].regex);
		for (i = 0; i < spec->unpriv.expect_msg_cnt; i++)
		if (spec->unpriv.expect_msgs[i].regex_str)
		regfree(&spec->unpriv.expect_msgs[i].regex);

		free(spec->priv.name);
		free(spec->unpriv.name);
		free(spec->priv.expect_msgs);
		@@ -100,18 +119,38 @@ static void free_test_spec(struct test_spec *spec)
		spec->unpriv.expect_msgs = NULL;
		}

		static int push_msg(const char msg, struct test_subspec subspec)
		static int push_msg(const char substr, const char regex_str, struct test_subspec *subspec)
		{
		void *tmp;
		int regcomp_res;
		char error_msg[100];
		struct expect_msg *msg;

		tmp = realloc(subspec->expect_msgs, (1 + subspec->expect_msg_cnt) * sizeof(void *));
		tmp = realloc(subspec->expect_msgs,
		(1 + subspec->expect_msg_cnt) * sizeof(struct expect_msg));
		if (!tmp) {
		ASSERT_FAIL("failed to realloc memory for messages\n");
		return -ENOMEM;
		}
		subspec->expect_msgs = tmp;
		subspec->expect_msgs[subspec->expect_msg_cnt++] = msg;
		msg = &subspec->expect_msgs[subspec->expect_msg_cnt];

		if (substr) {
		msg->substr = substr;
		msg->regex_str = NULL;
		} else {
		msg->regex_str = regex_str;
		msg->substr = NULL;
		regcomp_res = regcomp(&msg->regex, regex_str, REG_EXTENDED\|REG_NEWLINE);
		if (regcomp_res != 0) {
		regerror(regcomp_res, &msg->regex, error_msg, sizeof(error_msg));
		PRINT_FAIL("Regexp compilation error in '%s': '%s'\n",
		regex_str, error_msg);
		return -EINVAL;
		}
		}

		subspec->expect_msg_cnt += 1;
		return 0;
		}

		@@ -233,13 +272,25 @@ static int parse_test_spec(struct test_loader *tester,
		spec->mode_mask \|= UNPRIV;
		} else if (str_has_pfx(s, TEST_TAG_EXPECT_MSG_PFX)) {
		msg = s + sizeof(TEST_TAG_EXPECT_MSG_PFX) - 1;
		err = push_msg(msg, &spec->priv);
		err = push_msg(msg, NULL, &spec->priv);
		if (err)
		goto cleanup;
		spec->mode_mask \|= PRIV;
		} else if (str_has_pfx(s, TEST_TAG_EXPECT_MSG_PFX_UNPRIV)) {
		msg = s + sizeof(TEST_TAG_EXPECT_MSG_PFX_UNPRIV) - 1;
		err = push_msg(msg, &spec->unpriv);
		err = push_msg(msg, NULL, &spec->unpriv);
		if (err)
		goto cleanup;
		spec->mode_mask \|= UNPRIV;
		} else if (str_has_pfx(s, TEST_TAG_EXPECT_REGEX_PFX)) {
		msg = s + sizeof(TEST_TAG_EXPECT_REGEX_PFX) - 1;
		err = push_msg(NULL, msg, &spec->priv);
		if (err)
		goto cleanup;
		spec->mode_mask \|= PRIV;
		} else if (str_has_pfx(s, TEST_TAG_EXPECT_REGEX_PFX_UNPRIV)) {
		msg = s + sizeof(TEST_TAG_EXPECT_REGEX_PFX_UNPRIV) - 1;
		err = push_msg(NULL, msg, &spec->unpriv);
		if (err)
		goto cleanup;
		spec->mode_mask \|= UNPRIV;
		@@ -337,16 +388,13 @@ static int parse_test_spec(struct test_loader *tester,
		}

		if (!spec->unpriv.expect_msgs) {
		size_t sz = spec->priv.expect_msg_cnt * sizeof(void *);
		for (i = 0; i < spec->priv.expect_msg_cnt; i++) {
		struct expect_msg *msg = &spec->priv.expect_msgs[i];

		spec->unpriv.expect_msgs = malloc(sz);
		if (!spec->unpriv.expect_msgs) {
		PRINT_FAIL("failed to allocate memory for unpriv.expect_msgs\n");
		err = -ENOMEM;
		err = push_msg(msg->substr, msg->regex_str, &spec->unpriv);
		if (err)
		goto cleanup;
		}
		memcpy(spec->unpriv.expect_msgs, spec->priv.expect_msgs, sz);
		spec->unpriv.expect_msg_cnt = spec->priv.expect_msg_cnt;
		}
		}

		@@ -402,27 +450,40 @@ static void validate_case(struct test_loader *tester,
		struct bpf_program *prog,
		int load_err)
		{
		int i, j;
		int i, j, err;
		char *match;
		regmatch_t reg_match[1];

		for (i = 0; i < subspec->expect_msg_cnt; i++) {
		char *match;
		const char *expect_msg;
		struct expect_msg *msg = &subspec->expect_msgs[i];

		expect_msg = subspec->expect_msgs[i];
		if (msg->substr) {
		match = strstr(tester->log_buf + tester->next_match_pos, msg->substr);
		if (match)
		tester->next_match_pos = match - tester->log_buf + strlen(msg->substr);
		} else {
		err = regexec(&msg->regex,
		tester->log_buf + tester->next_match_pos, 1, reg_match, 0);
		if (err == 0) {
		match = tester->log_buf + tester->next_match_pos + reg_match[0].rm_so;
		tester->next_match_pos += reg_match[0].rm_eo;
		} else {
		match = NULL;
		}
		}

		match = strstr(tester->log_buf + tester->next_match_pos, expect_msg);
		if (!ASSERT_OK_PTR(match, "expect_msg")) {
		/* if we are in verbose mode, we've already emitted log */
		if (env.verbosity == VERBOSE_NONE)
		emit_verifier_log(tester->log_buf, true /force/);
		for (j = 0; j < i; j++)
		fprintf(stderr,
		"MATCHED MSG: '%s'\n", subspec->expect_msgs[j]);
		fprintf(stderr, "EXPECTED MSG: '%s'\n", expect_msg);
		for (j = 0; j <= i; j++) {
		msg = &subspec->expect_msgs[j];
		fprintf(stderr, "%s %s: '%s'\n",
		j < i ? "MATCHED " : "EXPECTED",
		msg->substr ? "SUBSTR" : " REGEX",
		msg->substr ?: msg->regex_str);
		}
		return;
		}

		tester->next_match_pos = match - tester->log_buf + strlen(expect_msg);
		}
		}