Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[platform/kernel/linux-rpi.git] / lib / strnlen_user.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/kernel.h>
3 #include <linux/export.h>
4 #include <linux/uaccess.h>
5 #include <linux/mm.h>
6 #include <linux/bitops.h>
7
8 #include <asm/word-at-a-time.h>
9
10 /*
11  * Do a strnlen, return length of string *with* final '\0'.
12  * 'count' is the user-supplied count, while 'max' is the
13  * address space maximum.
14  *
15  * Return 0 for exceptions (which includes hitting the address
16  * space maximum), or 'count+1' if hitting the user-supplied
17  * maximum count.
18  *
19  * NOTE! We can sometimes overshoot the user-supplied maximum
20  * if it fits in a aligned 'long'. The caller needs to check
21  * the return value against "> max".
22  */
23 static inline long do_strnlen_user(const char __user *src, unsigned long count, unsigned long max)
24 {
25         const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
26         unsigned long align, res = 0;
27         unsigned long c;
28
29         /*
30          * Do everything aligned. But that means that we
31          * need to also expand the maximum..
32          */
33         align = (sizeof(unsigned long) - 1) & (unsigned long)src;
34         src -= align;
35         max += align;
36
37         unsafe_get_user(c, (unsigned long __user *)src, efault);
38         c |= aligned_byte_mask(align);
39
40         for (;;) {
41                 unsigned long data;
42                 if (has_zero(c, &data, &constants)) {
43                         data = prep_zero_mask(c, data, &constants);
44                         data = create_zero_mask(data);
45                         return res + find_zero(data) + 1 - align;
46                 }
47                 res += sizeof(unsigned long);
48                 /* We already handled 'unsigned long' bytes. Did we do it all ? */
49                 if (unlikely(max <= sizeof(unsigned long)))
50                         break;
51                 max -= sizeof(unsigned long);
52                 unsafe_get_user(c, (unsigned long __user *)(src+res), efault);
53         }
54         res -= align;
55
56         /*
57          * Uhhuh. We hit 'max'. But was that the user-specified maximum
58          * too? If so, return the marker for "too long".
59          */
60         if (res >= count)
61                 return count+1;
62
63         /*
64          * Nope: we hit the address space limit, and we still had more
65          * characters the caller would have wanted. That's 0.
66          */
67 efault:
68         return 0;
69 }
70
71 /**
72  * strnlen_user: - Get the size of a user string INCLUDING final NUL.
73  * @str: The string to measure.
74  * @count: Maximum count (including NUL character)
75  *
76  * Context: User context only. This function may sleep if pagefaults are
77  *          enabled.
78  *
79  * Get the size of a NUL-terminated string in user space.
80  *
81  * Returns the size of the string INCLUDING the terminating NUL.
82  * If the string is too long, returns a number larger than @count. User
83  * has to check the return value against "> count".
84  * On exception (or invalid count), returns 0.
85  *
86  * NOTE! You should basically never use this function. There is
87  * almost never any valid case for using the length of a user space
88  * string, since the string can be changed at any time by other
89  * threads. Use "strncpy_from_user()" instead to get a stable copy
90  * of the string.
91  */
92 long strnlen_user(const char __user *str, long count)
93 {
94         unsigned long max_addr, src_addr;
95
96         if (unlikely(count <= 0))
97                 return 0;
98
99         max_addr = user_addr_max();
100         src_addr = (unsigned long)untagged_addr(str);
101         if (likely(src_addr < max_addr)) {
102                 unsigned long max = max_addr - src_addr;
103                 long retval;
104
105                 /*
106                  * Truncate 'max' to the user-specified limit, so that
107                  * we only have one limit we need to check in the loop
108                  */
109                 if (max > count)
110                         max = count;
111
112                 if (user_read_access_begin(str, max)) {
113                         retval = do_strnlen_user(str, count, max);
114                         user_read_access_end();
115                         return retval;
116                 }
117         }
118         return 0;
119 }
120 EXPORT_SYMBOL(strnlen_user);