Branch data Line data Source code
1 : : #ifndef __LINUX_UACCESS_H__
2 : : #define __LINUX_UACCESS_H__
3 : :
4 : : #include <linux/preempt.h>
5 : : #include <asm/uaccess.h>
6 : :
7 : : /*
8 : : * These routines enable/disable the pagefault handler in that
9 : : * it will not take any locks and go straight to the fixup table.
10 : : *
11 : : * They have great resemblance to the preempt_disable/enable calls
12 : : * and in fact they are identical; this is because currently there is
13 : : * no other way to make the pagefault handlers do this. So we do
14 : : * disable preemption but we don't necessarily care about that.
15 : : */
16 : : static inline void pagefault_disable(void)
17 : : {
18 : : preempt_count_inc();
19 : : /*
20 : : * make sure to have issued the store before a pagefault
21 : : * can hit.
22 : : */
23 : 231313075 : barrier();
24 : : }
25 : :
26 : : static inline void pagefault_enable(void)
27 : : {
28 : : #ifndef CONFIG_PREEMPT
29 : : /*
30 : : * make sure to issue those last loads/stores before enabling
31 : : * the pagefault handler again.
32 : : */
33 : 231390436 : barrier();
34 : : preempt_count_dec();
35 : : #else
36 : : preempt_enable();
37 : : #endif
38 : : }
39 : :
40 : : #ifndef ARCH_HAS_NOCACHE_UACCESS
41 : :
42 : : static inline unsigned long __copy_from_user_inatomic_nocache(void *to,
43 : : const void __user *from, unsigned long n)
44 : : {
45 : : return __copy_from_user_inatomic(to, from, n);
46 : : }
47 : :
48 : : static inline unsigned long __copy_from_user_nocache(void *to,
49 : : const void __user *from, unsigned long n)
50 : : {
51 : 0 : return __copy_from_user(to, from, n);
52 : : }
53 : :
54 : : #endif /* ARCH_HAS_NOCACHE_UACCESS */
55 : :
56 : : /**
57 : : * probe_kernel_address(): safely attempt to read from a location
58 : : * @addr: address to read from - its type is type typeof(retval)*
59 : : * @retval: read into this variable
60 : : *
61 : : * Safely read from address @addr into variable @revtal. If a kernel fault
62 : : * happens, handle that and return -EFAULT.
63 : : * We ensure that the __get_user() is executed in atomic context so that
64 : : * do_page_fault() doesn't attempt to take mmap_sem. This makes
65 : : * probe_kernel_address() suitable for use within regions where the caller
66 : : * already holds mmap_sem, or other locks which nest inside mmap_sem.
67 : : * This must be a macro because __get_user() needs to know the types of the
68 : : * args.
69 : : *
70 : : * We don't include enough header files to be able to do the set_fs(). We
71 : : * require that the probe_kernel_address() caller will do that.
72 : : */
73 : : #define probe_kernel_address(addr, retval) \
74 : : ({ \
75 : : long ret; \
76 : : mm_segment_t old_fs = get_fs(); \
77 : : \
78 : : set_fs(KERNEL_DS); \
79 : : pagefault_disable(); \
80 : : ret = __copy_from_user_inatomic(&(retval), (__force typeof(retval) __user *)(addr), sizeof(retval)); \
81 : : pagefault_enable(); \
82 : : set_fs(old_fs); \
83 : : ret; \
84 : : })
85 : :
86 : : /*
87 : : * probe_kernel_read(): safely attempt to read from a location
88 : : * @dst: pointer to the buffer that shall take the data
89 : : * @src: address to read from
90 : : * @size: size of the data chunk
91 : : *
92 : : * Safely read from address @src to the buffer at @dst. If a kernel fault
93 : : * happens, handle that and return -EFAULT.
94 : : */
95 : : extern long probe_kernel_read(void *dst, const void *src, size_t size);
96 : : extern long __probe_kernel_read(void *dst, const void *src, size_t size);
97 : :
98 : : /*
99 : : * probe_kernel_write(): safely attempt to write to a location
100 : : * @dst: address to write to
101 : : * @src: pointer to the data that shall be written
102 : : * @size: size of the data chunk
103 : : *
104 : : * Safely write to address @dst from the buffer at @src. If a kernel fault
105 : : * happens, handle that and return -EFAULT.
106 : : */
107 : : extern long notrace probe_kernel_write(void *dst, const void *src, size_t size);
108 : : extern long notrace __probe_kernel_write(void *dst, const void *src, size_t size);
109 : :
110 : : #endif /* __LINUX_UACCESS_H__ */
|
