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