* [PATCH bpf-next v2 1/2] bpf: Add kfuncs for read-only string operations
2024-09-26 7:29 [PATCH bpf-next v2 0/2] bpf: Add kfuncs for read-only string operations Viktor Malik
@ 2024-09-26 7:29 ` Viktor Malik
2024-09-26 7:29 ` [PATCH bpf-next v2 2/2] selftests/bpf: Add tests for string kfuncs Viktor Malik
2024-09-27 1:37 ` [PATCH bpf-next v2 0/2] bpf: Add kfuncs for read-only string operations Eduard Zingerman
2 siblings, 0 replies; 7+ messages in thread
From: Viktor Malik @ 2024-09-26 7:29 UTC (permalink / raw)
To: bpf
Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
Martin KaFai Lau, Eduard Zingerman, Song Liu, Yonghong Song,
John Fastabend, KP Singh, Stanislav Fomichev, Hao Luo, Jiri Olsa,
Viktor Malik
Kernel contains highly optimised implementation of traditional string
operations. Expose them as kfuncs to allow BPF programs leverage the
kernel implementation instead of needing to reimplement the operations.
For now, add kfuncs for all string operations which do not copy memory
around: strcmp, strchr, strrchr, strnchr, strstr, strnstr, strlen,
strnlen, strpbrk, strspn, strcspn. Do not add strncmp as it is already
exposed as a helper.
Signed-off-by: Viktor Malik <vmalik@redhat.com>
---
kernel/bpf/helpers.c | 66 ++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 66 insertions(+)
diff --git a/kernel/bpf/helpers.c b/kernel/bpf/helpers.c
index 1a43d06eab28..daa19760d8c8 100644
--- a/kernel/bpf/helpers.c
+++ b/kernel/bpf/helpers.c
@@ -3004,6 +3004,61 @@ __bpf_kfunc int bpf_copy_from_user_str(void *dst, u32 dst__sz, const void __user
return ret + 1;
}
+__bpf_kfunc int bpf_strcmp(const char *cs, const char *ct)
+{
+ return strcmp(cs, ct);
+}
+
+__bpf_kfunc char *bpf_strchr(const char *s, int c)
+{
+ return strchr(s, c);
+}
+
+__bpf_kfunc char *bpf_strrchr(const char *s, int c)
+{
+ return strrchr(s, c);
+}
+
+__bpf_kfunc char *bpf_strnchr(const char *s, size_t count, int c)
+{
+ return strnchr(s, count, c);
+}
+
+__bpf_kfunc char *bpf_strstr(const char *s1, const char *s2)
+{
+ return strstr(s1, s2);
+}
+
+__bpf_kfunc char *bpf_strnstr(const char *s1, const char *s2, size_t len)
+{
+ return strnstr(s1, s2, len);
+}
+
+__bpf_kfunc size_t bpf_strlen(const char *s)
+{
+ return strlen(s);
+}
+
+__bpf_kfunc size_t bpf_strnlen(const char *s, size_t count)
+{
+ return strnlen(s, count);
+}
+
+__bpf_kfunc char *bpf_strpbrk(const char *cs, const char *ct)
+{
+ return strpbrk(cs, ct);
+}
+
+__bpf_kfunc size_t bpf_strspn(const char *s, const char *accept)
+{
+ return strspn(s, accept);
+}
+
+__bpf_kfunc size_t bpf_strcspn(const char *s, const char *reject)
+{
+ return strcspn(s, reject);
+}
+
__bpf_kfunc_end_defs();
BTF_KFUNCS_START(generic_btf_ids)
@@ -3090,6 +3145,17 @@ BTF_ID_FLAGS(func, bpf_iter_bits_new, KF_ITER_NEW)
BTF_ID_FLAGS(func, bpf_iter_bits_next, KF_ITER_NEXT | KF_RET_NULL)
BTF_ID_FLAGS(func, bpf_iter_bits_destroy, KF_ITER_DESTROY)
BTF_ID_FLAGS(func, bpf_copy_from_user_str, KF_SLEEPABLE)
+BTF_ID_FLAGS(func, bpf_strcmp)
+BTF_ID_FLAGS(func, bpf_strchr)
+BTF_ID_FLAGS(func, bpf_strrchr)
+BTF_ID_FLAGS(func, bpf_strnchr)
+BTF_ID_FLAGS(func, bpf_strstr)
+BTF_ID_FLAGS(func, bpf_strnstr)
+BTF_ID_FLAGS(func, bpf_strlen)
+BTF_ID_FLAGS(func, bpf_strnlen)
+BTF_ID_FLAGS(func, bpf_strpbrk)
+BTF_ID_FLAGS(func, bpf_strspn)
+BTF_ID_FLAGS(func, bpf_strcspn)
BTF_KFUNCS_END(common_btf_ids)
static const struct btf_kfunc_id_set common_kfunc_set = {
--
2.46.0
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH bpf-next v2 2/2] selftests/bpf: Add tests for string kfuncs
2024-09-26 7:29 [PATCH bpf-next v2 0/2] bpf: Add kfuncs for read-only string operations Viktor Malik
2024-09-26 7:29 ` [PATCH bpf-next v2 1/2] " Viktor Malik
@ 2024-09-26 7:29 ` Viktor Malik
2024-09-27 1:57 ` Eduard Zingerman
2024-09-27 1:37 ` [PATCH bpf-next v2 0/2] bpf: Add kfuncs for read-only string operations Eduard Zingerman
2 siblings, 1 reply; 7+ messages in thread
From: Viktor Malik @ 2024-09-26 7:29 UTC (permalink / raw)
To: bpf
Cc: Alexei Starovoitov, Daniel Borkmann, Andrii Nakryiko,
Martin KaFai Lau, Eduard Zingerman, Song Liu, Yonghong Song,
John Fastabend, KP Singh, Stanislav Fomichev, Hao Luo, Jiri Olsa,
Viktor Malik
The tests attach to `raw_tp/bpf_testmod_test_write_bare` triggerred by
`trigger_module_test_write` which writes the string "aaa..." of the
given size.
Signed-off-by: Viktor Malik <vmalik@redhat.com>
---
.../selftests/bpf/prog_tests/string_kfuncs.c | 37 +++
.../selftests/bpf/progs/test_string_kfuncs.c | 215 ++++++++++++++++++
2 files changed, 252 insertions(+)
create mode 100644 tools/testing/selftests/bpf/prog_tests/string_kfuncs.c
create mode 100644 tools/testing/selftests/bpf/progs/test_string_kfuncs.c
diff --git a/tools/testing/selftests/bpf/prog_tests/string_kfuncs.c b/tools/testing/selftests/bpf/prog_tests/string_kfuncs.c
new file mode 100644
index 000000000000..4fe28a4ee6ad
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/string_kfuncs.c
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <test_progs.h>
+#include "test_string_kfuncs.skel.h"
+
+void test_string_kfuncs(void)
+{
+ const int WRITE_SZ = 10;
+ struct test_string_kfuncs *skel;
+ struct test_string_kfuncs__bss *bss;
+
+ skel = test_string_kfuncs__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "test_string_kfuncs__open_end_load"))
+ return;
+
+ bss = skel->bss;
+
+ if (!ASSERT_OK(test_string_kfuncs__attach(skel), "test_string_kfuncs__attach"))
+ goto end;
+
+ ASSERT_OK(trigger_module_test_write(WRITE_SZ), "trigger_write");
+
+ ASSERT_EQ(bss->strcmp_check, 1, "test_strcmp");
+ ASSERT_EQ(bss->strchr_check, 1, "test_strchr");
+ ASSERT_EQ(bss->strrchr_check, 1, "test_strrchr");
+ ASSERT_EQ(bss->strnchr_check, 1, "test_strnchr");
+ ASSERT_EQ(bss->strstr_check, 1, "test_strstr");
+ ASSERT_EQ(bss->strnstr_check, 1, "test_strstr");
+ ASSERT_EQ(bss->strlen_check, 1, "test_strlen");
+ ASSERT_EQ(bss->strnlen_check, 1, "test_strnlen");
+ ASSERT_EQ(bss->strpbrk_check, 1, "test_strpbrk");
+ ASSERT_EQ(bss->strspn_check, 1, "test_strspn");
+ ASSERT_EQ(bss->strcspn_check, 1, "test_strspn");
+
+end:
+ test_string_kfuncs__destroy(skel);
+}
diff --git a/tools/testing/selftests/bpf/progs/test_string_kfuncs.c b/tools/testing/selftests/bpf/progs/test_string_kfuncs.c
new file mode 100644
index 000000000000..3cfe80b1941b
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/test_string_kfuncs.c
@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include "vmlinux.h"
+#include <bpf/bpf_core_read.h>
+#include <bpf/bpf_tracing.h>
+#include "../bpf_testmod/bpf_testmod.h"
+
+#define BUFSZ 10
+
+int bpf_strcmp(const char *cs, const char *ct) __ksym;
+char *bpf_strchr(const char *s, int c) __ksym;
+char *bpf_strrchr(const char *s, int c) __ksym;
+char *bpf_strnchr(const char *s, size_t count, int c) __ksym;
+char *bpf_strstr(const char *s1, const char *s2) __ksym;
+char *bpf_strnstr(const char *s1, const char *s2, size_t len) __ksym;
+size_t bpf_strlen(const char *) __ksym;
+size_t bpf_strnlen(const char *s, size_t count) __ksym;
+char *bpf_strpbrk(const char *cs, const char *ct) __ksym;
+size_t bpf_strspn(const char *s, const char *accept) __ksym;
+size_t bpf_strcspn(const char *s, const char *reject) __ksym;
+
+__u32 strcmp_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strcmp,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+ char expected[] = "aaaaaaaaa";
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strcmp(buf, expected) == 0)
+ strcmp_check = 1;
+
+ return 0;
+}
+
+__u32 strchr_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strchr,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strchr(buf, 'a') == buf)
+ strchr_check = 1;
+
+ return 0;
+}
+
+__u32 strrchr_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strrchr,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strrchr(buf, 'a') == &buf[8])
+ strrchr_check = 1;
+
+ return 0;
+}
+
+__u32 strnchr_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strnchr,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strnchr(buf, 1, 'a') == buf)
+ strnchr_check = 1;
+
+ return 0;
+}
+
+__u32 strstr_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strstr,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+ char substr[] = "aaa";
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strstr(buf, substr) == buf)
+ strstr_check = 1;
+
+ return 0;
+}
+
+__u32 strnstr_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strnstr,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+ char substr[] = "aaa";
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strnstr(buf, substr, 3) == buf)
+ strnstr_check = 1;
+
+ return 0;
+}
+
+__u32 strlen_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strlen,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strlen(buf) == 9)
+ strlen_check = 1;
+
+ return 0;
+}
+
+__u32 strnlen_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strnlen,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strnlen(buf, 5) == 5)
+ strnlen_check = 1;
+
+ return 0;
+}
+
+__u32 strpbrk_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strpbrk,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+ char accept[] = "abc";
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strpbrk(buf, accept) == buf)
+ strpbrk_check = 1;
+
+ return 0;
+}
+
+__u32 strspn_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strspn,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+ char accept[] = "abc";
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strspn(buf, accept) == 9)
+ strspn_check = 1;
+
+ return 0;
+}
+
+__u32 strcspn_check = 0;
+
+SEC("raw_tp/bpf_testmod_test_write_bare")
+int BPF_PROG(test_strcspn,
+ struct task_struct *task, struct bpf_testmod_test_write_ctx *write_ctx)
+{
+ char buf[BUFSZ], *buf_ptr;
+ char reject[] = "abc";
+
+ buf_ptr = BPF_PROBE_READ(write_ctx, buf);
+ bpf_probe_read_kernel_str(buf, sizeof(buf), buf_ptr);
+
+ if (bpf_strcspn(buf, reject) == 0)
+ strcspn_check = 1;
+
+ return 0;
+}
+
+char LICENSE[] SEC("license") = "GPL";
--
2.46.0
^ permalink raw reply related [flat|nested] 7+ messages in thread