Add automated BPF selftests validating in-kernel binary byte sequence matching for bpf_memmem() and bpf_dynptr_memmem(). Covered test cases: 1. Binary pattern match across embedded null bytes (0x00). 2. Match at buffer start (offset 0). 3. Match at buffer end (haystack_sz - needle_sz). 4. Single-byte needle fastpath. 5. Non-matching pattern returning -ENOENT. 6. Multiple candidate occurrences returning the first match. 7. Overlapping candidate prefixes returning the correct match. 8. Exact match where needle equals haystack. 9. Needles larger than haystack returning -EINVAL. 10. Empty needle returning -EINVAL. 11. Invalid flags returning -EINVAL. 12. Oversized haystack (> 2 MB) returning -E2BIG. 13. Exact 2 MB boundary full scan. 14. Zero-length haystack returning -EINVAL. 15. Dynamic pointer (bpf_dynptr) searching across embedded nulls, start, end, not found, size boundary, and error cases. Signed-off-by: Abhishek Khade --- .../selftests/bpf/prog_tests/memmem_kfunc.c | 9 + .../selftests/bpf/progs/memmem_kfunc.c | 259 ++++++++++++++++++ 2 files changed, 268 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/memmem_kfunc.c create mode 100644 tools/testing/selftests/bpf/progs/memmem_kfunc.c diff --git a/tools/testing/selftests/bpf/prog_tests/memmem_kfunc.c b/tools/testing/selftests/bpf/prog_tests/memmem_kfunc.c new file mode 100644 index 000000000..d27c9a2a2 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/memmem_kfunc.c @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 Abhishek Khade */ +#include +#include "memmem_kfunc.skel.h" + +void test_memmem_kfunc(void) +{ + RUN_TESTS(memmem_kfunc); +} diff --git a/tools/testing/selftests/bpf/progs/memmem_kfunc.c b/tools/testing/selftests/bpf/progs/memmem_kfunc.c new file mode 100644 index 000000000..8abd06e97 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/memmem_kfunc.c @@ -0,0 +1,259 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2026 Abhishek Khade */ + +#include "vmlinux.h" +#include +#include "bpf_misc.h" +#include "errno.h" + +char _license[] SEC("license") = "GPL"; + +/* kfunc prototypes */ +long bpf_memmem(const void *haystack, u32 haystack__sz, + const void *needle, u32 needle__sz, + u64 flags) __ksym; + +long bpf_dynptr_memmem(const struct bpf_dynptr *haystack, + const void *needle, u32 needle__sz, + u64 flags) __ksym; + +static char bin_data[] = { + 0x16, 0x03, 0x01, 0x00, 0x02, 0xaa, 0xbb, 0x00, 0xff, 0x00, 0x55 +}; + +static char needle_null[] = { 0x00, 0xff, 0x00 }; +static char needle_start[] = { 0x16, 0x03, 0x01 }; +static char needle_end[] = { 0x00, 0x55 }; +static char needle_single[] = { 0xaa }; +static char needle_notfound[] = { 0xde, 0xad }; +static char needle_repeat[] = { 0xaa, 0xbb, 0x00, 0xaa, 0xbb }; +static char needle_sub_repeat[] = { 0xaa, 0xbb }; +static char overlap_haystack[] = { 0xaa, 0xaa, 0xaa, 0xbb }; +static char overlap_needle[] = { 0xaa, 0xaa, 0xbb }; +static char oversized_buf[2 * 1024 * 1024 + 1]; + +/* 1. Flat memory buffer tests */ + +SEC("syscall") +__success __retval(7) +int test_memmem_embedded_null(void *ctx) +{ + return bpf_memmem(bin_data, sizeof(bin_data), + needle_null, sizeof(needle_null), 0); +} + +SEC("syscall") +__success __retval(0) +int test_memmem_start(void *ctx) +{ + return bpf_memmem(bin_data, sizeof(bin_data), + needle_start, sizeof(needle_start), 0); +} + +SEC("syscall") +__success __retval(9) +int test_memmem_end(void *ctx) +{ + return bpf_memmem(bin_data, sizeof(bin_data), + needle_end, sizeof(needle_end), 0); +} + +SEC("syscall") +__success __retval(5) +int test_memmem_single_byte(void *ctx) +{ + return bpf_memmem(bin_data, sizeof(bin_data), + needle_single, sizeof(needle_single), 0); +} + +SEC("syscall") +__success __retval(-ENOENT) +int test_memmem_not_found(void *ctx) +{ + return bpf_memmem(bin_data, sizeof(bin_data), + needle_notfound, sizeof(needle_notfound), 0); +} + +SEC("syscall") +__success __retval(0) +int test_memmem_first_occurrence(void *ctx) +{ + return bpf_memmem(needle_repeat, sizeof(needle_repeat), + needle_sub_repeat, sizeof(needle_sub_repeat), 0); +} + +SEC("syscall") +__success __retval(1) +int test_memmem_overlapping_prefix(void *ctx) +{ + return bpf_memmem(overlap_haystack, sizeof(overlap_haystack), + overlap_needle, sizeof(overlap_needle), 0); +} + +SEC("syscall") +__success __retval(0) +int test_memmem_exact_match(void *ctx) +{ + return bpf_memmem(needle_start, sizeof(needle_start), + needle_start, sizeof(needle_start), 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_memmem_needle_too_large(void *ctx) +{ + return bpf_memmem(needle_start, sizeof(needle_start), + bin_data, sizeof(bin_data), 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_memmem_empty_needle(void *ctx) +{ + return bpf_memmem(bin_data, sizeof(bin_data), + needle_start, 0, 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_memmem_invalid_flags(void *ctx) +{ + return bpf_memmem(bin_data, sizeof(bin_data), + needle_start, sizeof(needle_start), 1); +} + +SEC("syscall") +__success __retval(-E2BIG) +int test_memmem_oversized_haystack(void *ctx) +{ + return bpf_memmem(oversized_buf, sizeof(oversized_buf), + needle_single, sizeof(needle_single), 0); +} + +SEC("syscall") +__success __retval(-ENOENT) +int test_memmem_exact_2mb(void *ctx) +{ + return bpf_memmem(oversized_buf, 2 * 1024 * 1024, + needle_single, sizeof(needle_single), 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_memmem_zero_len_haystack(void *ctx) +{ + return bpf_memmem(bin_data, 0, + needle_single, sizeof(needle_single), 0); +} + +/* 2. Dynamic pointer (bpf_dynptr) tests */ + +SEC("syscall") +__success __retval(7) +int test_dynptr_memmem_embedded_null(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)bin_data, sizeof(bin_data), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_null, sizeof(needle_null), 0); +} + +SEC("syscall") +__success __retval(0) +int test_dynptr_memmem_start(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)bin_data, sizeof(bin_data), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_start, sizeof(needle_start), 0); +} + +SEC("syscall") +__success __retval(9) +int test_dynptr_memmem_end(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)bin_data, sizeof(bin_data), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_end, sizeof(needle_end), 0); +} + +SEC("syscall") +__success __retval(0) +int test_dynptr_memmem_exact_match(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)needle_start, sizeof(needle_start), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_start, sizeof(needle_start), 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_dynptr_memmem_needle_too_large(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)needle_start, sizeof(needle_start), 0, &ptr); + return bpf_dynptr_memmem(&ptr, bin_data, sizeof(bin_data), 0); +} + +SEC("syscall") +__success __retval(-ENOENT) +int test_dynptr_memmem_not_found(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)bin_data, sizeof(bin_data), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_notfound, sizeof(needle_notfound), 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_dynptr_memmem_empty_needle(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)bin_data, sizeof(bin_data), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_start, 0, 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_dynptr_memmem_invalid_flags(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)bin_data, sizeof(bin_data), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_start, sizeof(needle_start), 1); +} + +SEC("syscall") +__success __retval(-E2BIG) +int test_dynptr_memmem_oversized_haystack(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)oversized_buf, sizeof(oversized_buf), 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_single, sizeof(needle_single), 0); +} + +SEC("syscall") +__success __retval(-ENOENT) +int test_dynptr_memmem_exact_2mb(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)oversized_buf, 2 * 1024 * 1024, 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_single, sizeof(needle_single), 0); +} + +SEC("syscall") +__success __retval(-EINVAL) +int test_dynptr_memmem_zero_len_haystack(void *ctx) +{ + struct bpf_dynptr ptr; + + bpf_dynptr_from_mem((void *)bin_data, 0, 0, &ptr); + return bpf_dynptr_memmem(&ptr, needle_single, sizeof(needle_single), 0); +} -- 2.53.0