]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
bf3c2d6d RV |
2 | #include <linux/compiler.h> |
3 | #include <linux/export.h> | |
1771c6e1 | 4 | #include <linux/kasan-checks.h> |
bf90e56e | 5 | #include <linux/thread_info.h> |
2922585b DM |
6 | #include <linux/uaccess.h> |
7 | #include <linux/kernel.h> | |
8 | #include <linux/errno.h> | |
903f433f | 9 | #include <linux/mm.h> |
2922585b DM |
10 | |
11 | #include <asm/byteorder.h> | |
36126f8f | 12 | #include <asm/word-at-a-time.h> |
2922585b DM |
13 | |
14 | #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS | |
15 | #define IS_UNALIGNED(src, dst) 0 | |
16 | #else | |
17 | #define IS_UNALIGNED(src, dst) \ | |
18 | (((long) dst | (long) src) & (sizeof(long) - 1)) | |
19 | #endif | |
20 | ||
21 | /* | |
22 | * Do a strncpy, return length of string without final '\0'. | |
23 | * 'count' is the user-supplied count (return 'count' if we | |
24 | * hit it), 'max' is the address space maximum (and we return | |
25 | * -EFAULT if we hit it). | |
26 | */ | |
29da93fe PZ |
27 | static inline long do_strncpy_from_user(char *dst, const char __user *src, |
28 | unsigned long count, unsigned long max) | |
2922585b | 29 | { |
36126f8f | 30 | const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS; |
29da93fe | 31 | unsigned long res = 0; |
2922585b | 32 | |
2922585b DM |
33 | if (IS_UNALIGNED(src, dst)) |
34 | goto byte_at_a_time; | |
35 | ||
36 | while (max >= sizeof(unsigned long)) { | |
36126f8f | 37 | unsigned long c, data; |
2922585b DM |
38 | |
39 | /* Fall back to byte-at-a-time if we get a page fault */ | |
1bd4403d LT |
40 | unsafe_get_user(c, (unsigned long __user *)(src+res), byte_at_a_time); |
41 | ||
2922585b | 42 | *(unsigned long *)(dst+res) = c; |
36126f8f LT |
43 | if (has_zero(c, &data, &constants)) { |
44 | data = prep_zero_mask(c, data, &constants); | |
45 | data = create_zero_mask(data); | |
46 | return res + find_zero(data); | |
2922585b DM |
47 | } |
48 | res += sizeof(unsigned long); | |
49 | max -= sizeof(unsigned long); | |
50 | } | |
51 | ||
52 | byte_at_a_time: | |
53 | while (max) { | |
54 | char c; | |
55 | ||
1bd4403d | 56 | unsafe_get_user(c,src+res, efault); |
2922585b DM |
57 | dst[res] = c; |
58 | if (!c) | |
59 | return res; | |
60 | res++; | |
61 | max--; | |
62 | } | |
63 | ||
64 | /* | |
65 | * Uhhuh. We hit 'max'. But was that the user-specified maximum | |
66 | * too? If so, that's ok - we got as much as the user asked for. | |
67 | */ | |
68 | if (res >= count) | |
69 | return res; | |
70 | ||
71 | /* | |
72 | * Nope: we hit the address space limit, and we still had more | |
73 | * characters the caller would have wanted. That's an EFAULT. | |
74 | */ | |
1bd4403d | 75 | efault: |
2922585b DM |
76 | return -EFAULT; |
77 | } | |
78 | ||
79 | /** | |
80 | * strncpy_from_user: - Copy a NUL terminated string from userspace. | |
81 | * @dst: Destination address, in kernel space. This buffer must be at | |
82 | * least @count bytes long. | |
83 | * @src: Source address, in user space. | |
84 | * @count: Maximum number of bytes to copy, including the trailing NUL. | |
85 | * | |
86 | * Copies a NUL-terminated string from userspace to kernel space. | |
87 | * | |
88 | * On success, returns the length of the string (not including the trailing | |
89 | * NUL). | |
90 | * | |
91 | * If access to userspace fails, returns -EFAULT (some data may have been | |
92 | * copied). | |
93 | * | |
94 | * If @count is smaller than the length of the string, copies @count bytes | |
95 | * and returns @count. | |
96 | */ | |
97 | long strncpy_from_user(char *dst, const char __user *src, long count) | |
98 | { | |
99 | unsigned long max_addr, src_addr; | |
100 | ||
101 | if (unlikely(count <= 0)) | |
102 | return 0; | |
103 | ||
104 | max_addr = user_addr_max(); | |
903f433f | 105 | src_addr = (unsigned long)untagged_addr(src); |
2922585b DM |
106 | if (likely(src_addr < max_addr)) { |
107 | unsigned long max = max_addr - src_addr; | |
9fd4470f LT |
108 | long retval; |
109 | ||
f31680e3 CL |
110 | /* |
111 | * Truncate 'max' to the user-specified limit, so that | |
112 | * we only have one limit we need to check in the loop | |
113 | */ | |
114 | if (max > count) | |
115 | max = count; | |
116 | ||
1771c6e1 | 117 | kasan_check_write(dst, count); |
bf90e56e | 118 | check_object_size(dst, count, false); |
594cc251 LT |
119 | if (user_access_begin(src, max)) { |
120 | retval = do_strncpy_from_user(dst, src, count, max); | |
121 | user_access_end(); | |
122 | return retval; | |
123 | } | |
2922585b DM |
124 | } |
125 | return -EFAULT; | |
126 | } | |
127 | EXPORT_SYMBOL(strncpy_from_user); |