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