Loading...
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
13unsigned long __must_check __copy_to_user_ll
14 (void __user *to, const void *from, unsigned long n);
15unsigned long __must_check __copy_from_user_ll
16 (void *to, const void __user *from, unsigned long n);
17unsigned long __must_check __copy_from_user_ll_nozero
18 (void *to, const void __user *from, unsigned long n);
19unsigned long __must_check __copy_from_user_ll_nocache
20 (void *to, const void __user *from, unsigned long n);
21unsigned 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 */
37static __always_inline unsigned long __must_check
38__copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
39{
40 check_object_size(from, n, true);
41 return __copy_to_user_ll(to, from, n);
42}
43
44/**
45 * __copy_to_user: - Copy a block of data into user space, with less checking.
46 * @to: Destination address, in user space.
47 * @from: Source address, in kernel space.
48 * @n: Number of bytes to copy.
49 *
50 * Context: User context only. This function may sleep if pagefaults are
51 * enabled.
52 *
53 * Copy data from kernel space to user space. Caller must check
54 * the specified block with access_ok() before calling this function.
55 *
56 * Returns number of bytes that could not be copied.
57 * On success, this will be zero.
58 */
59static __always_inline unsigned long __must_check
60__copy_to_user(void __user *to, const void *from, unsigned long n)
61{
62 might_fault();
63 return __copy_to_user_inatomic(to, from, n);
64}
65
66static __always_inline unsigned long
67__copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
68{
69 return __copy_from_user_ll_nozero(to, from, n);
70}
71
72/**
73 * __copy_from_user: - Copy a block of data from user space, with less checking.
74 * @to: Destination address, in kernel space.
75 * @from: Source address, in user space.
76 * @n: Number of bytes to copy.
77 *
78 * Context: User context only. This function may sleep if pagefaults are
79 * enabled.
80 *
81 * Copy data from user space to kernel space. Caller must check
82 * the specified block with access_ok() before calling this function.
83 *
84 * Returns number of bytes that could not be copied.
85 * On success, this will be zero.
86 *
87 * If some data could not be copied, this function will pad the copied
88 * data to the requested size using zero bytes.
89 *
90 * An alternate version - __copy_from_user_inatomic() - may be called from
91 * atomic context and will fail rather than sleep. In this case the
92 * uncopied bytes will *NOT* be padded with zeros. See fs/filemap.h
93 * for explanation of why this is needed.
94 */
95static __always_inline unsigned long
96__copy_from_user(void *to, const void __user *from, unsigned long n)
97{
98 might_fault();
99 check_object_size(to, n, false);
100 if (__builtin_constant_p(n)) {
101 unsigned long ret;
102
103 switch (n) {
104 case 1:
105 __uaccess_begin();
106 __get_user_size(*(u8 *)to, from, 1, ret, 1);
107 __uaccess_end();
108 return ret;
109 case 2:
110 __uaccess_begin();
111 __get_user_size(*(u16 *)to, from, 2, ret, 2);
112 __uaccess_end();
113 return ret;
114 case 4:
115 __uaccess_begin();
116 __get_user_size(*(u32 *)to, from, 4, ret, 4);
117 __uaccess_end();
118 return ret;
119 }
120 }
121 return __copy_from_user_ll(to, from, n);
122}
123
124static __always_inline unsigned long __copy_from_user_nocache(void *to,
125 const void __user *from, unsigned long n)
126{
127 might_fault();
128 if (__builtin_constant_p(n)) {
129 unsigned long ret;
130
131 switch (n) {
132 case 1:
133 __uaccess_begin();
134 __get_user_size(*(u8 *)to, from, 1, ret, 1);
135 __uaccess_end();
136 return ret;
137 case 2:
138 __uaccess_begin();
139 __get_user_size(*(u16 *)to, from, 2, ret, 2);
140 __uaccess_end();
141 return ret;
142 case 4:
143 __uaccess_begin();
144 __get_user_size(*(u32 *)to, from, 4, ret, 4);
145 __uaccess_end();
146 return ret;
147 }
148 }
149 return __copy_from_user_ll_nocache(to, from, n);
150}
151
152static __always_inline unsigned long
153__copy_from_user_inatomic_nocache(void *to, const void __user *from,
154 unsigned long n)
155{
156 return __copy_from_user_ll_nocache_nozero(to, from, n);
157}
158
159#endif /* _ASM_X86_UACCESS_32_H */
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _ASM_X86_UACCESS_32_H
3#define _ASM_X86_UACCESS_32_H
4
5/*
6 * User space memory access functions
7 */
8#include <linux/string.h>
9#include <asm/asm.h>
10#include <asm/page.h>
11
12unsigned long __must_check __copy_user_ll
13 (void *to, const void *from, unsigned long n);
14unsigned long __must_check __copy_from_user_ll_nocache_nozero
15 (void *to, const void __user *from, unsigned long n);
16
17static __always_inline unsigned long __must_check
18raw_copy_to_user(void __user *to, const void *from, unsigned long n)
19{
20 return __copy_user_ll((__force void *)to, from, n);
21}
22
23static __always_inline unsigned long
24raw_copy_from_user(void *to, const void __user *from, unsigned long n)
25{
26 return __copy_user_ll(to, (__force const void *)from, n);
27}
28
29static __always_inline unsigned long
30__copy_from_user_inatomic_nocache(void *to, const void __user *from,
31 unsigned long n)
32{
33 return __copy_from_user_ll_nocache_nozero(to, from, n);
34}
35
36#endif /* _ASM_X86_UACCESS_32_H */