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: Cupertino Miranda <cupertino.miranda@oracle.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Acked-by: Eduard Zingerman <eddyz87@gmail.com>
Link: https://lore.kernel.org/bpf/20240617141458.471620-2-cupertino.miranda@oracle.com

diff --git a/tools/testing/selftests/bpf/progs/bpf_misc.h b/tools/testing/selftests/bpf/progs/bpf_misc.h
index fb2f5513e29e1c28237e31e0f8b60aa5e5abaa61..c0280bd2f340d75fc2e6732c4732a2ee69fdbf73 100644 (file)
--- a/tools/testing/selftests/bpf/progs/bpf_misc.h
+++ b/tools/testing/selftests/bpf/progs/bpf_misc.h
@@ -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)))

diff --git a/tools/testing/selftests/bpf/test_loader.c b/tools/testing/selftests/bpf/test_loader.c
index 524c38e9cde48feb8977bb26555d29df3656c85a..f14e10b0de96e5a98a5662d0adfa541940cc2ee5 100644 (file)
--- a/tools/testing/selftests/bpf/test_loader.c
+++ b/tools/testing/selftests/bpf/test_loader.c
@@ -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;
-                               goto cleanup;
+                               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;
-
-               expect_msg = subspec->expect_msgs[i];
+               struct expect_msg *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);
        }
 }