blob: fdb34e86f923f188113e7945e63c572c805c65a2 [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>
Adrian Bunkf17d30a2008-02-06 01:36:44 -080023#include <linux/syscalls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25#include <asm/pgtable.h>
26#include <asm/uaccess.h>
27
28/*
29 * ptrace a task: make the debugger its new parent and
30 * move it to the ptrace list.
31 *
32 * Must be called with the tasklist lock write-held.
33 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070034void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
Eric Sesterhenn524223c2006-04-02 13:43:40 +020036 BUG_ON(!list_empty(&child->ptrace_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 if (child->parent == new_parent)
38 return;
39 list_add(&child->ptrace_list, &child->parent->ptrace_children);
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080040 remove_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 child->parent = new_parent;
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080042 add_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043}
44
45/*
46 * Turn a tracing stop into a normal stop now, since with no tracer there
47 * would be no way to wake it up with SIGCONT or SIGKILL. If there was a
48 * signal sent that would resume the child, but didn't because it was in
49 * TASK_TRACED, resume it now.
50 * Requires that irqs be disabled.
51 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070052void ptrace_untrace(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053{
54 spin_lock(&child->sighand->siglock);
Matthew Wilcox6618a3e2007-12-06 11:06:16 -050055 if (task_is_traced(child)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 if (child->signal->flags & SIGNAL_STOP_STOPPED) {
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -080057 __set_task_state(child, TASK_STOPPED);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 } else {
59 signal_wake_up(child, 1);
60 }
61 }
62 spin_unlock(&child->sighand->siglock);
63}
64
65/*
66 * unptrace a task: move it back to its original parent and
67 * remove it from the ptrace list.
68 *
69 * Must be called with the tasklist lock write-held.
70 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070071void __ptrace_unlink(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +030073 BUG_ON(!child->ptrace);
74
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 child->ptrace = 0;
76 if (!list_empty(&child->ptrace_list)) {
77 list_del_init(&child->ptrace_list);
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080078 remove_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 child->parent = child->real_parent;
Oleg Nesterov9b678ec2006-03-28 16:11:05 -080080 add_parent(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 }
82
Matthew Wilcox6618a3e2007-12-06 11:06:16 -050083 if (task_is_traced(child))
Roland McGrathe57a5052006-04-12 16:30:20 -070084 ptrace_untrace(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085}
86
87/*
88 * Check that we have indeed attached to the thing..
89 */
90int ptrace_check_attach(struct task_struct *child, int kill)
91{
92 int ret = -ESRCH;
93
94 /*
95 * We take the read lock around doing both checks to close a
96 * possible race where someone else was tracing our child and
97 * detached between these two checks. After this locked check,
98 * we are sure that this is our traced child and that can only
99 * be changed by us so it's not changing right after this.
100 */
101 read_lock(&tasklist_lock);
Oleg Nesterovc0c0b642008-02-08 04:19:00 -0800102 if ((child->ptrace & PT_PTRACED) && child->parent == current) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 ret = 0;
Oleg Nesterovc0c0b642008-02-08 04:19:00 -0800104 /*
105 * child->sighand can't be NULL, release_task()
106 * does ptrace_unlink() before __exit_signal().
107 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 spin_lock_irq(&child->sighand->siglock);
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800109 if (task_is_stopped(child))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 child->state = TASK_TRACED;
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800111 else if (!task_is_traced(child) && !kill)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 ret = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 spin_unlock_irq(&child->sighand->siglock);
114 }
115 read_unlock(&tasklist_lock);
116
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800117 if (!ret && !kill)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 wait_task_inactive(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120 /* All systems go.. */
121 return ret;
122}
123
Al Viro831830b2008-01-02 14:09:57 +0000124int __ptrace_may_attach(struct task_struct *task)
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700125{
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700126 /* May we inspect the given task?
127 * This check is used both for attaching with ptrace
128 * and for allowing access to sensitive information in /proc.
129 *
130 * ptrace_attach denies several cases that /proc allows
131 * because setting up the necessary parent/child relationship
132 * or halting the specified task is impossible.
133 */
134 int dumpable = 0;
135 /* Don't let security modules deny introspection */
136 if (task == current)
137 return 0;
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700138 if (((current->uid != task->euid) ||
139 (current->uid != task->suid) ||
140 (current->uid != task->uid) ||
141 (current->gid != task->egid) ||
142 (current->gid != task->sgid) ||
143 (current->gid != task->gid)) && !capable(CAP_SYS_PTRACE))
144 return -EPERM;
145 smp_rmb();
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700146 if (task->mm)
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700147 dumpable = get_dumpable(task->mm);
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700148 if (!dumpable && !capable(CAP_SYS_PTRACE))
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700149 return -EPERM;
150
151 return security_ptrace(current, task);
152}
153
154int ptrace_may_attach(struct task_struct *task)
155{
156 int err;
157 task_lock(task);
Al Viro831830b2008-01-02 14:09:57 +0000158 err = __ptrace_may_attach(task);
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700159 task_unlock(task);
160 return !err;
161}
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163int ptrace_attach(struct task_struct *task)
164{
165 int retval;
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700166 unsigned long flags;
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700167
Al Viroa5cb0132007-03-20 13:58:35 -0400168 audit_ptrace(task);
169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 retval = -EPERM;
171 if (task->pid <= 1)
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700172 goto out;
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -0700173 if (same_thread_group(task, current))
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700174 goto out;
175
Linus Torvaldsf3581662006-05-11 11:08:49 -0700176repeat:
177 /*
178 * Nasty, nasty.
179 *
180 * We want to hold both the task-lock and the
181 * tasklist_lock for writing at the same time.
182 * But that's against the rules (tasklist_lock
183 * is taken for reading by interrupts on other
184 * cpu's that may have task_lock).
185 */
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700186 task_lock(task);
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700187 if (!write_trylock_irqsave(&tasklist_lock, flags)) {
Linus Torvaldsf3581662006-05-11 11:08:49 -0700188 task_unlock(task);
189 do {
190 cpu_relax();
191 } while (!write_can_lock(&tasklist_lock));
192 goto repeat;
193 }
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700194
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700195 if (!task->mm)
196 goto bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 /* the same process cannot be attached many times */
198 if (task->ptrace & PT_PTRACED)
199 goto bad;
Linus Torvaldsb8c9a182008-01-02 13:48:27 -0800200 retval = __ptrace_may_attach(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 if (retval)
202 goto bad;
203
204 /* Go */
Oleg Nesterov6b39c7b2008-02-08 04:18:58 -0800205 task->ptrace |= PT_PTRACED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 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 Hellwig6b9c7ed82006-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 Hellwig6b9c7ed82006-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 Hellwig6b9c7ed82006-01-08 01:02:33 -0800505}
Christoph Hellwig481bed42005-11-07 00:59:47 -0800506
Christoph Hellwig6b9c7ed82006-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 Hellwig6b9c7ed82006-01-08 01:02:33 -0800522 * Tracing init is not allowed.
Christoph Hellwig481bed42005-11-07 00:59:47 -0800523 */
524 if (pid == 1)
Christoph Hellwig6b9c7ed82006-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 Hellwig6b9c7ed82006-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 Hellwig6b9c7ed82006-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 Hellwig6b9c7ed82006-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 Hellwig6b9c7ed82006-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}
Roland McGrath032d82d2008-01-30 13:31:47 +0100610
611#ifdef CONFIG_COMPAT
612#include <linux/compat.h>
613
614int compat_ptrace_request(struct task_struct *child, compat_long_t request,
615 compat_ulong_t addr, compat_ulong_t data)
616{
617 compat_ulong_t __user *datap = compat_ptr(data);
618 compat_ulong_t word;
619 int ret;
620
621 switch (request) {
622 case PTRACE_PEEKTEXT:
623 case PTRACE_PEEKDATA:
624 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
625 if (ret != sizeof(word))
626 ret = -EIO;
627 else
628 ret = put_user(word, datap);
629 break;
630
631 case PTRACE_POKETEXT:
632 case PTRACE_POKEDATA:
633 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
634 ret = (ret != sizeof(data) ? -EIO : 0);
635 break;
636
637 case PTRACE_GETEVENTMSG:
638 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
639 break;
640
641 default:
642 ret = ptrace_request(child, request, addr, data);
643 }
644
645 return ret;
646}
Roland McGrathc269f192008-01-30 13:31:48 +0100647
648#ifdef __ARCH_WANT_COMPAT_SYS_PTRACE
649asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
650 compat_long_t addr, compat_long_t data)
651{
652 struct task_struct *child;
653 long ret;
654
655 /*
656 * This lock_kernel fixes a subtle race with suid exec
657 */
658 lock_kernel();
659 if (request == PTRACE_TRACEME) {
660 ret = ptrace_traceme();
661 goto out;
662 }
663
664 child = ptrace_get_task_struct(pid);
665 if (IS_ERR(child)) {
666 ret = PTR_ERR(child);
667 goto out;
668 }
669
670 if (request == PTRACE_ATTACH) {
671 ret = ptrace_attach(child);
672 /*
673 * Some architectures need to do book-keeping after
674 * a ptrace attach.
675 */
676 if (!ret)
677 arch_ptrace_attach(child);
678 goto out_put_task_struct;
679 }
680
681 ret = ptrace_check_attach(child, request == PTRACE_KILL);
682 if (!ret)
683 ret = compat_arch_ptrace(child, request, addr, data);
684
685 out_put_task_struct:
686 put_task_struct(child);
687 out:
688 unlock_kernel();
689 return ret;
690}
691#endif /* __ARCH_WANT_COMPAT_SYS_PTRACE */
692
Roland McGrath032d82d2008-01-30 13:31:47 +0100693#endif /* CONFIG_COMPAT */