2 * linux/kernel/ptrace.c
4 * (C) Copyright 1999 Linus Torvalds
6 * Common interfaces for "ptrace()" which we do not want
7 * to continually duplicate across every architecture.
10 #include <linux/capability.h>
11 #include <linux/module.h>
12 #include <linux/sched.h>
13 #include <linux/errno.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>
20 #include <linux/signal.h>
21 #include <linux/audit.h>
22 #include <linux/pid_namespace.h>
24 #include <asm/pgtable.h>
25 #include <asm/uaccess.h>
28 * ptrace a task: make the debugger its new parent and
29 * move it to the ptrace list.
31 * Must be called with the tasklist lock write-held.
33 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
35 BUG_ON(!list_empty(&child->ptrace_list));
36 if (child->parent == new_parent)
38 list_add(&child->ptrace_list, &child->parent->ptrace_children);
40 child->parent = new_parent;
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.
51 void ptrace_untrace(struct task_struct *child)
53 spin_lock(&child->sighand->siglock);
54 if (task_is_traced(child)) {
55 if (child->signal->flags & SIGNAL_STOP_STOPPED) {
56 __set_task_state(child, TASK_STOPPED);
58 signal_wake_up(child, 1);
61 spin_unlock(&child->sighand->siglock);
65 * unptrace a task: move it back to its original parent and
66 * remove it from the ptrace list.
68 * Must be called with the tasklist lock write-held.
70 void __ptrace_unlink(struct task_struct *child)
72 BUG_ON(!child->ptrace);
75 if (!list_empty(&child->ptrace_list)) {
76 list_del_init(&child->ptrace_list);
78 child->parent = child->real_parent;
82 if (task_is_traced(child))
83 ptrace_untrace(child);
87 * Check that we have indeed attached to the thing..
89 int ptrace_check_attach(struct task_struct *child, int kill)
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.
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) {
105 spin_lock_irq(&child->sighand->siglock);
106 if (task_is_stopped(child))
107 child->state = TASK_TRACED;
108 else if (!task_is_traced(child) && !kill)
110 spin_unlock_irq(&child->sighand->siglock);
112 read_unlock(&tasklist_lock);
115 wait_task_inactive(child);
117 /* All systems go.. */
121 int __ptrace_may_attach(struct task_struct *task)
123 /* May we inspect the given task?
124 * This check is used both for attaching with ptrace
125 * and for allowing access to sensitive information in /proc.
127 * ptrace_attach denies several cases that /proc allows
128 * because setting up the necessary parent/child relationship
129 * or halting the specified task is impossible.
132 /* Don't let security modules deny introspection */
135 if (((current->uid != task->euid) ||
136 (current->uid != task->suid) ||
137 (current->uid != task->uid) ||
138 (current->gid != task->egid) ||
139 (current->gid != task->sgid) ||
140 (current->gid != task->gid)) && !capable(CAP_SYS_PTRACE))
144 dumpable = get_dumpable(task->mm);
145 if (!dumpable && !capable(CAP_SYS_PTRACE))
148 return security_ptrace(current, task);
151 int ptrace_may_attach(struct task_struct *task)
155 err = __ptrace_may_attach(task);
160 int ptrace_attach(struct task_struct *task)
170 if (same_thread_group(task, current))
177 * We want to hold both the task-lock and the
178 * tasklist_lock for writing at the same time.
179 * But that's against the rules (tasklist_lock
180 * is taken for reading by interrupts on other
181 * cpu's that may have task_lock).
184 if (!write_trylock_irqsave(&tasklist_lock, flags)) {
188 } while (!write_can_lock(&tasklist_lock));
194 /* the same process cannot be attached many times */
195 if (task->ptrace & PT_PTRACED)
197 retval = __ptrace_may_attach(task);
202 task->ptrace |= PT_PTRACED | ((task->real_parent != current)
204 if (capable(CAP_SYS_PTRACE))
205 task->ptrace |= PT_PTRACE_CAP;
207 __ptrace_link(task, current);
209 force_sig_specific(SIGSTOP, task);
212 write_unlock_irqrestore(&tasklist_lock, flags);
218 static inline void __ptrace_detach(struct task_struct *child, unsigned int data)
220 child->exit_code = data;
221 /* .. re-parent .. */
222 __ptrace_unlink(child);
223 /* .. and wake it up. */
224 if (child->exit_state != EXIT_ZOMBIE)
225 wake_up_process(child);
228 int ptrace_detach(struct task_struct *child, unsigned int data)
230 if (!valid_signal(data))
233 /* Architecture-specific hardware disable .. */
234 ptrace_disable(child);
235 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
237 write_lock_irq(&tasklist_lock);
238 /* protect against de_thread()->release_task() */
240 __ptrace_detach(child, data);
241 write_unlock_irq(&tasklist_lock);
246 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
252 int this_len, retval;
254 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
255 retval = access_process_vm(tsk, src, buf, this_len, 0);
261 if (copy_to_user(dst, buf, retval))
271 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
277 int this_len, retval;
279 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
280 if (copy_from_user(buf, src, this_len))
282 retval = access_process_vm(tsk, dst, buf, this_len, 1);
296 static int ptrace_setoptions(struct task_struct *child, long data)
298 child->ptrace &= ~PT_TRACE_MASK;
300 if (data & PTRACE_O_TRACESYSGOOD)
301 child->ptrace |= PT_TRACESYSGOOD;
303 if (data & PTRACE_O_TRACEFORK)
304 child->ptrace |= PT_TRACE_FORK;
306 if (data & PTRACE_O_TRACEVFORK)
307 child->ptrace |= PT_TRACE_VFORK;
309 if (data & PTRACE_O_TRACECLONE)
310 child->ptrace |= PT_TRACE_CLONE;
312 if (data & PTRACE_O_TRACEEXEC)
313 child->ptrace |= PT_TRACE_EXEC;
315 if (data & PTRACE_O_TRACEVFORKDONE)
316 child->ptrace |= PT_TRACE_VFORK_DONE;
318 if (data & PTRACE_O_TRACEEXIT)
319 child->ptrace |= PT_TRACE_EXIT;
321 return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
324 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t __user * data)
329 read_lock(&tasklist_lock);
330 if (likely(child->sighand != NULL)) {
332 spin_lock_irq(&child->sighand->siglock);
333 if (likely(child->last_siginfo != NULL)) {
334 lastinfo = *child->last_siginfo;
337 spin_unlock_irq(&child->sighand->siglock);
339 read_unlock(&tasklist_lock);
341 return copy_siginfo_to_user(data, &lastinfo);
345 static int ptrace_setsiginfo(struct task_struct *child, siginfo_t __user * data)
350 if (copy_from_user(&newinfo, data, sizeof (siginfo_t)))
353 read_lock(&tasklist_lock);
354 if (likely(child->sighand != NULL)) {
356 spin_lock_irq(&child->sighand->siglock);
357 if (likely(child->last_siginfo != NULL)) {
358 *child->last_siginfo = newinfo;
361 spin_unlock_irq(&child->sighand->siglock);
363 read_unlock(&tasklist_lock);
368 #ifdef PTRACE_SINGLESTEP
369 #define is_singlestep(request) ((request) == PTRACE_SINGLESTEP)
371 #define is_singlestep(request) 0
374 #ifdef PTRACE_SINGLEBLOCK
375 #define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK)
377 #define is_singleblock(request) 0
381 #define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP)
383 #define is_sysemu_singlestep(request) 0
386 static int ptrace_resume(struct task_struct *child, long request, long data)
388 if (!valid_signal(data))
391 if (request == PTRACE_SYSCALL)
392 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
394 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
396 #ifdef TIF_SYSCALL_EMU
397 if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
398 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
400 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
403 if (is_singleblock(request)) {
404 if (unlikely(!arch_has_block_step()))
406 user_enable_block_step(child);
407 } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
408 if (unlikely(!arch_has_single_step()))
410 user_enable_single_step(child);
413 user_disable_single_step(child);
415 child->exit_code = data;
416 wake_up_process(child);
421 int ptrace_request(struct task_struct *child, long request,
422 long addr, long data)
427 case PTRACE_PEEKTEXT:
428 case PTRACE_PEEKDATA:
429 return generic_ptrace_peekdata(child, addr, data);
430 case PTRACE_POKETEXT:
431 case PTRACE_POKEDATA:
432 return generic_ptrace_pokedata(child, addr, data);
434 #ifdef PTRACE_OLDSETOPTIONS
435 case PTRACE_OLDSETOPTIONS:
437 case PTRACE_SETOPTIONS:
438 ret = ptrace_setoptions(child, data);
440 case PTRACE_GETEVENTMSG:
441 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
443 case PTRACE_GETSIGINFO:
444 ret = ptrace_getsiginfo(child, (siginfo_t __user *) data);
446 case PTRACE_SETSIGINFO:
447 ret = ptrace_setsiginfo(child, (siginfo_t __user *) data);
449 case PTRACE_DETACH: /* detach a process that was attached. */
450 ret = ptrace_detach(child, data);
453 #ifdef PTRACE_SINGLESTEP
454 case PTRACE_SINGLESTEP:
456 #ifdef PTRACE_SINGLEBLOCK
457 case PTRACE_SINGLEBLOCK:
461 case PTRACE_SYSEMU_SINGLESTEP:
465 return ptrace_resume(child, request, data);
468 if (child->exit_state) /* already dead */
470 return ptrace_resume(child, request, SIGKILL);
480 * ptrace_traceme -- helper for PTRACE_TRACEME
482 * Performs checks and sets PT_PTRACED.
483 * Should be used by all ptrace implementations for PTRACE_TRACEME.
485 int ptrace_traceme(void)
490 * Are we already being traced?
493 if (!(current->ptrace & PT_PTRACED)) {
494 ret = security_ptrace(current->parent, current);
496 * Set the ptrace bit in the process ptrace flags.
499 current->ptrace |= PT_PTRACED;
501 task_unlock(current);
506 * ptrace_get_task_struct -- grab a task struct reference for ptrace
507 * @pid: process id to grab a task_struct reference of
509 * This function is a helper for ptrace implementations. It checks
510 * permissions and then grabs a task struct for use of the actual
511 * ptrace implementation.
513 * Returns the task_struct for @pid or an ERR_PTR() on failure.
515 struct task_struct *ptrace_get_task_struct(pid_t pid)
517 struct task_struct *child;
520 * Tracing init is not allowed.
523 return ERR_PTR(-EPERM);
525 read_lock(&tasklist_lock);
526 child = find_task_by_vpid(pid);
528 get_task_struct(child);
530 read_unlock(&tasklist_lock);
532 return ERR_PTR(-ESRCH);
536 #ifndef arch_ptrace_attach
537 #define arch_ptrace_attach(child) do { } while (0)
540 #ifndef __ARCH_SYS_PTRACE
541 asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
543 struct task_struct *child;
547 * This lock_kernel fixes a subtle race with suid exec
550 if (request == PTRACE_TRACEME) {
551 ret = ptrace_traceme();
553 arch_ptrace_attach(current);
557 child = ptrace_get_task_struct(pid);
559 ret = PTR_ERR(child);
563 if (request == PTRACE_ATTACH) {
564 ret = ptrace_attach(child);
566 * Some architectures need to do book-keeping after
570 arch_ptrace_attach(child);
571 goto out_put_task_struct;
574 ret = ptrace_check_attach(child, request == PTRACE_KILL);
576 goto out_put_task_struct;
578 ret = arch_ptrace(child, request, addr, data);
580 goto out_put_task_struct;
583 put_task_struct(child);
588 #endif /* __ARCH_SYS_PTRACE */
590 int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
595 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
596 if (copied != sizeof(tmp))
598 return put_user(tmp, (unsigned long __user *)data);
601 int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
605 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
606 return (copied == sizeof(data)) ? 0 : -EIO;
610 #include <linux/compat.h>
612 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
613 compat_ulong_t addr, compat_ulong_t data)
615 compat_ulong_t __user *datap = compat_ptr(data);
620 case PTRACE_PEEKTEXT:
621 case PTRACE_PEEKDATA:
622 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
623 if (ret != sizeof(word))
626 ret = put_user(word, datap);
629 case PTRACE_POKETEXT:
630 case PTRACE_POKEDATA:
631 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
632 ret = (ret != sizeof(data) ? -EIO : 0);
635 case PTRACE_GETEVENTMSG:
636 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
640 ret = ptrace_request(child, request, addr, data);
646 #ifdef __ARCH_WANT_COMPAT_SYS_PTRACE
647 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
648 compat_long_t addr, compat_long_t data)
650 struct task_struct *child;
654 * This lock_kernel fixes a subtle race with suid exec
657 if (request == PTRACE_TRACEME) {
658 ret = ptrace_traceme();
662 child = ptrace_get_task_struct(pid);
664 ret = PTR_ERR(child);
668 if (request == PTRACE_ATTACH) {
669 ret = ptrace_attach(child);
671 * Some architectures need to do book-keeping after
675 arch_ptrace_attach(child);
676 goto out_put_task_struct;
679 ret = ptrace_check_attach(child, request == PTRACE_KILL);
681 ret = compat_arch_ptrace(child, request, addr, data);
684 put_task_struct(child);
689 #endif /* __ARCH_WANT_COMPAT_SYS_PTRACE */
691 #endif /* CONFIG_COMPAT */