| | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
| | 2 | #ifndef __ALPHA_UACCESS_H |
| | 3 | #define __ALPHA_UACCESS_H |
| | 4 | |
| | 5 | #include <asm-generic/access_ok.h> |
| | 6 | /* |
| | 7 | * These are the main single-value transfer routines. They automatically |
| | 8 | * use the right size if we just have the right pointer type. |
| | 9 | * |
| | 10 | * As the alpha uses the same address space for kernel and user |
| | 11 | * data, we can just do these as direct assignments. (Of course, the |
| | 12 | * exception handling means that it's no longer "just"...) |
| | 13 | * |
| | 14 | * Careful to not |
| | 15 | * (a) re-use the arguments for side effects (sizeof/typeof is ok) |
| | 16 | * (b) require any knowledge of processes at this stage |
| | 17 | */ |
| | 18 | #define put_user(x, ptr) \ |
| | 19 | __put_user_check((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr))) |
| | 20 | #define get_user(x, ptr) \ |
| | 21 | __get_user_check((x), (ptr), sizeof(*(ptr))) |
| | 22 | |
| | 23 | /* |
| | 24 | * The "__xxx" versions do not do address space checking, useful when |
| | 25 | * doing multiple accesses to the same area (the programmer has to do the |
| | 26 | * checks by hand with "access_ok()") |
| | 27 | */ |
| | 28 | #define __put_user(x, ptr) \ |
| | 29 | __put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr))) |
| | 30 | #define __get_user(x, ptr) \ |
| | 31 | __get_user_nocheck((x), (ptr), sizeof(*(ptr))) |
| | 32 | |
| | 33 | /* |
| | 34 | * The "lda %1, 2b-1b(%0)" bits are magic to get the assembler to |
| | 35 | * encode the bits we need for resolving the exception. See the |
| | 36 | * more extensive comments with fixup_inline_exception below for |
| | 37 | * more information. |
| | 38 | */ |
| | 39 | #define EXC(label,cont,res,err) \ |
| | 40 | ".section __ex_table,\"a\"\n" \ |
| | 41 | " .long "#label"-.\n" \ |
| | 42 | " lda "#res","#cont"-"#label"("#err")\n" \ |
| | 43 | ".previous\n" |
| | 44 | |
| | 45 | extern void __get_user_unknown(void); |
| | 46 | |
| | 47 | #define __get_user_nocheck(x, ptr, size) \ |
| | 48 | ({ \ |
| | 49 | long __gu_err = 0; \ |
| | 50 | unsigned long __gu_val; \ |
| | 51 | __chk_user_ptr(ptr); \ |
| | 52 | switch (size) { \ |
| | 53 | case 1: __get_user_8(ptr); break; \ |
| | 54 | case 2: __get_user_16(ptr); break; \ |
| | 55 | case 4: __get_user_32(ptr); break; \ |
| | 56 | case 8: __get_user_64(ptr); break; \ |
| | 57 | default: __get_user_unknown(); break; \ |
| | 58 | } \ |
| | 59 | (x) = (__force __typeof__(*(ptr))) __gu_val; \ |
| | 60 | __gu_err; \ |
| | 61 | }) |
| | 62 | |
| | 63 | #define __get_user_check(x, ptr, size) \ |
| | 64 | ({ \ |
| | 65 | long __gu_err = -EFAULT; \ |
| | 66 | unsigned long __gu_val = 0; \ |
| | 67 | const __typeof__(*(ptr)) __user *__gu_addr = (ptr); \ |
| | 68 | if (__access_ok(__gu_addr, size)) { \ |
| | 69 | __gu_err = 0; \ |
| | 70 | switch (size) { \ |
| | 71 | case 1: __get_user_8(__gu_addr); break; \ |
| | 72 | case 2: __get_user_16(__gu_addr); break; \ |
| | 73 | case 4: __get_user_32(__gu_addr); break; \ |
| | 74 | case 8: __get_user_64(__gu_addr); break; \ |
| | 75 | default: __get_user_unknown(); break; \ |
| | 76 | } \ |
| | 77 | } \ |
| | 78 | (x) = (__force __typeof__(*(ptr))) __gu_val; \ |
| | 79 | __gu_err; \ |
| | 80 | }) |
| | 81 | |
| | 82 | struct __large_struct { unsigned long buf[100]; }; |
| | 83 | #define __m(x) (*(struct __large_struct __user *)(x)) |
| | 84 | |
| | 85 | #define __get_user_64(addr) \ |
| | 86 | __asm__("1: ldq %0,%2\n" \ |
| | 87 | "2:\n" \ |
| | 88 | EXC(1b,2b,%0,%1) \ |
| | 89 | : "=r"(__gu_val), "=r"(__gu_err) \ |
| | 90 | : "m"(__m(addr)), "1"(__gu_err)) |
| | 91 | |
| | 92 | #define __get_user_32(addr) \ |
| | 93 | __asm__("1: ldl %0,%2\n" \ |
| | 94 | "2:\n" \ |
| | 95 | EXC(1b,2b,%0,%1) \ |
| | 96 | : "=r"(__gu_val), "=r"(__gu_err) \ |
| | 97 | : "m"(__m(addr)), "1"(__gu_err)) |
| | 98 | |
| | 99 | #define __get_user_16(addr) \ |
| | 100 | __asm__("1: ldwu %0,%2\n" \ |
| | 101 | "2:\n" \ |
| | 102 | EXC(1b,2b,%0,%1) \ |
| | 103 | : "=r"(__gu_val), "=r"(__gu_err) \ |
| | 104 | : "m"(__m(addr)), "1"(__gu_err)) |
| | 105 | |
| | 106 | #define __get_user_8(addr) \ |
| | 107 | __asm__("1: ldbu %0,%2\n" \ |
| | 108 | "2:\n" \ |
| | 109 | EXC(1b,2b,%0,%1) \ |
| | 110 | : "=r"(__gu_val), "=r"(__gu_err) \ |
| | 111 | : "m"(__m(addr)), "1"(__gu_err)) |
| | 112 | |
| | 113 | extern void __put_user_unknown(void); |
| | 114 | |
| | 115 | #define __put_user_nocheck(x, ptr, size) \ |
| | 116 | ({ \ |
| | 117 | long __pu_err = 0; \ |
| | 118 | __chk_user_ptr(ptr); \ |
| | 119 | switch (size) { \ |
| | 120 | case 1: __put_user_8(x, ptr); break; \ |
| | 121 | case 2: __put_user_16(x, ptr); break; \ |
| | 122 | case 4: __put_user_32(x, ptr); break; \ |
| | 123 | case 8: __put_user_64(x, ptr); break; \ |
| | 124 | default: __put_user_unknown(); break; \ |
| | 125 | } \ |
| | 126 | __pu_err; \ |
| | 127 | }) |
| | 128 | |
| | 129 | #define __put_user_check(x, ptr, size) \ |
| | 130 | ({ \ |
| | 131 | long __pu_err = -EFAULT; \ |
| | 132 | __typeof__(*(ptr)) __user *__pu_addr = (ptr); \ |
| | 133 | if (__access_ok(__pu_addr, size)) { \ |
| | 134 | __pu_err = 0; \ |
| | 135 | switch (size) { \ |
| | 136 | case 1: __put_user_8(x, __pu_addr); break; \ |
| | 137 | case 2: __put_user_16(x, __pu_addr); break; \ |
| | 138 | case 4: __put_user_32(x, __pu_addr); break; \ |
| | 139 | case 8: __put_user_64(x, __pu_addr); break; \ |
| | 140 | default: __put_user_unknown(); break; \ |
| | 141 | } \ |
| | 142 | } \ |
| | 143 | __pu_err; \ |
| | 144 | }) |
| | 145 | |
| | 146 | /* |
| | 147 | * The "__put_user_xx()" macros tell gcc they read from memory |
| | 148 | * instead of writing: this is because they do not write to |
| | 149 | * any memory gcc knows about, so there are no aliasing issues |
| | 150 | */ |
| | 151 | #define __put_user_64(x, addr) \ |
| | 152 | __asm__ __volatile__("1: stq %r2,%1\n" \ |
| | 153 | "2:\n" \ |
| | 154 | EXC(1b,2b,$31,%0) \ |
| | 155 | : "=r"(__pu_err) \ |
| | 156 | : "m" (__m(addr)), "rJ" (x), "0"(__pu_err)) |
| | 157 | |
| | 158 | #define __put_user_32(x, addr) \ |
| | 159 | __asm__ __volatile__("1: stl %r2,%1\n" \ |
| | 160 | "2:\n" \ |
| | 161 | EXC(1b,2b,$31,%0) \ |
| | 162 | : "=r"(__pu_err) \ |
| | 163 | : "m"(__m(addr)), "rJ"(x), "0"(__pu_err)) |
| | 164 | |
| | 165 | #define __put_user_16(x, addr) \ |
| | 166 | __asm__ __volatile__("1: stw %r2,%1\n" \ |
| | 167 | "2:\n" \ |
| | 168 | EXC(1b,2b,$31,%0) \ |
| | 169 | : "=r"(__pu_err) \ |
| | 170 | : "m"(__m(addr)), "rJ"(x), "0"(__pu_err)) |
| | 171 | |
| | 172 | #define __put_user_8(x, addr) \ |
| | 173 | __asm__ __volatile__("1: stb %r2,%1\n" \ |
| | 174 | "2:\n" \ |
| | 175 | EXC(1b,2b,$31,%0) \ |
| | 176 | : "=r"(__pu_err) \ |
| | 177 | : "m"(__m(addr)), "rJ"(x), "0"(__pu_err)) |
| | 178 | |
| | 179 | /* |
| | 180 | * Complex access routines |
| | 181 | */ |
| | 182 | |
| | 183 | extern long __copy_user(void *to, const void *from, long len); |
| | 184 | |
| | 185 | static inline unsigned long |
| | 186 | raw_copy_from_user(void *to, const void __user *from, unsigned long len) |
| | 187 | { |
| | 188 | return __copy_user(to, (__force const void *)from, len); |
| | 189 | } |
| | 190 | |
| | 191 | static inline unsigned long |
| | 192 | raw_copy_to_user(void __user *to, const void *from, unsigned long len) |
| | 193 | { |
| | 194 | return __copy_user((__force void *)to, from, len); |
| | 195 | } |
| | 196 | |
| | 197 | extern long __clear_user(void __user *to, long len); |
| | 198 | |
| | 199 | static inline long |
| | 200 | clear_user(void __user *to, long len) |
| | 201 | { |
| | 202 | if (__access_ok(to, len)) |
| | 203 | len = __clear_user(to, len); |
| | 204 | return len; |
| | 205 | } |
| | 206 | |
| | 207 | extern long strncpy_from_user(char *dest, const char __user *src, long count); |
| | 208 | extern __must_check long strnlen_user(const char __user *str, long n); |
| | 209 | |
| | 210 | #include <asm/extable.h> |
| | 211 | |
| | 212 | #endif /* __ALPHA_UACCESS_H */ |
projects / linux-2.6-block.git / blame_incremental