~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/include/asm/uaccess_32.h

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifndef _ASM_X86_UACCESS_32_H
  2 #define _ASM_X86_UACCESS_32_H
  3 
  4 /*
  5  * User space memory access functions
  6  */
  7 #include <linux/errno.h>
  8 #include <linux/thread_info.h>
  9 #include <linux/string.h>
 10 #include <asm/asm.h>
 11 #include <asm/page.h>
 12 
 13 unsigned long __must_check __copy_to_user_ll
 14                 (void __user *to, const void *from, unsigned long n);
 15 unsigned long __must_check __copy_from_user_ll
 16                 (void *to, const void __user *from, unsigned long n);
 17 unsigned long __must_check __copy_from_user_ll_nozero
 18                 (void *to, const void __user *from, unsigned long n);
 19 unsigned long __must_check __copy_from_user_ll_nocache
 20                 (void *to, const void __user *from, unsigned long n);
 21 unsigned long __must_check __copy_from_user_ll_nocache_nozero
 22                 (void *to, const void __user *from, unsigned long n);
 23 
 24 /**
 25  * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking.
 26  * @to:   Destination address, in user space.
 27  * @from: Source address, in kernel space.
 28  * @n:    Number of bytes to copy.
 29  *
 30  * Context: User context only.
 31  *
 32  * Copy data from kernel space to user space.  Caller must check
 33  * the specified block with access_ok() before calling this function.
 34  * The caller should also make sure he pins the user space address
 35  * so that we don't result in page fault and sleep.
 36  *
 37  * Here we special-case 1, 2 and 4-byte copy_*_user invocations.  On a fault
 38  * we return the initial request size (1, 2 or 4), as copy_*_user should do.
 39  * If a store crosses a page boundary and gets a fault, the x86 will not write
 40  * anything, so this is accurate.
 41  */
 42 
 43 static __always_inline unsigned long __must_check
 44 __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
 45 {
 46         if (__builtin_constant_p(n)) {
 47                 unsigned long ret;
 48 
 49                 switch (n) {
 50                 case 1:
 51                         __put_user_size(*(u8 *)from, (u8 __user *)to,
 52                                         1, ret, 1);
 53                         return ret;
 54                 case 2:
 55                         __put_user_size(*(u16 *)from, (u16 __user *)to,
 56                                         2, ret, 2);
 57                         return ret;
 58                 case 4:
 59                         __put_user_size(*(u32 *)from, (u32 __user *)to,
 60                                         4, ret, 4);
 61                         return ret;
 62                 }
 63         }
 64         return __copy_to_user_ll(to, from, n);
 65 }
 66 
 67 /**
 68  * __copy_to_user: - Copy a block of data into user space, with less checking.
 69  * @to:   Destination address, in user space.
 70  * @from: Source address, in kernel space.
 71  * @n:    Number of bytes to copy.
 72  *
 73  * Context: User context only.  This function may sleep.
 74  *
 75  * Copy data from kernel space to user space.  Caller must check
 76  * the specified block with access_ok() before calling this function.
 77  *
 78  * Returns number of bytes that could not be copied.
 79  * On success, this will be zero.
 80  */
 81 static __always_inline unsigned long __must_check
 82 __copy_to_user(void __user *to, const void *from, unsigned long n)
 83 {
 84         might_fault();
 85         return __copy_to_user_inatomic(to, from, n);
 86 }
 87 
 88 static __always_inline unsigned long
 89 __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
 90 {
 91         /* Avoid zeroing the tail if the copy fails..
 92          * If 'n' is constant and 1, 2, or 4, we do still zero on a failure,
 93          * but as the zeroing behaviour is only significant when n is not
 94          * constant, that shouldn't be a problem.
 95          */
 96         if (__builtin_constant_p(n)) {
 97                 unsigned long ret;
 98 
 99                 switch (n) {
100                 case 1:
101                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
102                         return ret;
103                 case 2:
104                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
105                         return ret;
106                 case 4:
107                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
108                         return ret;
109                 }
110         }
111         return __copy_from_user_ll_nozero(to, from, n);
112 }
113 
114 /**
115  * __copy_from_user: - Copy a block of data from user space, with less checking.
116  * @to:   Destination address, in kernel space.
117  * @from: Source address, in user space.
118  * @n:    Number of bytes to copy.
119  *
120  * Context: User context only.  This function may sleep.
121  *
122  * Copy data from user space to kernel space.  Caller must check
123  * the specified block with access_ok() before calling this function.
124  *
125  * Returns number of bytes that could not be copied.
126  * On success, this will be zero.
127  *
128  * If some data could not be copied, this function will pad the copied
129  * data to the requested size using zero bytes.
130  *
131  * An alternate version - __copy_from_user_inatomic() - may be called from
132  * atomic context and will fail rather than sleep.  In this case the
133  * uncopied bytes will *NOT* be padded with zeros.  See fs/filemap.h
134  * for explanation of why this is needed.
135  */
136 static __always_inline unsigned long
137 __copy_from_user(void *to, const void __user *from, unsigned long n)
138 {
139         might_fault();
140         if (__builtin_constant_p(n)) {
141                 unsigned long ret;
142 
143                 switch (n) {
144                 case 1:
145                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
146                         return ret;
147                 case 2:
148                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
149                         return ret;
150                 case 4:
151                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
152                         return ret;
153                 }
154         }
155         return __copy_from_user_ll(to, from, n);
156 }
157 
158 static __always_inline unsigned long __copy_from_user_nocache(void *to,
159                                 const void __user *from, unsigned long n)
160 {
161         might_fault();
162         if (__builtin_constant_p(n)) {
163                 unsigned long ret;
164 
165                 switch (n) {
166                 case 1:
167                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
168                         return ret;
169                 case 2:
170                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
171                         return ret;
172                 case 4:
173                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
174                         return ret;
175                 }
176         }
177         return __copy_from_user_ll_nocache(to, from, n);
178 }
179 
180 static __always_inline unsigned long
181 __copy_from_user_inatomic_nocache(void *to, const void __user *from,
182                                   unsigned long n)
183 {
184        return __copy_from_user_ll_nocache_nozero(to, from, n);
185 }
186 
187 unsigned long __must_check copy_to_user(void __user *to,
188                                         const void *from, unsigned long n);
189 unsigned long __must_check _copy_from_user(void *to,
190                                           const void __user *from,
191                                           unsigned long n);
192 
193 
194 extern void copy_from_user_overflow(void)
195 #ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS
196         __compiletime_error("copy_from_user() buffer size is not provably correct")
197 #else
198         __compiletime_warning("copy_from_user() buffer size is not provably correct")
199 #endif
200 ;
201 
202 static inline unsigned long __must_check copy_from_user(void *to,
203                                           const void __user *from,
204                                           unsigned long n)
205 {
206         int sz = __compiletime_object_size(to);
207 
208         if (likely(sz == -1 || sz >= n))
209                 n = _copy_from_user(to, from, n);
210         else
211                 copy_from_user_overflow();
212 
213         return n;
214 }
215 
216 #endif /* _ASM_X86_UACCESS_32_H */
217 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp