bpf: Add kfuncs for read-only string operations

String operations are commonly used so this exposes the most common ones
to BPF programs. For now, we limit ourselves to operations which do not
copy memory around.

Unfortunately, most in-kernel implementations assume that strings are
%NUL-terminated, which is not necessarily true, and therefore we cannot
use them directly in the BPF context. Instead, we open-code them using
__get_kernel_nofault instead of plain dereference to make them safe and
limit the strings length to XATTR_SIZE_MAX to make sure the functions
terminate. When __get_kernel_nofault fails, functions return -EFAULT.
Similarly, when the size bound is reached, the functions return -E2BIG.
In addition, we return -ERANGE when the passed strings are outside of
the kernel address space.

Note that thanks to these dynamic safety checks, no other constraints
are put on the kfunc args (they are marked with the "__ign" suffix to
skip any verifier checks for them).

All of the functions return integers, including functions which normally
(in kernel or libc) return pointers to the strings. The reason is that
since the strings are generally treated as unsafe, the pointers couldn't
be dereferenced anyways. So, instead, we return an index to the string
and let user decide what to do with it. This also nicely fits with
returning various error codes when necessary (see above).

Suggested-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Viktor Malik <vmalik@redhat.com>
Link: https://lore.kernel.org/r/4b008a6212852c1b056a413f86e3efddac73551c.1750917800.git.vmalik@redhat.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/helpers.c b/kernel/bpf/helpers.c
index b71e428ad9360fde0fc6aa2c0833a285ae6688dc..2cdcf7b2c91e8c440ff7bf3362487cddd33d52f4 100644 (file)
--- a/kernel/bpf/helpers.c
+++ b/kernel/bpf/helpers.c
@@ -24,6 +24,7 @@
 #include <linux/bpf_mem_alloc.h>
 #include <linux/kasan.h>
 #include <linux/bpf_verifier.h>
+#include <linux/uaccess.h>
 
 #include "../../lib/kstrtox.h"
 
@@ -3278,6 +3279,376 @@ __bpf_kfunc void __bpf_trap(void)
 {
 }
 
+/*
+ * Kfuncs for string operations.
+ *
+ * Since strings are not necessarily %NUL-terminated, we cannot directly call
+ * in-kernel implementations. Instead, we open-code the implementations using
+ * __get_kernel_nofault instead of plain dereference to make them safe.
+ */
+
+/**
+ * bpf_strcmp - Compare two strings
+ * @s1__ign: One string
+ * @s2__ign: Another string
+ *
+ * Return:
+ * * %0       - Strings are equal
+ * * %-1      - @s1__ign is smaller
+ * * %1       - @s2__ign is smaller
+ * * %-EFAULT - Cannot read one of the strings
+ * * %-E2BIG  - One of strings is too large
+ * * %-ERANGE - One of strings is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strcmp(const char *s1__ign, const char *s2__ign)
+{
+       char c1, c2;
+       int i;
+
+       if (!copy_from_kernel_nofault_allowed(s1__ign, 1) ||
+           !copy_from_kernel_nofault_allowed(s2__ign, 1)) {
+               return -ERANGE;
+       }
+
+       guard(pagefault)();
+       for (i = 0; i < XATTR_SIZE_MAX; i++) {
+               __get_kernel_nofault(&c1, s1__ign, char, err_out);
+               __get_kernel_nofault(&c2, s2__ign, char, err_out);
+               if (c1 != c2)
+                       return c1 < c2 ? -1 : 1;
+               if (c1 == '\0')
+                       return 0;
+               s1__ign++;
+               s2__ign++;
+       }
+       return -E2BIG;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * bpf_strnchr - Find a character in a length limited string
+ * @s__ign: The string to be searched
+ * @count: The number of characters to be searched
+ * @c: The character to search for
+ *
+ * Note that the %NUL-terminator is considered part of the string, and can
+ * be searched for.
+ *
+ * Return:
+ * * >=0      - Index of the first occurrence of @c within @s__ign
+ * * %-ENOENT - @c not found in the first @count characters of @s__ign
+ * * %-EFAULT - Cannot read @s__ign
+ * * %-E2BIG  - @s__ign is too large
+ * * %-ERANGE - @s__ign is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strnchr(const char *s__ign, size_t count, char c)
+{
+       char sc;
+       int i;
+
+       if (!copy_from_kernel_nofault_allowed(s__ign, 1))
+               return -ERANGE;
+
+       guard(pagefault)();
+       for (i = 0; i < count && i < XATTR_SIZE_MAX; i++) {
+               __get_kernel_nofault(&sc, s__ign, char, err_out);
+               if (sc == c)
+                       return i;
+               if (sc == '\0')
+                       return -ENOENT;
+               s__ign++;
+       }
+       return i == XATTR_SIZE_MAX ? -E2BIG : -ENOENT;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * bpf_strchr - Find the first occurrence of a character in a string
+ * @s__ign: The string to be searched
+ * @c: The character to search for
+ *
+ * Note that the %NUL-terminator is considered part of the string, and can
+ * be searched for.
+ *
+ * Return:
+ * * >=0      - The index of the first occurrence of @c within @s__ign
+ * * %-ENOENT - @c not found in @s__ign
+ * * %-EFAULT - Cannot read @s__ign
+ * * %-E2BIG  - @s__ign is too large
+ * * %-ERANGE - @s__ign is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strchr(const char *s__ign, char c)
+{
+       return bpf_strnchr(s__ign, XATTR_SIZE_MAX, c);
+}
+
+/**
+ * bpf_strchrnul - Find and return a character in a string, or end of string
+ * @s__ign: The string to be searched
+ * @c: The character to search for
+ *
+ * Return:
+ * * >=0      - Index of the first occurrence of @c within @s__ign or index of
+ *              the null byte at the end of @s__ign when @c is not found
+ * * %-EFAULT - Cannot read @s__ign
+ * * %-E2BIG  - @s__ign is too large
+ * * %-ERANGE - @s__ign is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strchrnul(const char *s__ign, char c)
+{
+       char sc;
+       int i;
+
+       if (!copy_from_kernel_nofault_allowed(s__ign, 1))
+               return -ERANGE;
+
+       guard(pagefault)();
+       for (i = 0; i < XATTR_SIZE_MAX; i++) {
+               __get_kernel_nofault(&sc, s__ign, char, err_out);
+               if (sc == '\0' || sc == c)
+                       return i;
+               s__ign++;
+       }
+       return -E2BIG;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * bpf_strrchr - Find the last occurrence of a character in a string
+ * @s__ign: The string to be searched
+ * @c: The character to search for
+ *
+ * Return:
+ * * >=0      - Index of the last occurrence of @c within @s__ign
+ * * %-ENOENT - @c not found in @s__ign
+ * * %-EFAULT - Cannot read @s__ign
+ * * %-E2BIG  - @s__ign is too large
+ * * %-ERANGE - @s__ign is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strrchr(const char *s__ign, int c)
+{
+       char sc;
+       int i, last = -ENOENT;
+
+       if (!copy_from_kernel_nofault_allowed(s__ign, 1))
+               return -ERANGE;
+
+       guard(pagefault)();
+       for (i = 0; i < XATTR_SIZE_MAX; i++) {
+               __get_kernel_nofault(&sc, s__ign, char, err_out);
+               if (sc == c)
+                       last = i;
+               if (sc == '\0')
+                       return last;
+               s__ign++;
+       }
+       return -E2BIG;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * bpf_strlen - Calculate the length of a length-limited string
+ * @s__ign: The string
+ * @count: The maximum number of characters to count
+ *
+ * Return:
+ * * >=0      - The length of @s__ign
+ * * %-EFAULT - Cannot read @s__ign
+ * * %-E2BIG  - @s__ign is too large
+ * * %-ERANGE - @s__ign is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strnlen(const char *s__ign, size_t count)
+{
+       char c;
+       int i;
+
+       if (!copy_from_kernel_nofault_allowed(s__ign, 1))
+               return -ERANGE;
+
+       guard(pagefault)();
+       for (i = 0; i < count && i < XATTR_SIZE_MAX; i++) {
+               __get_kernel_nofault(&c, s__ign, char, err_out);
+               if (c == '\0')
+                       return i;
+               s__ign++;
+       }
+       return i == XATTR_SIZE_MAX ? -E2BIG : i;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * bpf_strlen - Calculate the length of a string
+ * @s__ign: The string
+ *
+ * Return:
+ * * >=0      - The length of @s__ign
+ * * %-EFAULT - Cannot read @s__ign
+ * * %-E2BIG  - @s__ign is too large
+ * * %-ERANGE - @s__ign is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strlen(const char *s__ign)
+{
+       return bpf_strnlen(s__ign, XATTR_SIZE_MAX);
+}
+
+/**
+ * bpf_strspn - Calculate the length of the initial substring of @s__ign which
+ *              only contains letters in @accept__ign
+ * @s__ign: The string to be searched
+ * @accept__ign: The string to search for
+ *
+ * Return:
+ * * >=0      - The length of the initial substring of @s__ign which only
+ *              contains letters from @accept__ign
+ * * %-EFAULT - Cannot read one of the strings
+ * * %-E2BIG  - One of the strings is too large
+ * * %-ERANGE - One of the strings is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strspn(const char *s__ign, const char *accept__ign)
+{
+       char cs, ca;
+       int i, j;
+
+       if (!copy_from_kernel_nofault_allowed(s__ign, 1) ||
+           !copy_from_kernel_nofault_allowed(accept__ign, 1)) {
+               return -ERANGE;
+       }
+
+       guard(pagefault)();
+       for (i = 0; i < XATTR_SIZE_MAX; i++) {
+               __get_kernel_nofault(&cs, s__ign, char, err_out);
+               if (cs == '\0')
+                       return i;
+               for (j = 0; j < XATTR_SIZE_MAX; j++) {
+                       __get_kernel_nofault(&ca, accept__ign + j, char, err_out);
+                       if (cs == ca || ca == '\0')
+                               break;
+               }
+               if (j == XATTR_SIZE_MAX)
+                       return -E2BIG;
+               if (ca == '\0')
+                       return i;
+               s__ign++;
+       }
+       return -E2BIG;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * strcspn - Calculate the length of the initial substring of @s__ign which
+ *           does not contain letters in @reject__ign
+ * @s__ign: The string to be searched
+ * @reject__ign: The string to search for
+ *
+ * Return:
+ * * >=0      - The length of the initial substring of @s__ign which does not
+ *              contain letters from @reject__ign
+ * * %-EFAULT - Cannot read one of the strings
+ * * %-E2BIG  - One of the strings is too large
+ * * %-ERANGE - One of the strings is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strcspn(const char *s__ign, const char *reject__ign)
+{
+       char cs, cr;
+       int i, j;
+
+       if (!copy_from_kernel_nofault_allowed(s__ign, 1) ||
+           !copy_from_kernel_nofault_allowed(reject__ign, 1)) {
+               return -ERANGE;
+       }
+
+       guard(pagefault)();
+       for (i = 0; i < XATTR_SIZE_MAX; i++) {
+               __get_kernel_nofault(&cs, s__ign, char, err_out);
+               if (cs == '\0')
+                       return i;
+               for (j = 0; j < XATTR_SIZE_MAX; j++) {
+                       __get_kernel_nofault(&cr, reject__ign + j, char, err_out);
+                       if (cs == cr || cr == '\0')
+                               break;
+               }
+               if (j == XATTR_SIZE_MAX)
+                       return -E2BIG;
+               if (cr != '\0')
+                       return i;
+               s__ign++;
+       }
+       return -E2BIG;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * bpf_strnstr - Find the first substring in a length-limited string
+ * @s1__ign: The string to be searched
+ * @s2__ign: The string to search for
+ * @len: the maximum number of characters to search
+ *
+ * Return:
+ * * >=0      - Index of the first character of the first occurrence of @s2__ign
+ *              within the first @len characters of @s1__ign
+ * * %-ENOENT - @s2__ign not found in the first @len characters of @s1__ign
+ * * %-EFAULT - Cannot read one of the strings
+ * * %-E2BIG  - One of the strings is too large
+ * * %-ERANGE - One of the strings is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strnstr(const char *s1__ign, const char *s2__ign, size_t len)
+{
+       char c1, c2;
+       int i, j;
+
+       if (!copy_from_kernel_nofault_allowed(s1__ign, 1) ||
+           !copy_from_kernel_nofault_allowed(s2__ign, 1)) {
+               return -ERANGE;
+       }
+
+       guard(pagefault)();
+       for (i = 0; i < XATTR_SIZE_MAX; i++) {
+               for (j = 0; i + j < len && j < XATTR_SIZE_MAX; j++) {
+                       __get_kernel_nofault(&c2, s2__ign + j, char, err_out);
+                       if (c2 == '\0')
+                               return i;
+                       __get_kernel_nofault(&c1, s1__ign + j, char, err_out);
+                       if (c1 == '\0')
+                               return -ENOENT;
+                       if (c1 != c2)
+                               break;
+               }
+               if (j == XATTR_SIZE_MAX)
+                       return -E2BIG;
+               if (i + j == len)
+                       return -ENOENT;
+               s1__ign++;
+       }
+       return -E2BIG;
+err_out:
+       return -EFAULT;
+}
+
+/**
+ * bpf_strstr - Find the first substring in a string
+ * @s1__ign: The string to be searched
+ * @s2__ign: The string to search for
+ *
+ * Return:
+ * * >=0      - Index of the first character of the first occurrence of @s2__ign
+ *              within @s1__ign
+ * * %-ENOENT - @s2__ign is not a substring of @s1__ign
+ * * %-EFAULT - Cannot read one of the strings
+ * * %-E2BIG  - One of the strings is too large
+ * * %-ERANGE - One of the strings is outside of kernel address space
+ */
+__bpf_kfunc int bpf_strstr(const char *s1__ign, const char *s2__ign)
+{
+       return bpf_strnstr(s1__ign, s2__ign, XATTR_SIZE_MAX);
+}
+
 __bpf_kfunc_end_defs();
 
 BTF_KFUNCS_START(generic_btf_ids)
@@ -3397,6 +3768,17 @@ BTF_ID_FLAGS(func, bpf_iter_dmabuf_next, KF_ITER_NEXT | KF_RET_NULL | KF_SLEEPAB
 BTF_ID_FLAGS(func, bpf_iter_dmabuf_destroy, KF_ITER_DESTROY | KF_SLEEPABLE)
 #endif
 BTF_ID_FLAGS(func, __bpf_trap)
+BTF_ID_FLAGS(func, bpf_strcmp);
+BTF_ID_FLAGS(func, bpf_strchr);
+BTF_ID_FLAGS(func, bpf_strchrnul);
+BTF_ID_FLAGS(func, bpf_strnchr);
+BTF_ID_FLAGS(func, bpf_strrchr);
+BTF_ID_FLAGS(func, bpf_strlen);
+BTF_ID_FLAGS(func, bpf_strnlen);
+BTF_ID_FLAGS(func, bpf_strspn);
+BTF_ID_FLAGS(func, bpf_strcspn);
+BTF_ID_FLAGS(func, bpf_strstr);
+BTF_ID_FLAGS(func, bpf_strnstr);
 BTF_KFUNCS_END(common_btf_ids)
 
 static const struct btf_kfunc_id_set common_kfunc_set = {