Branch data Line data Source code
1 : : /*
2 : : * linux/mm/process_vm_access.c
3 : : *
4 : : * Copyright (C) 2010-2011 Christopher Yeoh <cyeoh@au1.ibm.com>, IBM Corp.
5 : : *
6 : : * This program is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU General Public License
8 : : * as published by the Free Software Foundation; either version
9 : : * 2 of the License, or (at your option) any later version.
10 : : */
11 : :
12 : : #include <linux/mm.h>
13 : : #include <linux/uio.h>
14 : : #include <linux/sched.h>
15 : : #include <linux/highmem.h>
16 : : #include <linux/ptrace.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/syscalls.h>
19 : :
20 : : #ifdef CONFIG_COMPAT
21 : : #include <linux/compat.h>
22 : : #endif
23 : :
24 : : /**
25 : : * process_vm_rw_pages - read/write pages from task specified
26 : : * @task: task to read/write from
27 : : * @mm: mm for task
28 : : * @process_pages: struct pages area that can store at least
29 : : * nr_pages_to_copy struct page pointers
30 : : * @pa: address of page in task to start copying from/to
31 : : * @start_offset: offset in page to start copying from/to
32 : : * @len: number of bytes to copy
33 : : * @lvec: iovec array specifying where to copy to/from
34 : : * @lvec_cnt: number of elements in iovec array
35 : : * @lvec_current: index in iovec array we are up to
36 : : * @lvec_offset: offset in bytes from current iovec iov_base we are up to
37 : : * @vm_write: 0 means copy from, 1 means copy to
38 : : * @nr_pages_to_copy: number of pages to copy
39 : : * @bytes_copied: returns number of bytes successfully copied
40 : : * Returns 0 on success, error code otherwise
41 : : */
42 : 0 : static int process_vm_rw_pages(struct task_struct *task,
43 : : struct mm_struct *mm,
44 : : struct page **process_pages,
45 : : unsigned long pa,
46 : : unsigned long start_offset,
47 : : unsigned long len,
48 : : const struct iovec *lvec,
49 : : unsigned long lvec_cnt,
50 : : unsigned long *lvec_current,
51 : : size_t *lvec_offset,
52 : : int vm_write,
53 : : unsigned int nr_pages_to_copy,
54 : : ssize_t *bytes_copied)
55 : : {
56 : : int pages_pinned;
57 : : void *target_kaddr;
58 : : int pgs_copied = 0;
59 : : int j;
60 : : int ret;
61 : : ssize_t bytes_to_copy;
62 : : ssize_t rc = 0;
63 : :
64 : 21 : *bytes_copied = 0;
65 : :
66 : : /* Get the pages we're interested in */
67 : 21 : down_read(&mm->mmap_sem);
68 : 21 : pages_pinned = get_user_pages(task, mm, pa,
69 : : nr_pages_to_copy,
70 : : vm_write, 0, process_pages, NULL);
71 : 21 : up_read(&mm->mmap_sem);
72 : :
73 [ + + ]: 42 : if (pages_pinned != nr_pages_to_copy) {
74 : : rc = -EFAULT;
75 : : goto end;
76 : : }
77 : :
78 : : /* Do the copy for each page */
79 [ + + ]: 91 : for (pgs_copied = 0;
80 [ + + ]: 82 : (pgs_copied < nr_pages_to_copy) && (*lvec_current < lvec_cnt);
81 : 72 : pgs_copied++) {
82 : : /* Make sure we have a non zero length iovec */
83 [ + - ]: 74 : while (*lvec_current < lvec_cnt
84 [ - + ]: 74 : && lvec[*lvec_current].iov_len == 0)
85 : 0 : (*lvec_current)++;
86 [ + - ]: 74 : if (*lvec_current == lvec_cnt)
87 : : break;
88 : :
89 : : /*
90 : : * Will copy smallest of:
91 : : * - bytes remaining in page
92 : : * - bytes remaining in destination iovec
93 : : */
94 : 74 : bytes_to_copy = min_t(ssize_t, PAGE_SIZE - start_offset,
95 : : len - *bytes_copied);
96 : 74 : bytes_to_copy = min_t(ssize_t, bytes_to_copy,
97 : : lvec[*lvec_current].iov_len
98 : : - *lvec_offset);
99 : :
100 : 74 : target_kaddr = kmap(process_pages[pgs_copied]) + start_offset;
101 : :
102 [ + + ]: 74 : if (vm_write)
103 : 30 : ret = copy_from_user(target_kaddr,
104 : 30 : lvec[*lvec_current].iov_base
105 : : + *lvec_offset,
106 : : bytes_to_copy);
107 : : else
108 : 44 : ret = copy_to_user(lvec[*lvec_current].iov_base
109 : : + *lvec_offset,
110 : : target_kaddr, bytes_to_copy);
111 : 74 : kunmap(process_pages[pgs_copied]);
112 [ + + ]: 74 : if (ret) {
113 : 2 : *bytes_copied += bytes_to_copy - ret;
114 : 2 : pgs_copied++;
115 : : rc = -EFAULT;
116 : 2 : goto end;
117 : : }
118 : 72 : *bytes_copied += bytes_to_copy;
119 : 72 : *lvec_offset += bytes_to_copy;
120 [ + + ]: 72 : if (*lvec_offset == lvec[*lvec_current].iov_len) {
121 : : /*
122 : : * Need to copy remaining part of page into the
123 : : * next iovec if there are any bytes left in page
124 : : */
125 : 11 : (*lvec_current)++;
126 : 11 : *lvec_offset = 0;
127 : 11 : start_offset = (start_offset + bytes_to_copy)
128 : : % PAGE_SIZE;
129 [ + - ]: 11 : if (start_offset)
130 : 11 : pgs_copied--;
131 : : } else {
132 : : start_offset = 0;
133 : : }
134 : : }
135 : :
136 : : end:
137 [ + + ]: 21 : if (vm_write) {
138 [ + + ]: 36 : for (j = 0; j < pages_pinned; j++) {
139 [ + + ]: 31 : if (j < pgs_copied)
140 : 27 : set_page_dirty_lock(process_pages[j]);
141 : 31 : put_page(process_pages[j]);
142 : : }
143 : : } else {
144 [ + + ]: 58 : for (j = 0; j < pages_pinned; j++)
145 : 42 : put_page(process_pages[j]);
146 : : }
147 : :
148 : 21 : return rc;
149 : : }
150 : :
151 : : /* Maximum number of pages kmalloc'd to hold struct page's during copy */
152 : : #define PVM_MAX_KMALLOC_PAGES (PAGE_SIZE * 2)
153 : :
154 : : /**
155 : : * process_vm_rw_single_vec - read/write pages from task specified
156 : : * @addr: start memory address of target process
157 : : * @len: size of area to copy to/from
158 : : * @lvec: iovec array specifying where to copy to/from locally
159 : : * @lvec_cnt: number of elements in iovec array
160 : : * @lvec_current: index in iovec array we are up to
161 : : * @lvec_offset: offset in bytes from current iovec iov_base we are up to
162 : : * @process_pages: struct pages area that can store at least
163 : : * nr_pages_to_copy struct page pointers
164 : : * @mm: mm for task
165 : : * @task: task to read/write from
166 : : * @vm_write: 0 means copy from, 1 means copy to
167 : : * @bytes_copied: returns number of bytes successfully copied
168 : : * Returns 0 on success or on failure error code
169 : : */
170 : 0 : static int process_vm_rw_single_vec(unsigned long addr,
171 : : unsigned long len,
172 : : const struct iovec *lvec,
173 : : unsigned long lvec_cnt,
174 : : unsigned long *lvec_current,
175 : : size_t *lvec_offset,
176 : : struct page **process_pages,
177 : : struct mm_struct *mm,
178 : : struct task_struct *task,
179 : : int vm_write,
180 : : ssize_t *bytes_copied)
181 : : {
182 : 21 : unsigned long pa = addr & PAGE_MASK;
183 : 21 : unsigned long start_offset = addr - pa;
184 : : unsigned long nr_pages;
185 : : ssize_t bytes_copied_loop;
186 : : ssize_t rc = 0;
187 : : unsigned long nr_pages_copied = 0;
188 : : unsigned long nr_pages_to_copy;
189 : : unsigned long max_pages_per_loop = PVM_MAX_KMALLOC_PAGES
190 : : / sizeof(struct pages *);
191 : :
192 : 21 : *bytes_copied = 0;
193 : :
194 : : /* Work out address and page range required */
195 [ + - ]: 21 : if (len == 0)
196 : : return 0;
197 : 21 : nr_pages = (addr + len - 1) / PAGE_SIZE - addr / PAGE_SIZE + 1;
198 : :
199 [ + + ][ + - ]: 38 : while ((nr_pages_copied < nr_pages) && (*lvec_current < lvec_cnt)) {
200 : 21 : nr_pages_to_copy = min(nr_pages - nr_pages_copied,
201 : : max_pages_per_loop);
202 : :
203 : 21 : rc = process_vm_rw_pages(task, mm, process_pages, pa,
204 : : start_offset, len,
205 : : lvec, lvec_cnt,
206 : : lvec_current, lvec_offset,
207 : : vm_write, nr_pages_to_copy,
208 : : &bytes_copied_loop);
209 : : start_offset = 0;
210 : 21 : *bytes_copied += bytes_copied_loop;
211 : :
212 [ + + ]: 21 : if (rc < 0) {
213 : : return rc;
214 : : } else {
215 : 17 : len -= bytes_copied_loop;
216 : 17 : nr_pages_copied += nr_pages_to_copy;
217 : 17 : pa += nr_pages_to_copy * PAGE_SIZE;
218 : : }
219 : : }
220 : :
221 : : return rc;
222 : : }
223 : :
224 : : /* Maximum number of entries for process pages array
225 : : which lives on stack */
226 : : #define PVM_MAX_PP_ARRAY_COUNT 16
227 : :
228 : : /**
229 : : * process_vm_rw_core - core of reading/writing pages from task specified
230 : : * @pid: PID of process to read/write from/to
231 : : * @lvec: iovec array specifying where to copy to/from locally
232 : : * @liovcnt: size of lvec array
233 : : * @rvec: iovec array specifying where to copy to/from in the other process
234 : : * @riovcnt: size of rvec array
235 : : * @flags: currently unused
236 : : * @vm_write: 0 if reading from other process, 1 if writing to other process
237 : : * Returns the number of bytes read/written or error code. May
238 : : * return less bytes than expected if an error occurs during the copying
239 : : * process.
240 : : */
241 : 0 : static ssize_t process_vm_rw_core(pid_t pid, const struct iovec *lvec,
242 : : unsigned long liovcnt,
243 : : const struct iovec *rvec,
244 : : unsigned long riovcnt,
245 : : unsigned long flags, int vm_write)
246 : : {
247 : : struct task_struct *task;
248 : : struct page *pp_stack[PVM_MAX_PP_ARRAY_COUNT];
249 : : struct page **process_pages = pp_stack;
250 : : struct mm_struct *mm;
251 : : unsigned long i;
252 : : ssize_t rc = 0;
253 : : ssize_t bytes_copied_loop;
254 : : ssize_t bytes_copied = 0;
255 : : unsigned long nr_pages = 0;
256 : : unsigned long nr_pages_iov;
257 : 18 : unsigned long iov_l_curr_idx = 0;
258 : 18 : size_t iov_l_curr_offset = 0;
259 : : ssize_t iov_len;
260 : :
261 : : /*
262 : : * Work out how many pages of struct pages we're going to need
263 : : * when eventually calling get_user_pages
264 : : */
265 [ + + ]: 45 : for (i = 0; i < riovcnt; i++) {
266 : 27 : iov_len = rvec[i].iov_len;
267 [ + - ]: 27 : if (iov_len > 0) {
268 : 54 : nr_pages_iov = ((unsigned long)rvec[i].iov_base
269 : 27 : + iov_len)
270 : 54 : / PAGE_SIZE - (unsigned long)rvec[i].iov_base
271 : 27 : / PAGE_SIZE + 1;
272 : 27 : nr_pages = max(nr_pages, nr_pages_iov);
273 : : }
274 : : }
275 : :
276 [ + - ]: 18 : if (nr_pages == 0)
277 : : return 0;
278 : :
279 [ + + ]: 18 : if (nr_pages > PVM_MAX_PP_ARRAY_COUNT) {
280 : : /* For reliability don't try to kmalloc more than
281 : : 2 pages worth */
282 : 1 : process_pages = kmalloc(min_t(size_t, PVM_MAX_KMALLOC_PAGES,
283 : : sizeof(struct pages *)*nr_pages),
284 : : GFP_KERNEL);
285 : :
286 [ + - ]: 1 : if (!process_pages)
287 : : return -ENOMEM;
288 : : }
289 : :
290 : : /* Get process information */
291 : : rcu_read_lock();
292 : 18 : task = find_task_by_vpid(pid);
293 [ + + ]: 18 : if (task)
294 : 14 : get_task_struct(task);
295 : : rcu_read_unlock();
296 [ + + ]: 18 : if (!task) {
297 : : rc = -ESRCH;
298 : : goto free_proc_pages;
299 : : }
300 : :
301 : 14 : mm = mm_access(task, PTRACE_MODE_ATTACH);
302 [ + - ][ + + ]: 14 : if (!mm || IS_ERR(mm)) {
303 [ + - ]: 2 : rc = IS_ERR(mm) ? PTR_ERR(mm) : -ESRCH;
304 : : /*
305 : : * Explicitly map EACCES to EPERM as EPERM is a more a
306 : : * appropriate error code for process_vw_readv/writev
307 : : */
308 [ + - ]: 2 : if (rc == -EACCES)
309 : : rc = -EPERM;
310 : : goto put_task_struct;
311 : : }
312 : :
313 [ + + ]: 29 : for (i = 0; i < riovcnt && iov_l_curr_idx < liovcnt; i++) {
314 : 21 : rc = process_vm_rw_single_vec(
315 : 42 : (unsigned long)rvec[i].iov_base, rvec[i].iov_len,
316 : : lvec, liovcnt, &iov_l_curr_idx, &iov_l_curr_offset,
317 : : process_pages, mm, task, vm_write, &bytes_copied_loop);
318 : 21 : bytes_copied += bytes_copied_loop;
319 [ + + ]: 21 : if (rc != 0) {
320 : : /* If we have managed to copy any data at all then
321 : : we return the number of bytes copied. Otherwise
322 : : we return the error code */
323 [ - + ]: 4 : if (bytes_copied)
324 : : rc = bytes_copied;
325 : : goto put_mm;
326 : : }
327 : : }
328 : :
329 : : rc = bytes_copied;
330 : : put_mm:
331 : 12 : mmput(mm);
332 : :
333 : : put_task_struct:
334 : : put_task_struct(task);
335 : :
336 : : free_proc_pages:
337 [ + + ]: 18 : if (process_pages != pp_stack)
338 : 18 : kfree(process_pages);
339 : : return rc;
340 : : }
341 : :
342 : : /**
343 : : * process_vm_rw - check iovecs before calling core routine
344 : : * @pid: PID of process to read/write from/to
345 : : * @lvec: iovec array specifying where to copy to/from locally
346 : : * @liovcnt: size of lvec array
347 : : * @rvec: iovec array specifying where to copy to/from in the other process
348 : : * @riovcnt: size of rvec array
349 : : * @flags: currently unused
350 : : * @vm_write: 0 if reading from other process, 1 if writing to other process
351 : : * Returns the number of bytes read/written or error code. May
352 : : * return less bytes than expected if an error occurs during the copying
353 : : * process.
354 : : */
355 : 0 : static ssize_t process_vm_rw(pid_t pid,
356 : : const struct iovec __user *lvec,
357 : : unsigned long liovcnt,
358 : : const struct iovec __user *rvec,
359 : : unsigned long riovcnt,
360 : : unsigned long flags, int vm_write)
361 : : {
362 : : struct iovec iovstack_l[UIO_FASTIOV];
363 : : struct iovec iovstack_r[UIO_FASTIOV];
364 : 36 : struct iovec *iov_l = iovstack_l;
365 : 36 : struct iovec *iov_r = iovstack_r;
366 : : ssize_t rc;
367 : :
368 [ + + ]: 36 : if (flags != 0)
369 : : return -EINVAL;
370 : :
371 : : /* Check iovecs */
372 [ + + ]: 28 : if (vm_write)
373 : 13 : rc = rw_copy_check_uvector(WRITE, lvec, liovcnt, UIO_FASTIOV,
374 : : iovstack_l, &iov_l);
375 : : else
376 : 15 : rc = rw_copy_check_uvector(READ, lvec, liovcnt, UIO_FASTIOV,
377 : : iovstack_l, &iov_l);
378 [ + + ]: 64 : if (rc <= 0)
379 : : goto free_iovecs;
380 : :
381 : 18 : rc = rw_copy_check_uvector(CHECK_IOVEC_ONLY, rvec, riovcnt, UIO_FASTIOV,
382 : : iovstack_r, &iov_r);
383 [ + - ]: 18 : if (rc <= 0)
384 : : goto free_iovecs;
385 : :
386 : 18 : rc = process_vm_rw_core(pid, iov_l, liovcnt, iov_r, riovcnt, flags,
387 : : vm_write);
388 : :
389 : : free_iovecs:
390 [ + + ]: 64 : if (iov_r != iovstack_r)
391 : 1 : kfree(iov_r);
392 [ - + ]: 28 : if (iov_l != iovstack_l)
393 : 0 : kfree(iov_l);
394 : :
395 : 28 : return rc;
396 : : }
397 : :
398 : 0 : SYSCALL_DEFINE6(process_vm_readv, pid_t, pid, const struct iovec __user *, lvec,
399 : : unsigned long, liovcnt, const struct iovec __user *, rvec,
400 : : unsigned long, riovcnt, unsigned long, flags)
401 : : {
402 : 19 : return process_vm_rw(pid, lvec, liovcnt, rvec, riovcnt, flags, 0);
403 : : }
404 : :
405 : 0 : SYSCALL_DEFINE6(process_vm_writev, pid_t, pid,
406 : : const struct iovec __user *, lvec,
407 : : unsigned long, liovcnt, const struct iovec __user *, rvec,
408 : : unsigned long, riovcnt, unsigned long, flags)
409 : : {
410 : 17 : return process_vm_rw(pid, lvec, liovcnt, rvec, riovcnt, flags, 1);
411 : : }
412 : :
413 : : #ifdef CONFIG_COMPAT
414 : :
415 : : asmlinkage ssize_t
416 : : compat_process_vm_rw(compat_pid_t pid,
417 : : const struct compat_iovec __user *lvec,
418 : : unsigned long liovcnt,
419 : : const struct compat_iovec __user *rvec,
420 : : unsigned long riovcnt,
421 : : unsigned long flags, int vm_write)
422 : : {
423 : : struct iovec iovstack_l[UIO_FASTIOV];
424 : : struct iovec iovstack_r[UIO_FASTIOV];
425 : : struct iovec *iov_l = iovstack_l;
426 : : struct iovec *iov_r = iovstack_r;
427 : : ssize_t rc = -EFAULT;
428 : :
429 : : if (flags != 0)
430 : : return -EINVAL;
431 : :
432 : : if (vm_write)
433 : : rc = compat_rw_copy_check_uvector(WRITE, lvec, liovcnt,
434 : : UIO_FASTIOV, iovstack_l,
435 : : &iov_l);
436 : : else
437 : : rc = compat_rw_copy_check_uvector(READ, lvec, liovcnt,
438 : : UIO_FASTIOV, iovstack_l,
439 : : &iov_l);
440 : : if (rc <= 0)
441 : : goto free_iovecs;
442 : : rc = compat_rw_copy_check_uvector(CHECK_IOVEC_ONLY, rvec, riovcnt,
443 : : UIO_FASTIOV, iovstack_r,
444 : : &iov_r);
445 : : if (rc <= 0)
446 : : goto free_iovecs;
447 : :
448 : : rc = process_vm_rw_core(pid, iov_l, liovcnt, iov_r, riovcnt, flags,
449 : : vm_write);
450 : :
451 : : free_iovecs:
452 : : if (iov_r != iovstack_r)
453 : : kfree(iov_r);
454 : : if (iov_l != iovstack_l)
455 : : kfree(iov_l);
456 : : return rc;
457 : : }
458 : :
459 : : asmlinkage ssize_t
460 : : compat_sys_process_vm_readv(compat_pid_t pid,
461 : : const struct compat_iovec __user *lvec,
462 : : unsigned long liovcnt,
463 : : const struct compat_iovec __user *rvec,
464 : : unsigned long riovcnt,
465 : : unsigned long flags)
466 : : {
467 : : return compat_process_vm_rw(pid, lvec, liovcnt, rvec,
468 : : riovcnt, flags, 0);
469 : : }
470 : :
471 : : asmlinkage ssize_t
472 : : compat_sys_process_vm_writev(compat_pid_t pid,
473 : : const struct compat_iovec __user *lvec,
474 : : unsigned long liovcnt,
475 : : const struct compat_iovec __user *rvec,
476 : : unsigned long riovcnt,
477 : : unsigned long flags)
478 : : {
479 : : return compat_process_vm_rw(pid, lvec, liovcnt, rvec,
480 : : riovcnt, flags, 1);
481 : : }
482 : :
483 : : #endif
|
