1/* SPDX-License-Identifier: GPL-2.0 */ 2/* 3 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited 4 * 5 * Derived from MIPS: 6 * Copyright (C) 1996, 1997, 1998, 1999, 2000, 03, 04 by Ralf Baechle 7 * Copyright (C) 1999, 2000 Silicon Graphics, Inc. 8 * Copyright (C) 2007 Maciej W. Rozycki 9 * Copyright (C) 2014, Imagination Technologies Ltd. 10 */ 11#ifndef _ASM_UACCESS_H 12#define _ASM_UACCESS_H 13 14#include <linux/kernel.h> 15#include <linux/string.h> 16#include <linux/extable.h> 17#include <asm/pgtable.h> 18#include <asm/extable.h> 19#include <asm/asm-extable.h> 20#include <asm-generic/access_ok.h> 21 22extern u64 __ua_limit; 23 24#define __UA_ADDR ".dword" 25#define __UA_LIMIT __ua_limit 26 27/* 28 * get_user: - Get a simple variable from user space. 29 * @x: Variable to store result. 30 * @ptr: Source address, in user space. 31 * 32 * Context: User context only. This function may sleep if pagefaults are 33 * enabled. 34 * 35 * This macro copies a single simple variable from user space to kernel 36 * space. It supports simple types like char and int, but not larger 37 * data types like structures or arrays. 38 * 39 * @ptr must have pointer-to-simple-variable type, and the result of 40 * dereferencing @ptr must be assignable to @x without a cast. 41 * 42 * Returns zero on success, or -EFAULT on error. 43 * On error, the variable @x is set to zero. 44 */ 45#define get_user(x, ptr) \ 46({ \ 47 const __typeof__(*(ptr)) __user *__p = (ptr); \ 48 \ 49 might_fault(); \ 50 access_ok(__p, sizeof(*__p)) ? __get_user((x), __p) : \ 51 ((x) = 0, -EFAULT); \ 52}) 53 54/* 55 * put_user: - Write a simple value into user space. 56 * @x: Value to copy to user space. 57 * @ptr: Destination address, in user space. 58 * 59 * Context: User context only. This function may sleep if pagefaults are 60 * enabled. 61 * 62 * This macro copies a single simple value from kernel space to user 63 * space. It supports simple types like char and int, but not larger 64 * data types like structures or arrays. 65 * 66 * @ptr must have pointer-to-simple-variable type, and @x must be assignable 67 * to the result of dereferencing @ptr. 68 * 69 * Returns zero on success, or -EFAULT on error. 70 */ 71#define put_user(x, ptr) \ 72({ \ 73 __typeof__(*(ptr)) __user *__p = (ptr); \ 74 \ 75 might_fault(); \ 76 access_ok(__p, sizeof(*__p)) ? __put_user((x), __p) : -EFAULT; \ 77}) 78 79/* 80 * __get_user: - Get a simple variable from user space, with less checking. 81 * @x: Variable to store result. 82 * @ptr: Source address, in user space. 83 * 84 * Context: User context only. This function may sleep if pagefaults are 85 * enabled. 86 * 87 * This macro copies a single simple variable from user space to kernel 88 * space. It supports simple types like char and int, but not larger 89 * data types like structures or arrays. 90 * 91 * @ptr must have pointer-to-simple-variable type, and the result of 92 * dereferencing @ptr must be assignable to @x without a cast. 93 * 94 * Caller must check the pointer with access_ok() before calling this 95 * function. 96 * 97 * Returns zero on success, or -EFAULT on error. 98 * On error, the variable @x is set to zero. 99 */ 100#define __get_user(x, ptr) \ 101({ \ 102 int __gu_err = 0; \ 103 \ 104 __chk_user_ptr(ptr); \ 105 __get_user_common((x), sizeof(*(ptr)), ptr); \ 106 __gu_err; \ 107}) 108 109/* 110 * __put_user: - Write a simple value into user space, with less checking. 111 * @x: Value to copy to user space. 112 * @ptr: Destination address, in user space. 113 * 114 * Context: User context only. This function may sleep if pagefaults are 115 * enabled. 116 * 117 * This macro copies a single simple value from kernel space to user 118 * space. It supports simple types like char and int, but not larger 119 * data types like structures or arrays. 120 * 121 * @ptr must have pointer-to-simple-variable type, and @x must be assignable 122 * to the result of dereferencing @ptr. 123 * 124 * Caller must check the pointer with access_ok() before calling this 125 * function. 126 * 127 * Returns zero on success, or -EFAULT on error. 128 */ 129#define __put_user(x, ptr) \ 130({ \ 131 int __pu_err = 0; \ 132 __typeof__(*(ptr)) __pu_val; \ 133 \ 134 __pu_val = (x); \ 135 __chk_user_ptr(ptr); \ 136 __put_user_common(ptr, sizeof(*(ptr))); \ 137 __pu_err; \ 138}) 139 140struct __large_struct { unsigned long buf[100]; }; 141#define __m(x) (*(struct __large_struct __user *)(x)) 142 143#define __get_user_common(val, size, ptr) \ 144do { \ 145 switch (size) { \ 146 case 1: __get_data_asm(val, "ld.b", ptr); break; \ 147 case 2: __get_data_asm(val, "ld.h", ptr); break; \ 148 case 4: __get_data_asm(val, "ld.w", ptr); break; \ 149 case 8: __get_data_asm(val, "ld.d", ptr); break; \ 150 default: BUILD_BUG(); break; \ 151 } \ 152} while (0) 153 154#define __get_kernel_common(val, size, ptr) __get_user_common(val, size, ptr) 155 156#define __get_data_asm(val, insn, ptr) \ 157{ \ 158 long __gu_tmp; \ 159 \ 160 __asm__ __volatile__( \ 161 "1: " insn " %1, %2 \n" \ 162 "2: \n" \ 163 _ASM_EXTABLE_UACCESS_ERR_ZERO(1b, 2b, %0, %1) \ 164 : "+r" (__gu_err), "=r" (__gu_tmp) \ 165 : "m" (__m(ptr))); \ 166 \ 167 (val) = (__typeof__(*(ptr))) __gu_tmp; \ 168} 169 170#define __put_user_common(ptr, size) \ 171do { \ 172 switch (size) { \ 173 case 1: __put_data_asm("st.b", ptr); break; \ 174 case 2: __put_data_asm("st.h", ptr); break; \ 175 case 4: __put_data_asm("st.w", ptr); break; \ 176 case 8: __put_data_asm("st.d", ptr); break; \ 177 default: BUILD_BUG(); break; \ 178 } \ 179} while (0) 180 181#define __put_kernel_common(ptr, size) __put_user_common(ptr, size) 182 183#define __put_data_asm(insn, ptr) \ 184{ \ 185 __asm__ __volatile__( \ 186 "1: " insn " %z2, %1 # __put_user_asm\n" \ 187 "2: \n" \ 188 _ASM_EXTABLE_UACCESS_ERR(1b, 2b, %0) \ 189 : "+r" (__pu_err), "=m" (__m(ptr)) \ 190 : "Jr" (__pu_val)); \ 191} 192 193#define __get_kernel_nofault(dst, src, type, err_label) \ 194do { \ 195 int __gu_err = 0; \ 196 \ 197 __get_kernel_common(*((type *)(dst)), sizeof(type), \ 198 (__force type *)(src)); \ 199 if (unlikely(__gu_err)) \ 200 goto err_label; \ 201} while (0) 202 203#define __put_kernel_nofault(dst, src, type, err_label) \ 204do { \ 205 type __pu_val; \ 206 int __pu_err = 0; \ 207 \ 208 __pu_val = *(__force type *)(src); \ 209 __put_kernel_common(((type *)(dst)), sizeof(type)); \ 210 if (unlikely(__pu_err)) \ 211 goto err_label; \ 212} while (0) 213 214extern unsigned long __copy_user(void *to, const void *from, __kernel_size_t n); 215 216static inline unsigned long __must_check 217raw_copy_from_user(void *to, const void __user *from, unsigned long n) 218{ 219 return __copy_user(to, (__force const void *)from, n); 220} 221 222static inline unsigned long __must_check 223raw_copy_to_user(void __user *to, const void *from, unsigned long n) 224{ 225 return __copy_user((__force void *)to, from, n); 226} 227 228#define INLINE_COPY_FROM_USER 229#define INLINE_COPY_TO_USER 230 231/* 232 * __clear_user: - Zero a block of memory in user space, with less checking. 233 * @addr: Destination address, in user space. 234 * @size: Number of bytes to zero. 235 * 236 * Zero a block of memory in user space. Caller must check 237 * the specified block with access_ok() before calling this function. 238 * 239 * Returns number of bytes that could not be cleared. 240 * On success, this will be zero. 241 */ 242extern unsigned long __clear_user(void __user *addr, __kernel_size_t size); 243 244#define clear_user(addr, n) \ 245({ \ 246 void __user *__cl_addr = (addr); \ 247 unsigned long __cl_size = (n); \ 248 if (__cl_size && access_ok(__cl_addr, __cl_size)) \ 249 __cl_size = __clear_user(__cl_addr, __cl_size); \ 250 __cl_size; \ 251}) 252 253extern long strncpy_from_user(char *to, const char __user *from, long n); 254extern long strnlen_user(const char __user *str, long n); 255 256#endif /* _ASM_UACCESS_H */ 257