2 * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3 * Licensed under the GPL
7 #include <linux/highmem.h>
9 #include <linux/sched.h>
10 #include <asm/current.h>
12 #include <asm/pgtable.h>
13 #include "kern_util.h"
16 pte_t
*virt_to_pte(struct mm_struct
*mm
, unsigned long addr
)
25 pgd
= pgd_offset(mm
, addr
);
26 if (!pgd_present(*pgd
))
29 pud
= pud_offset(pgd
, addr
);
30 if (!pud_present(*pud
))
33 pmd
= pmd_offset(pud
, addr
);
34 if (!pmd_present(*pmd
))
37 return pte_offset_kernel(pmd
, addr
);
40 static pte_t
*maybe_map(unsigned long virt
, int is_write
)
42 pte_t
*pte
= virt_to_pte(current
->mm
, virt
);
45 if ((pte
== NULL
) || !pte_present(*pte
) ||
46 (is_write
&& !pte_write(*pte
))) {
47 err
= handle_page_fault(virt
, 0, is_write
, 1, &dummy_code
);
50 pte
= virt_to_pte(current
->mm
, virt
);
52 if (!pte_present(*pte
))
58 static int do_op_one_page(unsigned long addr
, int len
, int is_write
,
59 int (*op
)(unsigned long addr
, int len
, void *arg
), void *arg
)
65 pte
= maybe_map(addr
, is_write
);
69 page
= pte_page(*pte
);
70 addr
= (unsigned long) kmap_atomic(page
, KM_UML_USERCOPY
) +
73 n
= (*op
)(addr
, len
, arg
);
75 kunmap_atomic(page
, KM_UML_USERCOPY
);
80 static void do_buffer_op(void *jmpbuf
, void *arg_ptr
)
84 int len
, is_write
, size
, remain
, n
;
85 int (*op
)(unsigned long, int, void *);
89 va_copy(args
, *(va_list *)arg_ptr
);
90 addr
= va_arg(args
, unsigned long);
91 len
= va_arg(args
, int);
92 is_write
= va_arg(args
, int);
93 op
= va_arg(args
, void *);
94 arg
= va_arg(args
, void *);
95 res
= va_arg(args
, int *);
97 size
= min(PAGE_ALIGN(addr
) - addr
, (unsigned long) len
);
100 current
->thread
.fault_catcher
= jmpbuf
;
101 n
= do_op_one_page(addr
, size
, is_write
, op
, arg
);
103 *res
= (n
< 0 ? remain
: 0);
114 while(addr
< ((addr
+ remain
) & PAGE_MASK
)) {
115 n
= do_op_one_page(addr
, PAGE_SIZE
, is_write
, op
, arg
);
117 *res
= (n
< 0 ? remain
: 0);
129 n
= do_op_one_page(addr
, remain
, is_write
, op
, arg
);
131 *res
= (n
< 0 ? remain
: 0);
134 current
->thread
.fault_catcher
= NULL
;
137 static int buffer_op(unsigned long addr
, int len
, int is_write
,
138 int (*op
)(unsigned long addr
, int len
, void *arg
),
143 faulted
= setjmp_wrapper(do_buffer_op
, addr
, len
, is_write
, op
, arg
,
148 return addr
+ len
- (unsigned long) current
->thread
.fault_addr
;
151 static int copy_chunk_from_user(unsigned long from
, int len
, void *arg
)
153 unsigned long *to_ptr
= arg
, to
= *to_ptr
;
155 memcpy((void *) to
, (void *) from
, len
);
160 int copy_from_user(void *to
, const void __user
*from
, int n
)
162 if (segment_eq(get_fs(), KERNEL_DS
)) {
163 memcpy(to
, (__force
void*)from
, n
);
167 return access_ok(VERIFY_READ
, from
, n
) ?
168 buffer_op((unsigned long) from
, n
, 0, copy_chunk_from_user
, &to
):
172 static int copy_chunk_to_user(unsigned long to
, int len
, void *arg
)
174 unsigned long *from_ptr
= arg
, from
= *from_ptr
;
176 memcpy((void *) to
, (void *) from
, len
);
181 int copy_to_user(void __user
*to
, const void *from
, int n
)
183 if (segment_eq(get_fs(), KERNEL_DS
)) {
184 memcpy((__force
void *) to
, from
, n
);
188 return access_ok(VERIFY_WRITE
, to
, n
) ?
189 buffer_op((unsigned long) to
, n
, 1, copy_chunk_to_user
, &from
) :
193 static int strncpy_chunk_from_user(unsigned long from
, int len
, void *arg
)
195 char **to_ptr
= arg
, *to
= *to_ptr
;
198 strncpy(to
, (void *) from
, len
);
199 n
= strnlen(to
, len
);
207 int strncpy_from_user(char *dst
, const char __user
*src
, int count
)
212 if (segment_eq(get_fs(), KERNEL_DS
)) {
213 strncpy(dst
, (__force
void *) src
, count
);
214 return strnlen(dst
, count
);
217 if (!access_ok(VERIFY_READ
, src
, 1))
220 n
= buffer_op((unsigned long) src
, count
, 0, strncpy_chunk_from_user
,
224 return strnlen(dst
, count
);
227 static int clear_chunk(unsigned long addr
, int len
, void *unused
)
229 memset((void *) addr
, 0, len
);
233 int __clear_user(void __user
*mem
, int len
)
235 return buffer_op((unsigned long) mem
, len
, 1, clear_chunk
, NULL
);
238 int clear_user(void __user
*mem
, int len
)
240 if (segment_eq(get_fs(), KERNEL_DS
)) {
241 memset((__force
void*)mem
, 0, len
);
245 return access_ok(VERIFY_WRITE
, mem
, len
) ?
246 buffer_op((unsigned long) mem
, len
, 1, clear_chunk
, NULL
) : len
;
249 static int strnlen_chunk(unsigned long str
, int len
, void *arg
)
251 int *len_ptr
= arg
, n
;
253 n
= strnlen((void *) str
, len
);
261 int strnlen_user(const void __user
*str
, int len
)
265 if (segment_eq(get_fs(), KERNEL_DS
))
266 return strnlen((__force
char*)str
, len
) + 1;
268 n
= buffer_op((unsigned long) str
, len
, 0, strnlen_chunk
, &count
);