1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * S390 version 4 * Copyright IBM Corp. 1999, 2000 5 * Author(s): Hartmut Penner (hp@de.ibm.com), 6 * Martin Schwidefsky (schwidefsky@de.ibm.com) 7 * 8 * Derived from "include/asm-i386/uaccess.h" 9 */ 10 #ifndef __S390_UACCESS_H 11 #define __S390_UACCESS_H 12 13 /* 14 * User space memory access functions 15 */ 16 #include <asm/asm-extable.h> 17 #include <asm/processor.h> 18 #include <asm/ctl_reg.h> 19 #include <asm/extable.h> 20 #include <asm/facility.h> 21 #include <asm-generic/access_ok.h> 22 23 void debug_user_asce(int exit); 24 25 unsigned long __must_check 26 raw_copy_from_user(void *to, const void __user *from, unsigned long n); 27 28 unsigned long __must_check 29 raw_copy_to_user(void __user *to, const void *from, unsigned long n); 30 31 #ifndef CONFIG_KASAN 32 #define INLINE_COPY_FROM_USER 33 #define INLINE_COPY_TO_USER 34 #endif 35 36 unsigned long __must_check 37 _copy_from_user_key(void *to, const void __user *from, unsigned long n, unsigned long key); 38 39 static __always_inline unsigned long __must_check 40 copy_from_user_key(void *to, const void __user *from, unsigned long n, unsigned long key) 41 { 42 if (check_copy_size(to, n, false)) 43 n = _copy_from_user_key(to, from, n, key); 44 return n; 45 } 46 47 unsigned long __must_check 48 _copy_to_user_key(void __user *to, const void *from, unsigned long n, unsigned long key); 49 50 static __always_inline unsigned long __must_check 51 copy_to_user_key(void __user *to, const void *from, unsigned long n, unsigned long key) 52 { 53 if (check_copy_size(from, n, true)) 54 n = _copy_to_user_key(to, from, n, key); 55 return n; 56 } 57 58 union oac { 59 unsigned int val; 60 struct { 61 struct { 62 unsigned short key : 4; 63 unsigned short : 4; 64 unsigned short as : 2; 65 unsigned short : 4; 66 unsigned short k : 1; 67 unsigned short a : 1; 68 } oac1; 69 struct { 70 unsigned short key : 4; 71 unsigned short : 4; 72 unsigned short as : 2; 73 unsigned short : 4; 74 unsigned short k : 1; 75 unsigned short a : 1; 76 } oac2; 77 }; 78 }; 79 80 int __noreturn __put_user_bad(void); 81 82 #define __put_user_asm(to, from, size) \ 83 ({ \ 84 union oac __oac_spec = { \ 85 .oac1.as = PSW_BITS_AS_SECONDARY, \ 86 .oac1.a = 1, \ 87 }; \ 88 int __rc; \ 89 \ 90 asm volatile( \ 91 " lr 0,%[spec]\n" \ 92 "0: mvcos %[_to],%[_from],%[_size]\n" \ 93 "1: xr %[rc],%[rc]\n" \ 94 "2:\n" \ 95 EX_TABLE_UA_STORE(0b, 2b, %[rc]) \ 96 EX_TABLE_UA_STORE(1b, 2b, %[rc]) \ 97 : [rc] "=&d" (__rc), [_to] "+Q" (*(to)) \ 98 : [_size] "d" (size), [_from] "Q" (*(from)), \ 99 [spec] "d" (__oac_spec.val) \ 100 : "cc", "0"); \ 101 __rc; \ 102 }) 103 104 static __always_inline int __put_user_fn(void *x, void __user *ptr, unsigned long size) 105 { 106 int rc; 107 108 switch (size) { 109 case 1: 110 rc = __put_user_asm((unsigned char __user *)ptr, 111 (unsigned char *)x, 112 size); 113 break; 114 case 2: 115 rc = __put_user_asm((unsigned short __user *)ptr, 116 (unsigned short *)x, 117 size); 118 break; 119 case 4: 120 rc = __put_user_asm((unsigned int __user *)ptr, 121 (unsigned int *)x, 122 size); 123 break; 124 case 8: 125 rc = __put_user_asm((unsigned long __user *)ptr, 126 (unsigned long *)x, 127 size); 128 break; 129 default: 130 __put_user_bad(); 131 break; 132 } 133 return rc; 134 } 135 136 int __noreturn __get_user_bad(void); 137 138 #define __get_user_asm(to, from, size) \ 139 ({ \ 140 union oac __oac_spec = { \ 141 .oac2.as = PSW_BITS_AS_SECONDARY, \ 142 .oac2.a = 1, \ 143 }; \ 144 int __rc; \ 145 \ 146 asm volatile( \ 147 " lr 0,%[spec]\n" \ 148 "0: mvcos 0(%[_to]),%[_from],%[_size]\n" \ 149 "1: xr %[rc],%[rc]\n" \ 150 "2:\n" \ 151 EX_TABLE_UA_LOAD_MEM(0b, 2b, %[rc], %[_to], %[_ksize]) \ 152 EX_TABLE_UA_LOAD_MEM(1b, 2b, %[rc], %[_to], %[_ksize]) \ 153 : [rc] "=&d" (__rc), "=Q" (*(to)) \ 154 : [_size] "d" (size), [_from] "Q" (*(from)), \ 155 [spec] "d" (__oac_spec.val), [_to] "a" (to), \ 156 [_ksize] "K" (size) \ 157 : "cc", "0"); \ 158 __rc; \ 159 }) 160 161 static __always_inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size) 162 { 163 int rc; 164 165 switch (size) { 166 case 1: 167 rc = __get_user_asm((unsigned char *)x, 168 (unsigned char __user *)ptr, 169 size); 170 break; 171 case 2: 172 rc = __get_user_asm((unsigned short *)x, 173 (unsigned short __user *)ptr, 174 size); 175 break; 176 case 4: 177 rc = __get_user_asm((unsigned int *)x, 178 (unsigned int __user *)ptr, 179 size); 180 break; 181 case 8: 182 rc = __get_user_asm((unsigned long *)x, 183 (unsigned long __user *)ptr, 184 size); 185 break; 186 default: 187 __get_user_bad(); 188 break; 189 } 190 return rc; 191 } 192 193 /* 194 * These are the main single-value transfer routines. They automatically 195 * use the right size if we just have the right pointer type. 196 */ 197 #define __put_user(x, ptr) \ 198 ({ \ 199 __typeof__(*(ptr)) __x = (x); \ 200 int __pu_err = -EFAULT; \ 201 \ 202 __chk_user_ptr(ptr); \ 203 switch (sizeof(*(ptr))) { \ 204 case 1: \ 205 case 2: \ 206 case 4: \ 207 case 8: \ 208 __pu_err = __put_user_fn(&__x, ptr, sizeof(*(ptr))); \ 209 break; \ 210 default: \ 211 __put_user_bad(); \ 212 break; \ 213 } \ 214 __builtin_expect(__pu_err, 0); \ 215 }) 216 217 #define put_user(x, ptr) \ 218 ({ \ 219 might_fault(); \ 220 __put_user(x, ptr); \ 221 }) 222 223 #define __get_user(x, ptr) \ 224 ({ \ 225 int __gu_err = -EFAULT; \ 226 \ 227 __chk_user_ptr(ptr); \ 228 switch (sizeof(*(ptr))) { \ 229 case 1: { \ 230 unsigned char __x; \ 231 \ 232 __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \ 233 (x) = *(__force __typeof__(*(ptr)) *)&__x; \ 234 break; \ 235 }; \ 236 case 2: { \ 237 unsigned short __x; \ 238 \ 239 __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \ 240 (x) = *(__force __typeof__(*(ptr)) *)&__x; \ 241 break; \ 242 }; \ 243 case 4: { \ 244 unsigned int __x; \ 245 \ 246 __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \ 247 (x) = *(__force __typeof__(*(ptr)) *)&__x; \ 248 break; \ 249 }; \ 250 case 8: { \ 251 unsigned long __x; \ 252 \ 253 __gu_err = __get_user_fn(&__x, ptr, sizeof(*(ptr))); \ 254 (x) = *(__force __typeof__(*(ptr)) *)&__x; \ 255 break; \ 256 }; \ 257 default: \ 258 __get_user_bad(); \ 259 break; \ 260 } \ 261 __builtin_expect(__gu_err, 0); \ 262 }) 263 264 #define get_user(x, ptr) \ 265 ({ \ 266 might_fault(); \ 267 __get_user(x, ptr); \ 268 }) 269 270 /* 271 * Copy a null terminated string from userspace. 272 */ 273 long __must_check strncpy_from_user(char *dst, const char __user *src, long count); 274 275 long __must_check strnlen_user(const char __user *src, long count); 276 277 /* 278 * Zero Userspace 279 */ 280 unsigned long __must_check __clear_user(void __user *to, unsigned long size); 281 282 static inline unsigned long __must_check clear_user(void __user *to, unsigned long n) 283 { 284 might_fault(); 285 return __clear_user(to, n); 286 } 287 288 void *s390_kernel_write(void *dst, const void *src, size_t size); 289 290 int __noreturn __put_kernel_bad(void); 291 292 #define __put_kernel_asm(val, to, insn) \ 293 ({ \ 294 int __rc; \ 295 \ 296 asm volatile( \ 297 "0: " insn " %[_val],%[_to]\n" \ 298 "1: xr %[rc],%[rc]\n" \ 299 "2:\n" \ 300 EX_TABLE_UA_STORE(0b, 2b, %[rc]) \ 301 EX_TABLE_UA_STORE(1b, 2b, %[rc]) \ 302 : [rc] "=d" (__rc), [_to] "+Q" (*(to)) \ 303 : [_val] "d" (val) \ 304 : "cc"); \ 305 __rc; \ 306 }) 307 308 #define __put_kernel_nofault(dst, src, type, err_label) \ 309 do { \ 310 unsigned long __x = (unsigned long)(*((type *)(src))); \ 311 int __pk_err; \ 312 \ 313 switch (sizeof(type)) { \ 314 case 1: \ 315 __pk_err = __put_kernel_asm(__x, (type *)(dst), "stc"); \ 316 break; \ 317 case 2: \ 318 __pk_err = __put_kernel_asm(__x, (type *)(dst), "sth"); \ 319 break; \ 320 case 4: \ 321 __pk_err = __put_kernel_asm(__x, (type *)(dst), "st"); \ 322 break; \ 323 case 8: \ 324 __pk_err = __put_kernel_asm(__x, (type *)(dst), "stg"); \ 325 break; \ 326 default: \ 327 __pk_err = __put_kernel_bad(); \ 328 break; \ 329 } \ 330 if (unlikely(__pk_err)) \ 331 goto err_label; \ 332 } while (0) 333 334 int __noreturn __get_kernel_bad(void); 335 336 #define __get_kernel_asm(val, from, insn) \ 337 ({ \ 338 int __rc; \ 339 \ 340 asm volatile( \ 341 "0: " insn " %[_val],%[_from]\n" \ 342 "1: xr %[rc],%[rc]\n" \ 343 "2:\n" \ 344 EX_TABLE_UA_LOAD_REG(0b, 2b, %[rc], %[_val]) \ 345 EX_TABLE_UA_LOAD_REG(1b, 2b, %[rc], %[_val]) \ 346 : [rc] "=d" (__rc), [_val] "=d" (val) \ 347 : [_from] "Q" (*(from)) \ 348 : "cc"); \ 349 __rc; \ 350 }) 351 352 #define __get_kernel_nofault(dst, src, type, err_label) \ 353 do { \ 354 int __gk_err; \ 355 \ 356 switch (sizeof(type)) { \ 357 case 1: { \ 358 unsigned char __x; \ 359 \ 360 __gk_err = __get_kernel_asm(__x, (type *)(src), "ic"); \ 361 *((type *)(dst)) = (type)__x; \ 362 break; \ 363 }; \ 364 case 2: { \ 365 unsigned short __x; \ 366 \ 367 __gk_err = __get_kernel_asm(__x, (type *)(src), "lh"); \ 368 *((type *)(dst)) = (type)__x; \ 369 break; \ 370 }; \ 371 case 4: { \ 372 unsigned int __x; \ 373 \ 374 __gk_err = __get_kernel_asm(__x, (type *)(src), "l"); \ 375 *((type *)(dst)) = (type)__x; \ 376 break; \ 377 }; \ 378 case 8: { \ 379 unsigned long __x; \ 380 \ 381 __gk_err = __get_kernel_asm(__x, (type *)(src), "lg"); \ 382 *((type *)(dst)) = (type)__x; \ 383 break; \ 384 }; \ 385 default: \ 386 __gk_err = __get_kernel_bad(); \ 387 break; \ 388 } \ 389 if (unlikely(__gk_err)) \ 390 goto err_label; \ 391 } while (0) 392 393 #endif /* __S390_UACCESS_H */ 394