1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu> 4 * Copyright (C) 2008-2009 PetaLogix 5 * Copyright (C) 2006 Atmark Techno, Inc. 6 */ 7 8 #ifndef _ASM_MICROBLAZE_UACCESS_H 9 #define _ASM_MICROBLAZE_UACCESS_H 10 11 #include <linux/kernel.h> 12 13 #include <asm/mmu.h> 14 #include <asm/page.h> 15 #include <linux/pgtable.h> 16 #include <asm/extable.h> 17 #include <linux/string.h> 18 #include <asm-generic/access_ok.h> 19 20 # define __FIXUP_SECTION ".section .fixup,\"ax\"\n" 21 # define __EX_TABLE_SECTION ".section __ex_table,\"a\"\n" 22 23 extern unsigned long __copy_tofrom_user(void __user *to, 24 const void __user *from, unsigned long size); 25 26 /* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */ 27 static inline unsigned long __must_check __clear_user(void __user *to, 28 unsigned long n) 29 { 30 /* normal memset with two words to __ex_table */ 31 __asm__ __volatile__ ( \ 32 "1: sb r0, %1, r0;" \ 33 " addik %0, %0, -1;" \ 34 " bneid %0, 1b;" \ 35 " addik %1, %1, 1;" \ 36 "2: " \ 37 __EX_TABLE_SECTION \ 38 ".word 1b,2b;" \ 39 ".previous;" \ 40 : "=r"(n), "=r"(to) \ 41 : "0"(n), "1"(to) 42 ); 43 return n; 44 } 45 46 static inline unsigned long __must_check clear_user(void __user *to, 47 unsigned long n) 48 { 49 might_fault(); 50 if (unlikely(!access_ok(to, n))) 51 return n; 52 53 return __clear_user(to, n); 54 } 55 56 /* put_user and get_user macros */ 57 extern long __user_bad(void); 58 59 #define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \ 60 ({ \ 61 __asm__ __volatile__ ( \ 62 "1:" insn " %1, %2, r0;" \ 63 " addk %0, r0, r0;" \ 64 "2: " \ 65 __FIXUP_SECTION \ 66 "3: brid 2b;" \ 67 " addik %0, r0, %3;" \ 68 ".previous;" \ 69 __EX_TABLE_SECTION \ 70 ".word 1b,3b;" \ 71 ".previous;" \ 72 : "=&r"(__gu_err), "=r"(__gu_val) \ 73 : "r"(__gu_ptr), "i"(-EFAULT) \ 74 ); \ 75 }) 76 77 /** 78 * get_user: - Get a simple variable from user space. 79 * @x: Variable to store result. 80 * @ptr: Source address, in user space. 81 * 82 * Context: User context only. This function may sleep if pagefaults are 83 * enabled. 84 * 85 * This macro copies a single simple variable from user space to kernel 86 * space. It supports simple types like char and int, but not larger 87 * data types like structures or arrays. 88 * 89 * @ptr must have pointer-to-simple-variable type, and the result of 90 * dereferencing @ptr must be assignable to @x without a cast. 91 * 92 * Returns zero on success, or -EFAULT on error. 93 * On error, the variable @x is set to zero. 94 */ 95 #define get_user(x, ptr) ({ \ 96 const typeof(*(ptr)) __user *__gu_ptr = (ptr); \ 97 access_ok(__gu_ptr, sizeof(*__gu_ptr)) ? \ 98 __get_user(x, __gu_ptr) : -EFAULT; \ 99 }) 100 101 #define __get_user(x, ptr) \ 102 ({ \ 103 long __gu_err; \ 104 switch (sizeof(*(ptr))) { \ 105 case 1: \ 106 __get_user_asm("lbu", (ptr), x, __gu_err); \ 107 break; \ 108 case 2: \ 109 __get_user_asm("lhu", (ptr), x, __gu_err); \ 110 break; \ 111 case 4: \ 112 __get_user_asm("lw", (ptr), x, __gu_err); \ 113 break; \ 114 case 8: { \ 115 __u64 __x = 0; \ 116 __gu_err = raw_copy_from_user(&__x, ptr, 8) ? \ 117 -EFAULT : 0; \ 118 (x) = (typeof(x))(typeof((x) - (x)))__x; \ 119 break; \ 120 } \ 121 default: \ 122 /* __gu_val = 0; __gu_err = -EINVAL;*/ __gu_err = __user_bad();\ 123 } \ 124 __gu_err; \ 125 }) 126 127 128 #define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \ 129 ({ \ 130 __asm__ __volatile__ ( \ 131 "1:" insn " %1, %2, r0;" \ 132 " addk %0, r0, r0;" \ 133 "2: " \ 134 __FIXUP_SECTION \ 135 "3: brid 2b;" \ 136 " addik %0, r0, %3;" \ 137 ".previous;" \ 138 __EX_TABLE_SECTION \ 139 ".word 1b,3b;" \ 140 ".previous;" \ 141 : "=&r"(__gu_err) \ 142 : "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \ 143 ); \ 144 }) 145 146 #define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err) \ 147 ({ \ 148 __asm__ __volatile__ (" lwi %0, %1, 0;" \ 149 "1: swi %0, %2, 0;" \ 150 " lwi %0, %1, 4;" \ 151 "2: swi %0, %2, 4;" \ 152 " addk %0, r0, r0;" \ 153 "3: " \ 154 __FIXUP_SECTION \ 155 "4: brid 3b;" \ 156 " addik %0, r0, %3;" \ 157 ".previous;" \ 158 __EX_TABLE_SECTION \ 159 ".word 1b,4b,2b,4b;" \ 160 ".previous;" \ 161 : "=&r"(__gu_err) \ 162 : "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \ 163 ); \ 164 }) 165 166 /** 167 * put_user: - Write a simple value into user space. 168 * @x: Value to copy to user space. 169 * @ptr: Destination address, in user space. 170 * 171 * Context: User context only. This function may sleep if pagefaults are 172 * enabled. 173 * 174 * This macro copies a single simple value from kernel space to user 175 * space. It supports simple types like char and int, but not larger 176 * data types like structures or arrays. 177 * 178 * @ptr must have pointer-to-simple-variable type, and @x must be assignable 179 * to the result of dereferencing @ptr. 180 * 181 * Returns zero on success, or -EFAULT on error. 182 */ 183 #define put_user(x, ptr) \ 184 __put_user_check((x), (ptr), sizeof(*(ptr))) 185 186 #define __put_user_check(x, ptr, size) \ 187 ({ \ 188 typeof(*(ptr)) volatile __pu_val = x; \ 189 typeof(*(ptr)) __user *__pu_addr = (ptr); \ 190 int __pu_err = 0; \ 191 \ 192 if (access_ok(__pu_addr, size)) { \ 193 switch (size) { \ 194 case 1: \ 195 __put_user_asm("sb", __pu_addr, __pu_val, \ 196 __pu_err); \ 197 break; \ 198 case 2: \ 199 __put_user_asm("sh", __pu_addr, __pu_val, \ 200 __pu_err); \ 201 break; \ 202 case 4: \ 203 __put_user_asm("sw", __pu_addr, __pu_val, \ 204 __pu_err); \ 205 break; \ 206 case 8: \ 207 __put_user_asm_8(__pu_addr, __pu_val, __pu_err);\ 208 break; \ 209 default: \ 210 __pu_err = __user_bad(); \ 211 break; \ 212 } \ 213 } else { \ 214 __pu_err = -EFAULT; \ 215 } \ 216 __pu_err; \ 217 }) 218 219 #define __put_user(x, ptr) \ 220 ({ \ 221 __typeof__(*(ptr)) volatile __gu_val = (x); \ 222 long __gu_err = 0; \ 223 switch (sizeof(__gu_val)) { \ 224 case 1: \ 225 __put_user_asm("sb", (ptr), __gu_val, __gu_err); \ 226 break; \ 227 case 2: \ 228 __put_user_asm("sh", (ptr), __gu_val, __gu_err); \ 229 break; \ 230 case 4: \ 231 __put_user_asm("sw", (ptr), __gu_val, __gu_err); \ 232 break; \ 233 case 8: \ 234 __put_user_asm_8((ptr), __gu_val, __gu_err); \ 235 break; \ 236 default: \ 237 /*__gu_err = -EINVAL;*/ __gu_err = __user_bad(); \ 238 } \ 239 __gu_err; \ 240 }) 241 242 static inline unsigned long 243 raw_copy_from_user(void *to, const void __user *from, unsigned long n) 244 { 245 return __copy_tofrom_user((__force void __user *)to, from, n); 246 } 247 248 static inline unsigned long 249 raw_copy_to_user(void __user *to, const void *from, unsigned long n) 250 { 251 return __copy_tofrom_user(to, (__force const void __user *)from, n); 252 } 253 #define INLINE_COPY_FROM_USER 254 #define INLINE_COPY_TO_USER 255 256 /* 257 * Copy a null terminated string from userspace. 258 */ 259 __must_check long strncpy_from_user(char *dst, const char __user *src, 260 long count); 261 262 /* 263 * Return the size of a string (including the ending 0) 264 * 265 * Return 0 on exception, a value greater than N if too long 266 */ 267 __must_check long strnlen_user(const char __user *sstr, long len); 268 269 #endif /* _ASM_MICROBLAZE_UACCESS_H */ 270