From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=74.125.82.173 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1795350886; b=fkh1FsiAiq9gMwz588jkrHrM8jXRFxvm/fIp2M4isV3hkZfzjJOMhrEl81PBHek0sV2w 2x6m+a6XwQQrBK6lue+2iLzBId934WsVocjXl5GFOZ3Ps959sZX6eZp24IOyatf/6EpBL 1YLaBZS+cHLbYaOplqtJymm3tWvDjUx37260vdcnZmWnd9D4eFqcYD9NMnNIMsnPzv8YO 8xJ78wd2QdFaJ2t6VTyhqLeD6I5EpSoAAgAZqCawNcuy9m2JyORdmM8S1oCqu5U1wFNgB n0PAyCbdjNgl2zNmc1/t0z2j9IqBtz/+M40LttO8CNyXpUNd5GdSXcGW2yHZC/Cx4Dw== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1795350886; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Forwarded-Encrypted:X-Gm-Message-State:X-Gm-Gg:X-Received:Received: From:To:Cc:Subject:Date:Message-ID:X-Mailer:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding; bh=jZ+9Hq7+WF35Ttn4sUCu8cTqno+NpMWFIKoNlp9zeYA=; b=PwPK0GKBeeef+Gb8dKuTqGfUPbCxxZCNCJlVdxEpqdFBxw5TZPf8bmsppB/kv0dB1WZo jXvtKJ7U4pSDlEejjyKsughJKDgLj8HAslviWTkyyRDbIFxX0vMnOSdszFT5mXNeK4nK3 CXxiiHoqonGu5l9CjbY92FeUG1JniFSajqJhjg/1X+ZtoB5gz1YHJtojrsir3A6NlAmgx O7XFO2pjUvvO0i9tSYqW6QCq5YnZHfEKwfC3hK6zijjQoijSTV4glQDfiYCFaxzCJZ0cQ kY/tnJOzYN0woMQDBnd1+2uoaP8KgDXBbRYKVi2iPjibjOk/GB8MlDIQ3A4jV6LUMUw== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=xKwikFDd; arc=none smtp.remote-ip=74.125.82.173 Received: from mail-dy1-f173.google.com (mail-dy1-f173.google.com [74.125.82.173]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3ED8F606A33C for ; Sun, 22 Nov 2026 12:34:45 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org 3ED8F606A33C Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=xKwikFDd Received: by mail-dy1-f173.google.com with SMTP id 5a478bee46e88-385d8a00598so3152533eec.1 for ; Sun, 22 Nov 2026 04:34:45 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20260707; t=1795350884; x=1795955684; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=jZ+9Hq7+WF35Ttn4sUCu8cTqno+NpMWFIKoNlp9zeYA=; b=xKwikFDdX4OBdEgRODyFtJGV+zd3rDqJUoJO0jhEeGn51IQrIrJVSwAWne+IkxvJb8 LGGKUptn3PPNw/Yvs7ngoxneVPDOBhUSvG5ZL6sg+2rzl7u7OlyUYLWeWfyNsirg1WLO oWGtMr4oFSa73ih2y5qcpUUmV85XXq/Bgv/MAOE8tlh85gT3OVALKKFRFbW2/Ifa7vHT DEms7ePeMIHS+XOZ30gQs7MzPX/uVoFMTnxdtsxcmA4SEzP6zaJd9rZKma+QzKewffX5 Jsruy2izLQeViQaFMdHHv3qecUgXnsMGhKYKEiE7hrtHdTcgUyq0f8B2GAxUwoK3+8hW OfoQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1795350884; x=1795955684; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=jZ+9Hq7+WF35Ttn4sUCu8cTqno+NpMWFIKoNlp9zeYA=; b=0F7Yt5X6oYIdLiYq+ichU5SWM+4y7mrzluTrr2hyv/rBtUmkkrfEUM8V2x+YGVaBZJ OQr77St+6dEZ+CHz+MStToSTaSkwf7sI5iove5lNL1kgwoRoAwqGjhEVYmWD6TmXE9W3 Wx1hLUJYqo8rMPy8WwmLhzs1+4/ZVBPpxpOAK1DrDAF62nwvYYs8C2dy3Cp6lc3JRQMx uBC0ZOEAmF9Cv5fHymH8bpJFG0eeErKSvXFIlsYYJdlnKKMsgE5PGri/E4xvUEuD+87M jYc0HQXn+8VU2Hv2ApVB38mjW4kVic/5x30bk3MqyMP/O+S+yjUJB7CgnvDe3ZrwrSPF PodA== X-Forwarded-Encrypted: i=1; AL+hErFPzmL0CmSKBAY/4QXIjIyP4MKXVGOc00eI17fK5Bvx3N985rb821cSx6cWHNIHPv+A3wJW0UIep5Y3rRc=@vger.kernel.org X-Gm-Message-State: APuU4Z8x+dUV9tLW8KajVVrPWGvXGJeWfPwLtE1Fnw6KFS6DynW2T9C6 bgt8SCJKfB/ZDVFCtDkfntz1qN3ls7C/5ORajrHgp81nt6mYE2Lb+RCD X-Gm-Gg: AZFdTZenHmENIt1JmqXT4FOguJwikaIJMaaw1FWDkG79xlGG3VsaV1e5HSgp0VM5KOf 3gxs/mSrTG2NPUecaICJLH/0F1tMtqaIXh+u2cLLrt0Q2KBc6mv56udsQp45AVcu7Z4HG9lMKmi pMFGeQKXFrbMWJUBqEdDwyf4kVQ9P97FKLwTFrcjk8CwKKIDGDiLu6BAhvdZDRzXUL3wzokwWPH p3GPl+KJpbmlRaF5gbFtoGgEvnCK9T3yTi4H5Y+vmVo39Zxb5Y6KDc6NeBh5rBFxSxq8RhJ7DvT 6bR+q1Lo88BNPjOrWxwo3HmJmBrGaEJ2erSHUstSFWl4yx82WGme4A/755y1LK7Mns9U94iHwDe 8fkiPz5V/xMijX1HMwIfytaupPfiXOPWKlEL43049AnV0LzIRX2j4mh4JvFtLtDQFpj2jU5sWSn AYvG35qTveYURT+i+w0J9ykF0TNAgQKFO7JvKWHPS5RGrzjOK2aZmK3TjynD6lcBKL2KXmzFlPn pfArXMpadUpkDiyRX+de0cPzjmIj2lMA96nB/BI0Ezyvru7FrO0X4cjrFufH15mVOd21c3E6aM2 QPuRAhs8TCY4OO+/4k9VehaPK093VJct5A9tcPzjjJBOGjh+nJbtsV5n85x6pvqf9g== X-Received: by 2002:a05:693c:8641:20b0:383:50b7:1d78 with SMTP id 5a478bee46e88-38571223ee7mr9754733eec.40.1795350884211; Sun, 22 Nov 2026 04:34:44 -0800 (PST) Received: from boogieman ([182.66.218.119]) by smtp.gmail.com with ESMTPSA id 5a478bee46e88-385666e99fdsm33372330eec.5.2026.11.22.04.34.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 22 Nov 2026 04:34:43 -0800 (PST) From: Abhishek Khade To: bpf@vger.kernel.org Cc: ast@kernel.org, daniel@iogearbox.net, andrii@kernel.org, memxor@gmail.com, linux-kernel@vger.kernel.org, Abhishek Khade Subject: [RFC PATCH bpf-next v2 2/2] selftests/bpf: Add selftests for bpf_memmem and bpf_dynptr_memmem kfuncs Date: Sun, 22 Nov 2026 18:04:27 +0530 Message-ID: <20261122123427.287521-3-abhishekkhade69@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20261122123427.287521-1-abhishekkhade69@gmail.com> References: <20261122123427.287521-1-abhishekkhade69@gmail.com> X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit 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