Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
8ca842c4 | 2 | * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
1da177e4 LT |
3 | * Licensed under the GPL |
4 | */ | |
5 | ||
8192ab42 JD |
6 | #include <linux/err.h> |
7 | #include <linux/highmem.h> | |
8 | #include <linux/mm.h> | |
73395a00 | 9 | #include <linux/module.h> |
8192ab42 JD |
10 | #include <linux/sched.h> |
11 | #include <asm/current.h> | |
12 | #include <asm/page.h> | |
13 | #include <asm/pgtable.h> | |
37185b33 AV |
14 | #include <kern_util.h> |
15 | #include <os.h> | |
1da177e4 | 16 | |
ca77b555 | 17 | pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr) |
9157f90f JD |
18 | { |
19 | pgd_t *pgd; | |
20 | pud_t *pud; | |
21 | pmd_t *pmd; | |
9157f90f | 22 | |
ca77b555 JD |
23 | if (mm == NULL) |
24 | return NULL; | |
25 | ||
26 | pgd = pgd_offset(mm, addr); | |
9157f90f | 27 | if (!pgd_present(*pgd)) |
ca77b555 | 28 | return NULL; |
9157f90f JD |
29 | |
30 | pud = pud_offset(pgd, addr); | |
31 | if (!pud_present(*pud)) | |
ca77b555 | 32 | return NULL; |
9157f90f JD |
33 | |
34 | pmd = pmd_offset(pud, addr); | |
35 | if (!pmd_present(*pmd)) | |
ca77b555 | 36 | return NULL; |
9157f90f | 37 | |
ca77b555 | 38 | return pte_offset_kernel(pmd, addr); |
9157f90f | 39 | } |
1da177e4 | 40 | |
ca77b555 | 41 | static pte_t *maybe_map(unsigned long virt, int is_write) |
1da177e4 | 42 | { |
ca77b555 JD |
43 | pte_t *pte = virt_to_pte(current->mm, virt); |
44 | int err, dummy_code; | |
1da177e4 | 45 | |
ca77b555 JD |
46 | if ((pte == NULL) || !pte_present(*pte) || |
47 | (is_write && !pte_write(*pte))) { | |
1da177e4 | 48 | err = handle_page_fault(virt, 0, is_write, 1, &dummy_code); |
8ca842c4 | 49 | if (err) |
ca77b555 JD |
50 | return NULL; |
51 | pte = virt_to_pte(current->mm, virt); | |
1da177e4 | 52 | } |
ca77b555 JD |
53 | if (!pte_present(*pte)) |
54 | pte = NULL; | |
2d58cc9a | 55 | |
ca77b555 | 56 | return pte; |
1da177e4 LT |
57 | } |
58 | ||
47e5243a | 59 | static int do_op_one_page(unsigned long addr, int len, int is_write, |
1da177e4 LT |
60 | int (*op)(unsigned long addr, int len, void *arg), void *arg) |
61 | { | |
8efa3c9d | 62 | jmp_buf buf; |
1da177e4 | 63 | struct page *page; |
ca77b555 | 64 | pte_t *pte; |
8efa3c9d | 65 | int n, faulted; |
1da177e4 | 66 | |
ca77b555 JD |
67 | pte = maybe_map(addr, is_write); |
68 | if (pte == NULL) | |
8ca842c4 | 69 | return -1; |
1da177e4 | 70 | |
ca77b555 | 71 | page = pte_page(*pte); |
91f23593 | 72 | addr = (unsigned long) kmap_atomic(page) + |
8ca842c4 | 73 | (addr & ~PAGE_MASK); |
47e5243a | 74 | |
8efa3c9d JD |
75 | current->thread.fault_catcher = &buf; |
76 | ||
77 | faulted = UML_SETJMP(&buf); | |
78 | if (faulted == 0) | |
79 | n = (*op)(addr, len, arg); | |
80 | else | |
81 | n = -1; | |
82 | ||
83 | current->thread.fault_catcher = NULL; | |
47e5243a | 84 | |
91f23593 | 85 | kunmap_atomic((void *)addr); |
1da177e4 | 86 | |
8ca842c4 | 87 | return n; |
1da177e4 LT |
88 | } |
89 | ||
8efa3c9d JD |
90 | static int buffer_op(unsigned long addr, int len, int is_write, |
91 | int (*op)(unsigned long, int, void *), void *arg) | |
1da177e4 | 92 | { |
8efa3c9d JD |
93 | int size, remain, n; |
94 | ||
1da177e4 LT |
95 | size = min(PAGE_ALIGN(addr) - addr, (unsigned long) len); |
96 | remain = len; | |
97 | ||
47e5243a | 98 | n = do_op_one_page(addr, size, is_write, op, arg); |
8ca842c4 | 99 | if (n != 0) { |
8efa3c9d | 100 | remain = (n < 0 ? remain : 0); |
1da177e4 LT |
101 | goto out; |
102 | } | |
103 | ||
104 | addr += size; | |
105 | remain -= size; | |
8efa3c9d | 106 | if (remain == 0) |
1da177e4 | 107 | goto out; |
1da177e4 | 108 | |
8efa3c9d | 109 | while (addr < ((addr + remain) & PAGE_MASK)) { |
47e5243a | 110 | n = do_op_one_page(addr, PAGE_SIZE, is_write, op, arg); |
8ca842c4 | 111 | if (n != 0) { |
8efa3c9d | 112 | remain = (n < 0 ? remain : 0); |
1da177e4 LT |
113 | goto out; |
114 | } | |
115 | ||
116 | addr += PAGE_SIZE; | |
117 | remain -= PAGE_SIZE; | |
118 | } | |
8efa3c9d | 119 | if (remain == 0) |
1da177e4 | 120 | goto out; |
1da177e4 | 121 | |
47e5243a | 122 | n = do_op_one_page(addr, remain, is_write, op, arg); |
8efa3c9d JD |
123 | if (n != 0) { |
124 | remain = (n < 0 ? remain : 0); | |
125 | goto out; | |
126 | } | |
1da177e4 | 127 | |
8efa3c9d JD |
128 | return 0; |
129 | out: | |
130 | return remain; | |
1da177e4 LT |
131 | } |
132 | ||
133 | static int copy_chunk_from_user(unsigned long from, int len, void *arg) | |
134 | { | |
135 | unsigned long *to_ptr = arg, to = *to_ptr; | |
136 | ||
137 | memcpy((void *) to, (void *) from, len); | |
138 | *to_ptr += len; | |
8ca842c4 | 139 | return 0; |
1da177e4 LT |
140 | } |
141 | ||
6aa802ce | 142 | int copy_from_user(void *to, const void __user *from, int n) |
1da177e4 | 143 | { |
8ca842c4 | 144 | if (segment_eq(get_fs(), KERNEL_DS)) { |
1da177e4 | 145 | memcpy(to, (__force void*)from, n); |
8ca842c4 | 146 | return 0; |
1da177e4 LT |
147 | } |
148 | ||
8ca842c4 | 149 | return access_ok(VERIFY_READ, from, n) ? |
1da177e4 | 150 | buffer_op((unsigned long) from, n, 0, copy_chunk_from_user, &to): |
8ca842c4 | 151 | n; |
1da177e4 | 152 | } |
73395a00 | 153 | EXPORT_SYMBOL(copy_from_user); |
1da177e4 LT |
154 | |
155 | static int copy_chunk_to_user(unsigned long to, int len, void *arg) | |
156 | { | |
157 | unsigned long *from_ptr = arg, from = *from_ptr; | |
158 | ||
159 | memcpy((void *) to, (void *) from, len); | |
160 | *from_ptr += len; | |
8ca842c4 | 161 | return 0; |
1da177e4 LT |
162 | } |
163 | ||
6aa802ce | 164 | int copy_to_user(void __user *to, const void *from, int n) |
1da177e4 | 165 | { |
8ca842c4 JD |
166 | if (segment_eq(get_fs(), KERNEL_DS)) { |
167 | memcpy((__force void *) to, from, n); | |
168 | return 0; | |
1da177e4 LT |
169 | } |
170 | ||
8ca842c4 | 171 | return access_ok(VERIFY_WRITE, to, n) ? |
1da177e4 | 172 | buffer_op((unsigned long) to, n, 1, copy_chunk_to_user, &from) : |
8ca842c4 | 173 | n; |
1da177e4 | 174 | } |
73395a00 | 175 | EXPORT_SYMBOL(copy_to_user); |
1da177e4 LT |
176 | |
177 | static int strncpy_chunk_from_user(unsigned long from, int len, void *arg) | |
178 | { | |
179 | char **to_ptr = arg, *to = *to_ptr; | |
180 | int n; | |
181 | ||
182 | strncpy(to, (void *) from, len); | |
183 | n = strnlen(to, len); | |
184 | *to_ptr += n; | |
185 | ||
8ca842c4 JD |
186 | if (n < len) |
187 | return 1; | |
188 | return 0; | |
1da177e4 LT |
189 | } |
190 | ||
6aa802ce | 191 | int strncpy_from_user(char *dst, const char __user *src, int count) |
1da177e4 LT |
192 | { |
193 | int n; | |
194 | char *ptr = dst; | |
195 | ||
8ca842c4 JD |
196 | if (segment_eq(get_fs(), KERNEL_DS)) { |
197 | strncpy(dst, (__force void *) src, count); | |
198 | return strnlen(dst, count); | |
1da177e4 LT |
199 | } |
200 | ||
8ca842c4 JD |
201 | if (!access_ok(VERIFY_READ, src, 1)) |
202 | return -EFAULT; | |
1da177e4 LT |
203 | |
204 | n = buffer_op((unsigned long) src, count, 0, strncpy_chunk_from_user, | |
205 | &ptr); | |
8ca842c4 JD |
206 | if (n != 0) |
207 | return -EFAULT; | |
208 | return strnlen(dst, count); | |
1da177e4 | 209 | } |
73395a00 | 210 | EXPORT_SYMBOL(strncpy_from_user); |
1da177e4 LT |
211 | |
212 | static int clear_chunk(unsigned long addr, int len, void *unused) | |
213 | { | |
214 | memset((void *) addr, 0, len); | |
8ca842c4 | 215 | return 0; |
1da177e4 LT |
216 | } |
217 | ||
6aa802ce | 218 | int __clear_user(void __user *mem, int len) |
1da177e4 | 219 | { |
8ca842c4 | 220 | return buffer_op((unsigned long) mem, len, 1, clear_chunk, NULL); |
1da177e4 LT |
221 | } |
222 | ||
6aa802ce | 223 | int clear_user(void __user *mem, int len) |
1da177e4 | 224 | { |
8ca842c4 | 225 | if (segment_eq(get_fs(), KERNEL_DS)) { |
1da177e4 | 226 | memset((__force void*)mem, 0, len); |
8ca842c4 | 227 | return 0; |
1da177e4 LT |
228 | } |
229 | ||
8ca842c4 JD |
230 | return access_ok(VERIFY_WRITE, mem, len) ? |
231 | buffer_op((unsigned long) mem, len, 1, clear_chunk, NULL) : len; | |
1da177e4 | 232 | } |
73395a00 | 233 | EXPORT_SYMBOL(clear_user); |
1da177e4 LT |
234 | |
235 | static int strnlen_chunk(unsigned long str, int len, void *arg) | |
236 | { | |
237 | int *len_ptr = arg, n; | |
238 | ||
239 | n = strnlen((void *) str, len); | |
240 | *len_ptr += n; | |
241 | ||
8ca842c4 JD |
242 | if (n < len) |
243 | return 1; | |
244 | return 0; | |
1da177e4 LT |
245 | } |
246 | ||
6aa802ce | 247 | int strnlen_user(const void __user *str, int len) |
1da177e4 LT |
248 | { |
249 | int count = 0, n; | |
250 | ||
8ca842c4 JD |
251 | if (segment_eq(get_fs(), KERNEL_DS)) |
252 | return strnlen((__force char*)str, len) + 1; | |
1da177e4 LT |
253 | |
254 | n = buffer_op((unsigned long) str, len, 0, strnlen_chunk, &count); | |
8ca842c4 JD |
255 | if (n == 0) |
256 | return count + 1; | |
3179ce72 | 257 | return 0; |
1da177e4 | 258 | } |
73395a00 | 259 | EXPORT_SYMBOL(strnlen_user); |