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

TOMOYO Linux Cross Reference
Linux/arch/sh/include/asm/uaccess.h

Version: ~ [ linux-5.14-rc1 ] ~ [ linux-5.13.1 ] ~ [ linux-5.12.16 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.49 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.131 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.197 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.239 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.275 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.275 ] ~ [ 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_SH_UACCESS_H
  2 #define __ASM_SH_UACCESS_H
  3 
  4 #include <linux/errno.h>
  5 #include <linux/sched.h>
  6 #include <asm/segment.h>
  7 
  8 #define VERIFY_READ    0
  9 #define VERIFY_WRITE   1
 10 
 11 #define __addr_ok(addr) \
 12         ((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)
 13 
 14 /*
 15  * __access_ok: Check if address with size is OK or not.
 16  *
 17  * Uhhuh, this needs 33-bit arithmetic. We have a carry..
 18  *
 19  * sum := addr + size;  carry? --> flag = true;
 20  * if (sum >= addr_limit) flag = true;
 21  */
 22 #define __access_ok(addr, size)         \
 23         (__addr_ok((addr) + (size)))
 24 #define access_ok(type, addr, size)     \
 25         (__chk_user_ptr(addr),          \
 26          __access_ok((unsigned long __force)(addr), (size)))
 27 
 28 #define user_addr_max() (current_thread_info()->addr_limit.seg)
 29 
 30 /*
 31  * Uh, these should become the main single-value transfer routines ...
 32  * They automatically use the right size if we just have the right
 33  * pointer type ...
 34  *
 35  * As SuperH uses the same address space for kernel and user data, we
 36  * can just do these as direct assignments.
 37  *
 38  * Careful to not
 39  * (a) re-use the arguments for side effects (sizeof is ok)
 40  * (b) require any knowledge of processes at this stage
 41  */
 42 #define put_user(x,ptr)         __put_user_check((x), (ptr), sizeof(*(ptr)))
 43 #define get_user(x,ptr)         __get_user_check((x), (ptr), sizeof(*(ptr)))
 44 
 45 /*
 46  * The "__xxx" versions do not do address space checking, useful when
 47  * doing multiple accesses to the same area (the user has to do the
 48  * checks by hand with "access_ok()")
 49  */
 50 #define __put_user(x,ptr)       __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
 51 #define __get_user(x,ptr)       __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
 52 
 53 struct __large_struct { unsigned long buf[100]; };
 54 #define __m(x) (*(struct __large_struct __user *)(x))
 55 
 56 #define __get_user_nocheck(x,ptr,size)                          \
 57 ({                                                              \
 58         long __gu_err;                                          \
 59         unsigned long __gu_val;                                 \
 60         const __typeof__(*(ptr)) __user *__gu_addr = (ptr);     \
 61         __chk_user_ptr(ptr);                                    \
 62         __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
 63         (x) = (__force __typeof__(*(ptr)))__gu_val;             \
 64         __gu_err;                                               \
 65 })
 66 
 67 #define __get_user_check(x,ptr,size)                                    \
 68 ({                                                                      \
 69         long __gu_err = -EFAULT;                                        \
 70         unsigned long __gu_val = 0;                                     \
 71         const __typeof__(*(ptr)) *__gu_addr = (ptr);                    \
 72         if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))          \
 73                 __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
 74         (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
 75         __gu_err;                                                       \
 76 })
 77 
 78 #define __put_user_nocheck(x,ptr,size)                          \
 79 ({                                                              \
 80         long __pu_err;                                          \
 81         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
 82         __typeof__(*(ptr)) __pu_val = x;                        \
 83         __chk_user_ptr(ptr);                                    \
 84         __put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
 85         __pu_err;                                               \
 86 })
 87 
 88 #define __put_user_check(x,ptr,size)                            \
 89 ({                                                              \
 90         long __pu_err = -EFAULT;                                \
 91         __typeof__(*(ptr)) __user *__pu_addr = (ptr);           \
 92         __typeof__(*(ptr)) __pu_val = x;                        \
 93         if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))   \
 94                 __put_user_size(__pu_val, __pu_addr, (size),    \
 95                                 __pu_err);                      \
 96         __pu_err;                                               \
 97 })
 98 
 99 #ifdef CONFIG_SUPERH32
100 # include <asm/uaccess_32.h>
101 #else
102 # include <asm/uaccess_64.h>
103 #endif
104 
105 extern long strncpy_from_user(char *dest, const char __user *src, long count);
106 
107 extern __must_check long strlen_user(const char __user *str);
108 extern __must_check long strnlen_user(const char __user *str, long n);
109 
110 /* Generic arbitrary sized copy.  */
111 /* Return the number of bytes NOT copied */
112 __kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);
113 
114 static __always_inline unsigned long
115 __copy_from_user(void *to, const void __user *from, unsigned long n)
116 {
117         return __copy_user(to, (__force void *)from, n);
118 }
119 
120 static __always_inline unsigned long __must_check
121 __copy_to_user(void __user *to, const void *from, unsigned long n)
122 {
123         return __copy_user((__force void *)to, from, n);
124 }
125 
126 #define __copy_to_user_inatomic __copy_to_user
127 #define __copy_from_user_inatomic __copy_from_user
128 
129 /*
130  * Clear the area and return remaining number of bytes
131  * (on failure.  Usually it's 0.)
132  */
133 __kernel_size_t __clear_user(void *addr, __kernel_size_t size);
134 
135 #define clear_user(addr,n)                                              \
136 ({                                                                      \
137         void __user * __cl_addr = (addr);                               \
138         unsigned long __cl_size = (n);                                  \
139                                                                         \
140         if (__cl_size && access_ok(VERIFY_WRITE,                        \
141                 ((unsigned long)(__cl_addr)), __cl_size))               \
142                 __cl_size = __clear_user(__cl_addr, __cl_size);         \
143                                                                         \
144         __cl_size;                                                      \
145 })
146 
147 static inline unsigned long
148 copy_from_user(void *to, const void __user *from, unsigned long n)
149 {
150         unsigned long __copy_from = (unsigned long) from;
151         __kernel_size_t __copy_size = (__kernel_size_t) n;
152 
153         if (__copy_size && __access_ok(__copy_from, __copy_size))
154                 __copy_size = __copy_user(to, from, __copy_size);
155 
156         if (unlikely(__copy_size))
157                 memset(to + (n - __copy_size), 0, __copy_size);
158 
159         return __copy_size;
160 }
161 
162 static inline unsigned long
163 copy_to_user(void __user *to, const void *from, unsigned long n)
164 {
165         unsigned long __copy_to = (unsigned long) to;
166         __kernel_size_t __copy_size = (__kernel_size_t) n;
167 
168         if (__copy_size && __access_ok(__copy_to, __copy_size))
169                 return __copy_user(to, from, __copy_size);
170 
171         return __copy_size;
172 }
173 
174 /*
175  * The exception table consists of pairs of addresses: the first is the
176  * address of an instruction that is allowed to fault, and the second is
177  * the address at which the program should continue.  No registers are
178  * modified, so it is entirely up to the continuation code to figure out
179  * what to do.
180  *
181  * All the routines below use bits of fixup code that are out of line
182  * with the main instruction path.  This means when everything is well,
183  * we don't even have to jump over them.  Further, they do not intrude
184  * on our cache or tlb entries.
185  */
186 struct exception_table_entry {
187         unsigned long insn, fixup;
188 };
189 
190 #if defined(CONFIG_SUPERH64) && defined(CONFIG_MMU)
191 #define ARCH_HAS_SEARCH_EXTABLE
192 #endif
193 
194 int fixup_exception(struct pt_regs *regs);
195 
196 extern void *set_exception_table_vec(unsigned int vec, void *handler);
197 
198 static inline void *set_exception_table_evt(unsigned int evt, void *handler)
199 {
200         return set_exception_table_vec(evt >> 5, handler);
201 }
202 
203 struct mem_access {
204         unsigned long (*from)(void *dst, const void __user *src, unsigned long cnt);
205         unsigned long (*to)(void __user *dst, const void *src, unsigned long cnt);
206 };
207 
208 int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
209                             struct mem_access *ma, int, unsigned long address);
210 
211 #endif /* __ASM_SH_UACCESS_H */
212 

~ [ 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