1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef __ASM_GENERIC_UACCESS_H 3 #define __ASM_GENERIC_UACCESS_H 4 5 /* 6 * User space memory access functions, these should work 7 * on any machine that has kernel and user data in the same 8 * address space, e.g. all NOMMU machines. 9 */ 10 #include <linux/string.h> 11 #include <asm-generic/access_ok.h> 12 13 #ifdef CONFIG_UACCESS_MEMCPY 14 #include <asm/unaligned.h> 15 16 static __always_inline int 17 __get_user_fn(size_t size, const void __user *from, void *to) 18 { 19 BUILD_BUG_ON(!__builtin_constant_p(size)); 20 21 switch (size) { 22 case 1: 23 *(u8 *)to = *((u8 __force *)from); 24 return 0; 25 case 2: 26 *(u16 *)to = get_unaligned((u16 __force *)from); 27 return 0; 28 case 4: 29 *(u32 *)to = get_unaligned((u32 __force *)from); 30 return 0; 31 case 8: 32 *(u64 *)to = get_unaligned((u64 __force *)from); 33 return 0; 34 default: 35 BUILD_BUG(); 36 return 0; 37 } 38 39 } 40 #define __get_user_fn(sz, u, k) __get_user_fn(sz, u, k) 41 42 static __always_inline int 43 __put_user_fn(size_t size, void __user *to, void *from) 44 { 45 BUILD_BUG_ON(!__builtin_constant_p(size)); 46 47 switch (size) { 48 case 1: 49 *(u8 __force *)to = *(u8 *)from; 50 return 0; 51 case 2: 52 put_unaligned(*(u16 *)from, (u16 __force *)to); 53 return 0; 54 case 4: 55 put_unaligned(*(u32 *)from, (u32 __force *)to); 56 return 0; 57 case 8: 58 put_unaligned(*(u64 *)from, (u64 __force *)to); 59 return 0; 60 default: 61 BUILD_BUG(); 62 return 0; 63 } 64 } 65 #define __put_user_fn(sz, u, k) __put_user_fn(sz, u, k) 66 67 #define __get_kernel_nofault(dst, src, type, err_label) \ 68 do { \ 69 *((type *)dst) = get_unaligned((type *)(src)); \ 70 if (0) /* make sure the label looks used to the compiler */ \ 71 goto err_label; \ 72 } while (0) 73 74 #define __put_kernel_nofault(dst, src, type, err_label) \ 75 do { \ 76 put_unaligned(*((type *)src), (type *)(dst)); \ 77 if (0) /* make sure the label looks used to the compiler */ \ 78 goto err_label; \ 79 } while (0) 80 81 static inline __must_check unsigned long 82 raw_copy_from_user(void *to, const void __user * from, unsigned long n) 83 { 84 memcpy(to, (const void __force *)from, n); 85 return 0; 86 } 87 88 static inline __must_check unsigned long 89 raw_copy_to_user(void __user *to, const void *from, unsigned long n) 90 { 91 memcpy((void __force *)to, from, n); 92 return 0; 93 } 94 #define INLINE_COPY_FROM_USER 95 #define INLINE_COPY_TO_USER 96 #endif /* CONFIG_UACCESS_MEMCPY */ 97 98 /* 99 * These are the main single-value transfer routines. They automatically 100 * use the right size if we just have the right pointer type. 101 * This version just falls back to copy_{from,to}_user, which should 102 * provide a fast-path for small values. 103 */ 104 #define __put_user(x, ptr) \ 105 ({ \ 106 __typeof__(*(ptr)) __x = (x); \ 107 int __pu_err = -EFAULT; \ 108 __chk_user_ptr(ptr); \ 109 switch (sizeof (*(ptr))) { \ 110 case 1: \ 111 case 2: \ 112 case 4: \ 113 case 8: \ 114 __pu_err = __put_user_fn(sizeof (*(ptr)), \ 115 ptr, &__x); \ 116 break; \ 117 default: \ 118 __put_user_bad(); \ 119 break; \ 120 } \ 121 __pu_err; \ 122 }) 123 124 #define put_user(x, ptr) \ 125 ({ \ 126 void __user *__p = (ptr); \ 127 might_fault(); \ 128 access_ok(__p, sizeof(*ptr)) ? \ 129 __put_user((x), ((__typeof__(*(ptr)) __user *)__p)) : \ 130 -EFAULT; \ 131 }) 132 133 #ifndef __put_user_fn 134 135 static inline int __put_user_fn(size_t size, void __user *ptr, void *x) 136 { 137 return unlikely(raw_copy_to_user(ptr, x, size)) ? -EFAULT : 0; 138 } 139 140 #define __put_user_fn(sz, u, k) __put_user_fn(sz, u, k) 141 142 #endif 143 144 extern int __put_user_bad(void) __attribute__((noreturn)); 145 146 #define __get_user(x, ptr) \ 147 ({ \ 148 int __gu_err = -EFAULT; \ 149 __chk_user_ptr(ptr); \ 150 switch (sizeof(*(ptr))) { \ 151 case 1: { \ 152 unsigned char __x = 0; \ 153 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 154 ptr, &__x); \ 155 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 156 break; \ 157 }; \ 158 case 2: { \ 159 unsigned short __x = 0; \ 160 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 161 ptr, &__x); \ 162 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 163 break; \ 164 }; \ 165 case 4: { \ 166 unsigned int __x = 0; \ 167 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 168 ptr, &__x); \ 169 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 170 break; \ 171 }; \ 172 case 8: { \ 173 unsigned long long __x = 0; \ 174 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 175 ptr, &__x); \ 176 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 177 break; \ 178 }; \ 179 default: \ 180 __get_user_bad(); \ 181 break; \ 182 } \ 183 __gu_err; \ 184 }) 185 186 #define get_user(x, ptr) \ 187 ({ \ 188 const void __user *__p = (ptr); \ 189 might_fault(); \ 190 access_ok(__p, sizeof(*ptr)) ? \ 191 __get_user((x), (__typeof__(*(ptr)) __user *)__p) :\ 192 ((x) = (__typeof__(*(ptr)))0,-EFAULT); \ 193 }) 194 195 #ifndef __get_user_fn 196 static inline int __get_user_fn(size_t size, const void __user *ptr, void *x) 197 { 198 return unlikely(raw_copy_from_user(x, ptr, size)) ? -EFAULT : 0; 199 } 200 201 #define __get_user_fn(sz, u, k) __get_user_fn(sz, u, k) 202 203 #endif 204 205 extern int __get_user_bad(void) __attribute__((noreturn)); 206 207 /* 208 * Zero Userspace 209 */ 210 #ifndef __clear_user 211 static inline __must_check unsigned long 212 __clear_user(void __user *to, unsigned long n) 213 { 214 memset((void __force *)to, 0, n); 215 return 0; 216 } 217 #endif 218 219 static inline __must_check unsigned long 220 clear_user(void __user *to, unsigned long n) 221 { 222 might_fault(); 223 if (!access_ok(to, n)) 224 return n; 225 226 return __clear_user(to, n); 227 } 228 229 #include <asm/extable.h> 230 231 __must_check long strncpy_from_user(char *dst, const char __user *src, 232 long count); 233 __must_check long strnlen_user(const char __user *src, long n); 234 235 #endif /* __ASM_GENERIC_UACCESS_H */ 236