blob: e6a99d2793b36d567e28e060613bf39a9497f3bd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/ptrace.c
3 *
4 * (C) Copyright 1999 Linus Torvalds
5 *
6 * Common interfaces for "ptrace()" which we do not want
7 * to continually duplicate across every architecture.
8 */
9
Randy.Dunlapc59ede72006-01-11 12:17:46 -080010#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/module.h>
12#include <linux/sched.h>
13#include <linux/errno.h>
14#include <linux/mm.h>
15#include <linux/highmem.h>
16#include <linux/pagemap.h>
17#include <linux/smp_lock.h>
18#include <linux/ptrace.h>
19#include <linux/security.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070020#include <linux/signal.h>
Al Viroa5cb0132007-03-20 13:58:35 -040021#include <linux/audit.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -070022#include <linux/pid_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24#include <asm/pgtable.h>
25#include <asm/uaccess.h>
26
27/*
28 * ptrace a task: make the debugger its new parent and
29 * move it to the ptrace list.
30 *
31 * Must be called with the tasklist lock write-held.
32 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070033void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034{
Eric Sesterhenn524223c2006-04-02 13:43:40 +020035 BUG_ON(!list_empty(&child->ptrace_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 if (child->parent == new_parent)
37 return;
38 list_add(&child->ptrace_list, &child->parent->ptrace_children);
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080039 remove_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 child->parent = new_parent;
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080041 add_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042}
43
44/*
45 * Turn a tracing stop into a normal stop now, since with no tracer there
46 * would be no way to wake it up with SIGCONT or SIGKILL. If there was a
47 * signal sent that would resume the child, but didn't because it was in
48 * TASK_TRACED, resume it now.
49 * Requires that irqs be disabled.
50 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070051void ptrace_untrace(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052{
53 spin_lock(&child->sighand->siglock);
54 if (child->state == TASK_TRACED) {
55 if (child->signal->flags & SIGNAL_STOP_STOPPED) {
56 child->state = TASK_STOPPED;
57 } else {
58 signal_wake_up(child, 1);
59 }
60 }
61 spin_unlock(&child->sighand->siglock);
62}
63
64/*
65 * unptrace a task: move it back to its original parent and
66 * remove it from the ptrace list.
67 *
68 * Must be called with the tasklist lock write-held.
69 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070070void __ptrace_unlink(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +030072 BUG_ON(!child->ptrace);
73
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 child->ptrace = 0;
75 if (!list_empty(&child->ptrace_list)) {
76 list_del_init(&child->ptrace_list);
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080077 remove_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 child->parent = child->real_parent;
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080079 add_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 }
81
Roland McGrathe57a5052006-04-12 16:30:20 -070082 if (child->state == TASK_TRACED)
83 ptrace_untrace(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084}
85
86/*
87 * Check that we have indeed attached to the thing..
88 */
89int ptrace_check_attach(struct task_struct *child, int kill)
90{
91 int ret = -ESRCH;
92
93 /*
94 * We take the read lock around doing both checks to close a
95 * possible race where someone else was tracing our child and
96 * detached between these two checks. After this locked check,
97 * we are sure that this is our traced child and that can only
98 * be changed by us so it's not changing right after this.
99 */
100 read_lock(&tasklist_lock);
101 if ((child->ptrace & PT_PTRACED) && child->parent == current &&
102 (!(child->ptrace & PT_ATTACHED) || child->real_parent != current)
103 && child->signal != NULL) {
104 ret = 0;
105 spin_lock_irq(&child->sighand->siglock);
106 if (child->state == TASK_STOPPED) {
107 child->state = TASK_TRACED;
108 } else if (child->state != TASK_TRACED && !kill) {
109 ret = -ESRCH;
110 }
111 spin_unlock_irq(&child->sighand->siglock);
112 }
113 read_unlock(&tasklist_lock);
114
115 if (!ret && !kill) {
116 wait_task_inactive(child);
117 }
118
119 /* All systems go.. */
120 return ret;
121}
122
Al Viro831830b2008-01-02 14:09:57 +0000123int __ptrace_may_attach(struct task_struct *task)
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700124{
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700125 /* May we inspect the given task?
126 * This check is used both for attaching with ptrace
127 * and for allowing access to sensitive information in /proc.
128 *
129 * ptrace_attach denies several cases that /proc allows
130 * because setting up the necessary parent/child relationship
131 * or halting the specified task is impossible.
132 */
133 int dumpable = 0;
134 /* Don't let security modules deny introspection */
135 if (task == current)
136 return 0;
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700137 if (((current->uid != task->euid) ||
138 (current->uid != task->suid) ||
139 (current->uid != task->uid) ||
140 (current->gid != task->egid) ||
141 (current->gid != task->sgid) ||
142 (current->gid != task->gid)) && !capable(CAP_SYS_PTRACE))
143 return -EPERM;
144 smp_rmb();
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700145 if (task->mm)
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700146 dumpable = get_dumpable(task->mm);
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700147 if (!dumpable && !capable(CAP_SYS_PTRACE))
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700148 return -EPERM;
149
150 return security_ptrace(current, task);
151}
152
153int ptrace_may_attach(struct task_struct *task)
154{
155 int err;
156 task_lock(task);
Al Viro831830b2008-01-02 14:09:57 +0000157 err = __ptrace_may_attach(task);
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700158 task_unlock(task);
159 return !err;
160}
161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162int ptrace_attach(struct task_struct *task)
163{
164 int retval;
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700165 unsigned long flags;
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700166
Al Viroa5cb0132007-03-20 13:58:35 -0400167 audit_ptrace(task);
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 retval = -EPERM;
170 if (task->pid <= 1)
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700171 goto out;
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -0700172 if (same_thread_group(task, current))
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700173 goto out;
174
Linus Torvaldsf3581662006-05-11 11:08:49 -0700175repeat:
176 /*
177 * Nasty, nasty.
178 *
179 * We want to hold both the task-lock and the
180 * tasklist_lock for writing at the same time.
181 * But that's against the rules (tasklist_lock
182 * is taken for reading by interrupts on other
183 * cpu's that may have task_lock).
184 */
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700185 task_lock(task);
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700186 if (!write_trylock_irqsave(&tasklist_lock, flags)) {
Linus Torvaldsf3581662006-05-11 11:08:49 -0700187 task_unlock(task);
188 do {
189 cpu_relax();
190 } while (!write_can_lock(&tasklist_lock));
191 goto repeat;
192 }
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700193
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700194 if (!task->mm)
195 goto bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 /* the same process cannot be attached many times */
197 if (task->ptrace & PT_PTRACED)
198 goto bad;
Linus Torvaldsb8c9a182008-01-02 13:48:27 -0800199 retval = __ptrace_may_attach(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 if (retval)
201 goto bad;
202
203 /* Go */
204 task->ptrace |= PT_PTRACED | ((task->real_parent != current)
205 ? PT_ATTACHED : 0);
206 if (capable(CAP_SYS_PTRACE))
207 task->ptrace |= PT_PTRACE_CAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 __ptrace_link(task, current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 force_sig_specific(SIGSTOP, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
213bad:
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700214 write_unlock_irqrestore(&tasklist_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 task_unlock(task);
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700216out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return retval;
218}
219
Oleg Nesterovd5f70c02006-06-26 00:26:07 -0700220static inline void __ptrace_detach(struct task_struct *child, unsigned int data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 child->exit_code = data;
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300223 /* .. re-parent .. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 __ptrace_unlink(child);
225 /* .. and wake it up. */
226 if (child->exit_state != EXIT_ZOMBIE)
227 wake_up_process(child);
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300228}
229
230int ptrace_detach(struct task_struct *child, unsigned int data)
231{
232 if (!valid_signal(data))
233 return -EIO;
234
235 /* Architecture-specific hardware disable .. */
236 ptrace_disable(child);
Roland McGrath7d941432007-09-05 03:05:56 -0700237 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300238
239 write_lock_irq(&tasklist_lock);
Oleg Nesterovd5f70c02006-06-26 00:26:07 -0700240 /* protect against de_thread()->release_task() */
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300241 if (child->ptrace)
242 __ptrace_detach(child, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 write_unlock_irq(&tasklist_lock);
244
245 return 0;
246}
247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
249{
250 int copied = 0;
251
252 while (len > 0) {
253 char buf[128];
254 int this_len, retval;
255
256 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
257 retval = access_process_vm(tsk, src, buf, this_len, 0);
258 if (!retval) {
259 if (copied)
260 break;
261 return -EIO;
262 }
263 if (copy_to_user(dst, buf, retval))
264 return -EFAULT;
265 copied += retval;
266 src += retval;
267 dst += retval;
268 len -= retval;
269 }
270 return copied;
271}
272
273int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
274{
275 int copied = 0;
276
277 while (len > 0) {
278 char buf[128];
279 int this_len, retval;
280
281 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
282 if (copy_from_user(buf, src, this_len))
283 return -EFAULT;
284 retval = access_process_vm(tsk, dst, buf, this_len, 1);
285 if (!retval) {
286 if (copied)
287 break;
288 return -EIO;
289 }
290 copied += retval;
291 src += retval;
292 dst += retval;
293 len -= retval;
294 }
295 return copied;
296}
297
298static int ptrace_setoptions(struct task_struct *child, long data)
299{
300 child->ptrace &= ~PT_TRACE_MASK;
301
302 if (data & PTRACE_O_TRACESYSGOOD)
303 child->ptrace |= PT_TRACESYSGOOD;
304
305 if (data & PTRACE_O_TRACEFORK)
306 child->ptrace |= PT_TRACE_FORK;
307
308 if (data & PTRACE_O_TRACEVFORK)
309 child->ptrace |= PT_TRACE_VFORK;
310
311 if (data & PTRACE_O_TRACECLONE)
312 child->ptrace |= PT_TRACE_CLONE;
313
314 if (data & PTRACE_O_TRACEEXEC)
315 child->ptrace |= PT_TRACE_EXEC;
316
317 if (data & PTRACE_O_TRACEVFORKDONE)
318 child->ptrace |= PT_TRACE_VFORK_DONE;
319
320 if (data & PTRACE_O_TRACEEXIT)
321 child->ptrace |= PT_TRACE_EXIT;
322
323 return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
324}
325
326static int ptrace_getsiginfo(struct task_struct *child, siginfo_t __user * data)
327{
328 siginfo_t lastinfo;
329 int error = -ESRCH;
330
331 read_lock(&tasklist_lock);
332 if (likely(child->sighand != NULL)) {
333 error = -EINVAL;
334 spin_lock_irq(&child->sighand->siglock);
335 if (likely(child->last_siginfo != NULL)) {
336 lastinfo = *child->last_siginfo;
337 error = 0;
338 }
339 spin_unlock_irq(&child->sighand->siglock);
340 }
341 read_unlock(&tasklist_lock);
342 if (!error)
343 return copy_siginfo_to_user(data, &lastinfo);
344 return error;
345}
346
347static int ptrace_setsiginfo(struct task_struct *child, siginfo_t __user * data)
348{
349 siginfo_t newinfo;
350 int error = -ESRCH;
351
352 if (copy_from_user(&newinfo, data, sizeof (siginfo_t)))
353 return -EFAULT;
354
355 read_lock(&tasklist_lock);
356 if (likely(child->sighand != NULL)) {
357 error = -EINVAL;
358 spin_lock_irq(&child->sighand->siglock);
359 if (likely(child->last_siginfo != NULL)) {
360 *child->last_siginfo = newinfo;
361 error = 0;
362 }
363 spin_unlock_irq(&child->sighand->siglock);
364 }
365 read_unlock(&tasklist_lock);
366 return error;
367}
368
Roland McGrath36df29d2008-01-30 13:30:51 +0100369
370#ifdef PTRACE_SINGLESTEP
371#define is_singlestep(request) ((request) == PTRACE_SINGLESTEP)
372#else
373#define is_singlestep(request) 0
374#endif
375
Roland McGrath5b88abb2008-01-30 13:30:53 +0100376#ifdef PTRACE_SINGLEBLOCK
377#define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK)
378#else
379#define is_singleblock(request) 0
380#endif
381
Roland McGrath36df29d2008-01-30 13:30:51 +0100382#ifdef PTRACE_SYSEMU
383#define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP)
384#else
385#define is_sysemu_singlestep(request) 0
386#endif
387
388static int ptrace_resume(struct task_struct *child, long request, long data)
389{
390 if (!valid_signal(data))
391 return -EIO;
392
393 if (request == PTRACE_SYSCALL)
394 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
395 else
396 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
397
398#ifdef TIF_SYSCALL_EMU
399 if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
400 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
401 else
402 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
403#endif
404
Roland McGrath5b88abb2008-01-30 13:30:53 +0100405 if (is_singleblock(request)) {
406 if (unlikely(!arch_has_block_step()))
407 return -EIO;
408 user_enable_block_step(child);
409 } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
Roland McGrath36df29d2008-01-30 13:30:51 +0100410 if (unlikely(!arch_has_single_step()))
411 return -EIO;
412 user_enable_single_step(child);
413 }
414 else
415 user_disable_single_step(child);
416
417 child->exit_code = data;
418 wake_up_process(child);
419
420 return 0;
421}
422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423int ptrace_request(struct task_struct *child, long request,
424 long addr, long data)
425{
426 int ret = -EIO;
427
428 switch (request) {
Roland McGrath16c3e382008-01-30 13:31:47 +0100429 case PTRACE_PEEKTEXT:
430 case PTRACE_PEEKDATA:
431 return generic_ptrace_peekdata(child, addr, data);
432 case PTRACE_POKETEXT:
433 case PTRACE_POKEDATA:
434 return generic_ptrace_pokedata(child, addr, data);
435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436#ifdef PTRACE_OLDSETOPTIONS
437 case PTRACE_OLDSETOPTIONS:
438#endif
439 case PTRACE_SETOPTIONS:
440 ret = ptrace_setoptions(child, data);
441 break;
442 case PTRACE_GETEVENTMSG:
443 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
444 break;
445 case PTRACE_GETSIGINFO:
446 ret = ptrace_getsiginfo(child, (siginfo_t __user *) data);
447 break;
448 case PTRACE_SETSIGINFO:
449 ret = ptrace_setsiginfo(child, (siginfo_t __user *) data);
450 break;
Alexey Dobriyan1bcf5482007-10-16 01:23:45 -0700451 case PTRACE_DETACH: /* detach a process that was attached. */
452 ret = ptrace_detach(child, data);
453 break;
Roland McGrath36df29d2008-01-30 13:30:51 +0100454
455#ifdef PTRACE_SINGLESTEP
456 case PTRACE_SINGLESTEP:
457#endif
Roland McGrath5b88abb2008-01-30 13:30:53 +0100458#ifdef PTRACE_SINGLEBLOCK
459 case PTRACE_SINGLEBLOCK:
460#endif
Roland McGrath36df29d2008-01-30 13:30:51 +0100461#ifdef PTRACE_SYSEMU
462 case PTRACE_SYSEMU:
463 case PTRACE_SYSEMU_SINGLESTEP:
464#endif
465 case PTRACE_SYSCALL:
466 case PTRACE_CONT:
467 return ptrace_resume(child, request, data);
468
469 case PTRACE_KILL:
470 if (child->exit_state) /* already dead */
471 return 0;
472 return ptrace_resume(child, request, SIGKILL);
473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 default:
475 break;
476 }
477
478 return ret;
479}
Christoph Hellwig481bed42005-11-07 00:59:47 -0800480
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800481/**
482 * ptrace_traceme -- helper for PTRACE_TRACEME
483 *
484 * Performs checks and sets PT_PTRACED.
485 * Should be used by all ptrace implementations for PTRACE_TRACEME.
486 */
487int ptrace_traceme(void)
Christoph Hellwig481bed42005-11-07 00:59:47 -0800488{
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700489 int ret = -EPERM;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800490
491 /*
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800492 * Are we already being traced?
Christoph Hellwig481bed42005-11-07 00:59:47 -0800493 */
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700494 task_lock(current);
495 if (!(current->ptrace & PT_PTRACED)) {
496 ret = security_ptrace(current->parent, current);
497 /*
498 * Set the ptrace bit in the process ptrace flags.
499 */
500 if (!ret)
501 current->ptrace |= PT_PTRACED;
502 }
503 task_unlock(current);
504 return ret;
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800505}
Christoph Hellwig481bed42005-11-07 00:59:47 -0800506
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800507/**
508 * ptrace_get_task_struct -- grab a task struct reference for ptrace
509 * @pid: process id to grab a task_struct reference of
510 *
511 * This function is a helper for ptrace implementations. It checks
512 * permissions and then grabs a task struct for use of the actual
513 * ptrace implementation.
514 *
515 * Returns the task_struct for @pid or an ERR_PTR() on failure.
516 */
517struct task_struct *ptrace_get_task_struct(pid_t pid)
518{
519 struct task_struct *child;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800520
521 /*
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800522 * Tracing init is not allowed.
Christoph Hellwig481bed42005-11-07 00:59:47 -0800523 */
524 if (pid == 1)
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800525 return ERR_PTR(-EPERM);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800526
Christoph Hellwig481bed42005-11-07 00:59:47 -0800527 read_lock(&tasklist_lock);
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -0700528 child = find_task_by_vpid(pid);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800529 if (child)
530 get_task_struct(child);
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -0700531
Christoph Hellwig481bed42005-11-07 00:59:47 -0800532 read_unlock(&tasklist_lock);
533 if (!child)
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800534 return ERR_PTR(-ESRCH);
535 return child;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800536}
537
Christoph Hellwig0ac15552007-10-16 01:26:37 -0700538#ifndef arch_ptrace_attach
539#define arch_ptrace_attach(child) do { } while (0)
540#endif
541
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800542#ifndef __ARCH_SYS_PTRACE
Christoph Hellwig481bed42005-11-07 00:59:47 -0800543asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
544{
545 struct task_struct *child;
546 long ret;
547
548 /*
549 * This lock_kernel fixes a subtle race with suid exec
550 */
551 lock_kernel();
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800552 if (request == PTRACE_TRACEME) {
553 ret = ptrace_traceme();
Haavard Skinnemoen6ea6dd92007-11-27 13:02:40 +0100554 if (!ret)
555 arch_ptrace_attach(current);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800556 goto out;
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800557 }
558
559 child = ptrace_get_task_struct(pid);
560 if (IS_ERR(child)) {
561 ret = PTR_ERR(child);
562 goto out;
563 }
Christoph Hellwig481bed42005-11-07 00:59:47 -0800564
565 if (request == PTRACE_ATTACH) {
566 ret = ptrace_attach(child);
Christoph Hellwig0ac15552007-10-16 01:26:37 -0700567 /*
568 * Some architectures need to do book-keeping after
569 * a ptrace attach.
570 */
571 if (!ret)
572 arch_ptrace_attach(child);
Christoph Hellwig005f18d2005-11-13 16:06:33 -0800573 goto out_put_task_struct;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800574 }
575
576 ret = ptrace_check_attach(child, request == PTRACE_KILL);
577 if (ret < 0)
578 goto out_put_task_struct;
579
580 ret = arch_ptrace(child, request, addr, data);
581 if (ret < 0)
582 goto out_put_task_struct;
583
584 out_put_task_struct:
585 put_task_struct(child);
586 out:
587 unlock_kernel();
588 return ret;
589}
590#endif /* __ARCH_SYS_PTRACE */
Alexey Dobriyan76647322007-07-17 04:03:43 -0700591
592int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
593{
594 unsigned long tmp;
595 int copied;
596
597 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
598 if (copied != sizeof(tmp))
599 return -EIO;
600 return put_user(tmp, (unsigned long __user *)data);
601}
Alexey Dobriyanf284ce72007-07-17 04:03:44 -0700602
603int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
604{
605 int copied;
606
607 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
608 return (copied == sizeof(data)) ? 0 : -EIO;
609}