Commit f06ae619 authored by Cupertino Miranda's avatar Cupertino Miranda Committed by Andrii Nakryiko
Browse files

selftests/bpf: Support checks against a regular expression 



Add support for __regex and __regex_unpriv macros to check the test
execution output against a regular expression. This is similar to __msg
and __msg_unpriv, however those expect do substring matching.

Signed-off-by: default avatarCupertino Miranda <cupertino.miranda@oracle.com>
Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Acked-by: default avatarEduard Zingerman <eddyz87@gmail.com>
Link: https://lore.kernel.org/bpf/20240617141458.471620-2-cupertino.miranda@oracle.com
parent cc5083d1

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/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);

	}

}