1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __PARISC_UACCESS_H
3 #define __PARISC_UACCESS_H
4
5 /*
6 * User space memory access functions
7 */
8 #include <asm/page.h>
9 #include <asm/cache.h>
10 #include <asm/extable.h>
11
12 #include <linux/bug.h>
13 #include <linux/string.h>
14
15 #define TASK_SIZE_MAX DEFAULT_TASK_SIZE
16 #include <asm/pgtable.h>
17 #include <asm-generic/access_ok.h>
18
19 #define put_user __put_user
20 #define get_user __get_user
21
22 #if !defined(CONFIG_64BIT)
23 #define LDD_USER(sr, val, ptr) __get_user_asm64(sr, val, ptr)
24 #define STD_USER(sr, x, ptr) __put_user_asm64(sr, x, ptr)
25 #else
26 #define LDD_USER(sr, val, ptr) __get_user_asm(sr, val, "ldd", ptr)
27 #define STD_USER(sr, x, ptr) __put_user_asm(sr, "std", x, ptr)
28 #endif
29
30 #define __get_user_internal(sr, val, ptr) \
31 ({ \
32 ASM_EXCEPTIONTABLE_VAR(__gu_err); \
33 \
34 switch (sizeof(*(ptr))) { \
35 case 1: __get_user_asm(sr, val, "ldb", ptr); break; \
36 case 2: __get_user_asm(sr, val, "ldh", ptr); break; \
37 case 4: __get_user_asm(sr, val, "ldw", ptr); break; \
38 case 8: LDD_USER(sr, val, ptr); break; \
39 default: BUILD_BUG(); \
40 } \
41 \
42 __gu_err; \
43 })
44
45 #define __get_user(val, ptr) \
46 ({ \
47 __get_user_internal(SR_USER, val, ptr); \
48 })
49
50 #define __get_user_asm(sr, val, ldx, ptr) \
51 { \
52 register long __gu_val; \
53 \
54 __asm__("1: " ldx " 0(%%sr%2,%3),%0\n" \
55 "9:\n" \
56 ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b, "%1") \
57 : "=r"(__gu_val), "+r"(__gu_err) \
58 : "i"(sr), "r"(ptr)); \
59 \
60 (val) = (__force __typeof__(*(ptr))) __gu_val; \
61 }
62
63 #define __get_kernel_nofault(dst, src, type, err_label) \
64 { \
65 type __z; \
66 long __err; \
67 __err = __get_user_internal(SR_KERNEL, __z, (type *)(src)); \
68 if (unlikely(__err)) \
69 goto err_label; \
70 else \
71 *(type *)(dst) = __z; \
72 }
73
74
75 #if !defined(CONFIG_64BIT)
76
77 #define __get_user_asm64(sr, val, ptr) \
78 { \
79 union { \
80 unsigned long long l; \
81 __typeof__(*(ptr)) t; \
82 } __gu_tmp; \
83 \
84 __asm__(" copy %%r0,%R0\n" \
85 "1: ldw 0(%%sr%2,%3),%0\n" \
86 "2: ldw 4(%%sr%2,%3),%R0\n" \
87 "9:\n" \
88 ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b, "%1") \
89 ASM_EXCEPTIONTABLE_ENTRY_EFAULT(2b, 9b, "%1") \
90 : "=&r"(__gu_tmp.l), "+r"(__gu_err) \
91 : "i"(sr), "r"(ptr)); \
92 \
93 (val) = __gu_tmp.t; \
94 }
95
96 #endif /* !defined(CONFIG_64BIT) */
97
98
99 #define __put_user_internal(sr, x, ptr) \
100 ({ \
101 ASM_EXCEPTIONTABLE_VAR(__pu_err); \
102 \
103 switch (sizeof(*(ptr))) { \
104 case 1: __put_user_asm(sr, "stb", x, ptr); break; \
105 case 2: __put_user_asm(sr, "sth", x, ptr); break; \
106 case 4: __put_user_asm(sr, "stw", x, ptr); break; \
107 case 8: STD_USER(sr, x, ptr); break; \
108 default: BUILD_BUG(); \
109 } \
110 \
111 __pu_err; \
112 })
113
114 #define __put_user(x, ptr) \
115 ({ \
116 __typeof__(&*(ptr)) __ptr = ptr; \
117 __typeof__(*(__ptr)) __x = (__typeof__(*(__ptr)))(x); \
118 __put_user_internal(SR_USER, __x, __ptr); \
119 })
120
121 #define __put_kernel_nofault(dst, src, type, err_label) \
122 { \
123 type __z = *(type *)(src); \
124 long __err; \
125 __err = __put_user_internal(SR_KERNEL, __z, (type *)(dst)); \
126 if (unlikely(__err)) \
127 goto err_label; \
128 }
129
130
131
132
133 /*
134 * The "__put_user/kernel_asm()" macros tell gcc they read from memory
135 * instead of writing. This is because they do not write to any memory
136 * gcc knows about, so there are no aliasing issues. These macros must
137 * also be aware that fixups are executed in the context of the fault,
138 * and any registers used there must be listed as clobbers.
139 * The register holding the possible EFAULT error (ASM_EXCEPTIONTABLE_REG)
140 * is already listed as input and output register.
141 */
142
143 #define __put_user_asm(sr, stx, x, ptr) \
144 __asm__ __volatile__ ( \
145 "1: " stx " %1,0(%%sr%2,%3)\n" \
146 "9:\n" \
147 ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b, "%0") \
148 : "+r"(__pu_err) \
149 : "r"(x), "i"(sr), "r"(ptr))
150
151
152 #if !defined(CONFIG_64BIT)
153
154 #define __put_user_asm64(sr, __val, ptr) do { \
155 __asm__ __volatile__ ( \
156 "1: stw %1,0(%%sr%2,%3)\n" \
157 "2: stw %R1,4(%%sr%2,%3)\n" \
158 "9:\n" \
159 ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b, "%0") \
160 ASM_EXCEPTIONTABLE_ENTRY_EFAULT(2b, 9b, "%0") \
161 : "+r"(__pu_err) \
162 : "r"(__val), "i"(sr), "r"(ptr)); \
163 } while (0)
164
165 #endif /* !defined(CONFIG_64BIT) */
166
167 /*
168 * Complex access routines -- external declarations
169 */
170
171 extern long strncpy_from_user(char *, const char __user *, long);
172 extern __must_check unsigned lclear_user(void __user *, unsigned long);
173 extern __must_check long strnlen_user(const char __user *src, long n);
174 /*
175 * Complex access routines -- macros
176 */
177
178 #define clear_user lclear_user
179 #define __clear_user lclear_user
180
181 unsigned long __must_check raw_copy_to_user(void __user *dst, const void *src,
182 unsigned long len);
183 unsigned long __must_check raw_copy_from_user(void *dst, const void __user *src,
184 unsigned long len);
185 #define INLINE_COPY_TO_USER
186 #define INLINE_COPY_FROM_USER
187
188 #endif /* __PARISC_UACCESS_H */
189
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.