1 /* 2 * S390 version 3 * Copyright IBM Corp. 1999, 2000 4 * Author(s): Hartmut Penner (hp@de.ibm.com), 5 * Martin Schwidefsky (schwidefsky@de.ibm.com) 6 * 7 * Derived from "include/asm-i386/uaccess.h" 8 */ 9 #ifndef __S390_UACCESS_H 10 #define __S390_UACCESS_H 11 12 /* 13 * User space memory access functions 14 */ 15 #include <linux/sched.h> 16 #include <linux/errno.h> 17 #include <asm/ctl_reg.h> 18 19 #define VERIFY_READ 0 20 #define VERIFY_WRITE 1 21 22 23 /* 24 * The fs value determines whether argument validity checking should be 25 * performed or not. If get_fs() == USER_DS, checking is performed, with 26 * get_fs() == KERNEL_DS, checking is bypassed. 27 * 28 * For historical reasons, these macros are grossly misnamed. 29 */ 30 31 #define MAKE_MM_SEG(a) ((mm_segment_t) { (a) }) 32 33 34 #define KERNEL_DS MAKE_MM_SEG(0) 35 #define USER_DS MAKE_MM_SEG(1) 36 37 #define get_ds() (KERNEL_DS) 38 #define get_fs() (current->thread.mm_segment) 39 40 #define set_fs(x) \ 41 ({ \ 42 unsigned long __pto; \ 43 current->thread.mm_segment = (x); \ 44 __pto = current->thread.mm_segment.ar4 ? \ 45 S390_lowcore.user_asce : S390_lowcore.kernel_asce; \ 46 __ctl_load(__pto, 7, 7); \ 47 }) 48 49 #define segment_eq(a,b) ((a).ar4 == (b).ar4) 50 51 static inline int __range_ok(unsigned long addr, unsigned long size) 52 { 53 return 1; 54 } 55 56 #define __access_ok(addr, size) \ 57 ({ \ 58 __chk_user_ptr(addr); \ 59 __range_ok((unsigned long)(addr), (size)); \ 60 }) 61 62 #define access_ok(type, addr, size) __access_ok(addr, size) 63 64 /* 65 * The exception table consists of pairs of addresses: the first is the 66 * address of an instruction that is allowed to fault, and the second is 67 * the address at which the program should continue. No registers are 68 * modified, so it is entirely up to the continuation code to figure out 69 * what to do. 70 * 71 * All the routines below use bits of fixup code that are out of line 72 * with the main instruction path. This means when everything is well, 73 * we don't even have to jump over them. Further, they do not intrude 74 * on our cache or tlb entries. 75 */ 76 77 struct exception_table_entry 78 { 79 unsigned long insn, fixup; 80 }; 81 82 struct uaccess_ops { 83 size_t (*copy_from_user)(size_t, const void __user *, void *); 84 size_t (*copy_from_user_small)(size_t, const void __user *, void *); 85 size_t (*copy_to_user)(size_t, void __user *, const void *); 86 size_t (*copy_to_user_small)(size_t, void __user *, const void *); 87 size_t (*copy_in_user)(size_t, void __user *, const void __user *); 88 size_t (*clear_user)(size_t, void __user *); 89 size_t (*strnlen_user)(size_t, const char __user *); 90 size_t (*strncpy_from_user)(size_t, const char __user *, char *); 91 int (*futex_atomic_op)(int op, u32 __user *, int oparg, int *old); 92 int (*futex_atomic_cmpxchg)(u32 *, u32 __user *, u32 old, u32 new); 93 }; 94 95 extern struct uaccess_ops uaccess; 96 extern struct uaccess_ops uaccess_std; 97 extern struct uaccess_ops uaccess_mvcos; 98 extern struct uaccess_ops uaccess_mvcos_switch; 99 extern struct uaccess_ops uaccess_pt; 100 101 extern int __handle_fault(unsigned long, unsigned long, int); 102 103 static inline int __put_user_fn(size_t size, void __user *ptr, void *x) 104 { 105 size = uaccess.copy_to_user_small(size, ptr, x); 106 return size ? -EFAULT : size; 107 } 108 109 static inline int __get_user_fn(size_t size, const void __user *ptr, void *x) 110 { 111 size = uaccess.copy_from_user_small(size, ptr, x); 112 return size ? -EFAULT : size; 113 } 114 115 /* 116 * These are the main single-value transfer routines. They automatically 117 * use the right size if we just have the right pointer type. 118 */ 119 #define __put_user(x, ptr) \ 120 ({ \ 121 __typeof__(*(ptr)) __x = (x); \ 122 int __pu_err = -EFAULT; \ 123 __chk_user_ptr(ptr); \ 124 switch (sizeof (*(ptr))) { \ 125 case 1: \ 126 case 2: \ 127 case 4: \ 128 case 8: \ 129 __pu_err = __put_user_fn(sizeof (*(ptr)), \ 130 ptr, &__x); \ 131 break; \ 132 default: \ 133 __put_user_bad(); \ 134 break; \ 135 } \ 136 __pu_err; \ 137 }) 138 139 #define put_user(x, ptr) \ 140 ({ \ 141 might_fault(); \ 142 __put_user(x, ptr); \ 143 }) 144 145 146 extern int __put_user_bad(void) __attribute__((noreturn)); 147 148 #define __get_user(x, ptr) \ 149 ({ \ 150 int __gu_err = -EFAULT; \ 151 __chk_user_ptr(ptr); \ 152 switch (sizeof(*(ptr))) { \ 153 case 1: { \ 154 unsigned char __x; \ 155 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 156 ptr, &__x); \ 157 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 158 break; \ 159 }; \ 160 case 2: { \ 161 unsigned short __x; \ 162 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 163 ptr, &__x); \ 164 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 165 break; \ 166 }; \ 167 case 4: { \ 168 unsigned int __x; \ 169 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 170 ptr, &__x); \ 171 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 172 break; \ 173 }; \ 174 case 8: { \ 175 unsigned long long __x; \ 176 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 177 ptr, &__x); \ 178 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 179 break; \ 180 }; \ 181 default: \ 182 __get_user_bad(); \ 183 break; \ 184 } \ 185 __gu_err; \ 186 }) 187 188 #define get_user(x, ptr) \ 189 ({ \ 190 might_fault(); \ 191 __get_user(x, ptr); \ 192 }) 193 194 extern int __get_user_bad(void) __attribute__((noreturn)); 195 196 #define __put_user_unaligned __put_user 197 #define __get_user_unaligned __get_user 198 199 /** 200 * __copy_to_user: - Copy a block of data into user space, with less checking. 201 * @to: Destination address, in user space. 202 * @from: Source address, in kernel space. 203 * @n: Number of bytes to copy. 204 * 205 * Context: User context only. This function may sleep. 206 * 207 * Copy data from kernel space to user space. Caller must check 208 * the specified block with access_ok() before calling this function. 209 * 210 * Returns number of bytes that could not be copied. 211 * On success, this will be zero. 212 */ 213 static inline unsigned long __must_check 214 __copy_to_user(void __user *to, const void *from, unsigned long n) 215 { 216 if (__builtin_constant_p(n) && (n <= 256)) 217 return uaccess.copy_to_user_small(n, to, from); 218 else 219 return uaccess.copy_to_user(n, to, from); 220 } 221 222 #define __copy_to_user_inatomic __copy_to_user 223 #define __copy_from_user_inatomic __copy_from_user 224 225 /** 226 * copy_to_user: - Copy a block of data into user space. 227 * @to: Destination address, in user space. 228 * @from: Source address, in kernel space. 229 * @n: Number of bytes to copy. 230 * 231 * Context: User context only. This function may sleep. 232 * 233 * Copy data from kernel space to user space. 234 * 235 * Returns number of bytes that could not be copied. 236 * On success, this will be zero. 237 */ 238 static inline unsigned long __must_check 239 copy_to_user(void __user *to, const void *from, unsigned long n) 240 { 241 might_fault(); 242 if (access_ok(VERIFY_WRITE, to, n)) 243 n = __copy_to_user(to, from, n); 244 return n; 245 } 246 247 /** 248 * __copy_from_user: - Copy a block of data from user space, with less checking. 249 * @to: Destination address, in kernel space. 250 * @from: Source address, in user space. 251 * @n: Number of bytes to copy. 252 * 253 * Context: User context only. This function may sleep. 254 * 255 * Copy data from user space to kernel space. Caller must check 256 * the specified block with access_ok() before calling this function. 257 * 258 * Returns number of bytes that could not be copied. 259 * On success, this will be zero. 260 * 261 * If some data could not be copied, this function will pad the copied 262 * data to the requested size using zero bytes. 263 */ 264 static inline unsigned long __must_check 265 __copy_from_user(void *to, const void __user *from, unsigned long n) 266 { 267 if (__builtin_constant_p(n) && (n <= 256)) 268 return uaccess.copy_from_user_small(n, from, to); 269 else 270 return uaccess.copy_from_user(n, from, to); 271 } 272 273 extern void copy_from_user_overflow(void) 274 #ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS 275 __compiletime_warning("copy_from_user() buffer size is not provably correct") 276 #endif 277 ; 278 279 /** 280 * copy_from_user: - Copy a block of data from user space. 281 * @to: Destination address, in kernel space. 282 * @from: Source address, in user space. 283 * @n: Number of bytes to copy. 284 * 285 * Context: User context only. This function may sleep. 286 * 287 * Copy data from user space to kernel space. 288 * 289 * Returns number of bytes that could not be copied. 290 * On success, this will be zero. 291 * 292 * If some data could not be copied, this function will pad the copied 293 * data to the requested size using zero bytes. 294 */ 295 static inline unsigned long __must_check 296 copy_from_user(void *to, const void __user *from, unsigned long n) 297 { 298 unsigned int sz = __compiletime_object_size(to); 299 300 might_fault(); 301 if (unlikely(sz != -1 && sz < n)) { 302 copy_from_user_overflow(); 303 return n; 304 } 305 if (access_ok(VERIFY_READ, from, n)) 306 n = __copy_from_user(to, from, n); 307 else 308 memset(to, 0, n); 309 return n; 310 } 311 312 static inline unsigned long __must_check 313 __copy_in_user(void __user *to, const void __user *from, unsigned long n) 314 { 315 return uaccess.copy_in_user(n, to, from); 316 } 317 318 static inline unsigned long __must_check 319 copy_in_user(void __user *to, const void __user *from, unsigned long n) 320 { 321 might_fault(); 322 if (__access_ok(from,n) && __access_ok(to,n)) 323 n = __copy_in_user(to, from, n); 324 return n; 325 } 326 327 /* 328 * Copy a null terminated string from userspace. 329 */ 330 static inline long __must_check 331 strncpy_from_user(char *dst, const char __user *src, long count) 332 { 333 long res = -EFAULT; 334 might_fault(); 335 if (access_ok(VERIFY_READ, src, 1)) 336 res = uaccess.strncpy_from_user(count, src, dst); 337 return res; 338 } 339 340 static inline unsigned long 341 strnlen_user(const char __user * src, unsigned long n) 342 { 343 might_fault(); 344 return uaccess.strnlen_user(n, src); 345 } 346 347 /** 348 * strlen_user: - Get the size of a string in user space. 349 * @str: The string to measure. 350 * 351 * Context: User context only. This function may sleep. 352 * 353 * Get the size of a NUL-terminated string in user space. 354 * 355 * Returns the size of the string INCLUDING the terminating NUL. 356 * On exception, returns 0. 357 * 358 * If there is a limit on the length of a valid string, you may wish to 359 * consider using strnlen_user() instead. 360 */ 361 #define strlen_user(str) strnlen_user(str, ~0UL) 362 363 /* 364 * Zero Userspace 365 */ 366 367 static inline unsigned long __must_check 368 __clear_user(void __user *to, unsigned long n) 369 { 370 return uaccess.clear_user(n, to); 371 } 372 373 static inline unsigned long __must_check 374 clear_user(void __user *to, unsigned long n) 375 { 376 might_fault(); 377 if (access_ok(VERIFY_WRITE, to, n)) 378 n = uaccess.clear_user(n, to); 379 return n; 380 } 381 382 extern int copy_to_user_real(void __user *dest, void *src, size_t count); 383 extern int copy_from_user_real(void *dest, void __user *src, size_t count); 384 385 #endif /* __S390_UACCESS_H */ 386