]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - kernel/ptrace.c
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>
22 #include <asm/pgtable.h>
23 #include <asm/uaccess.h>
26 * ptrace a task: make the debugger its new parent and
27 * move it to the ptrace list.
29 * Must be called with the tasklist lock write-held.
31 void __ptrace_link(task_t
*child
, task_t
*new_parent
)
33 if (!list_empty(&child
->ptrace_list
))
35 if (child
->parent
== new_parent
)
37 list_add(&child
->ptrace_list
, &child
->parent
->ptrace_children
);
39 child
->parent
= new_parent
;
44 * Turn a tracing stop into a normal stop now, since with no tracer there
45 * would be no way to wake it up with SIGCONT or SIGKILL. If there was a
46 * signal sent that would resume the child, but didn't because it was in
47 * TASK_TRACED, resume it now.
48 * Requires that irqs be disabled.
50 void ptrace_untrace(task_t
*child
)
52 spin_lock(&child
->sighand
->siglock
);
53 if (child
->state
== TASK_TRACED
) {
54 if (child
->signal
->flags
& SIGNAL_STOP_STOPPED
) {
55 child
->state
= TASK_STOPPED
;
57 signal_wake_up(child
, 1);
60 if (child
->signal
->flags
& SIGNAL_GROUP_EXIT
) {
61 sigaddset(&child
->pending
.signal
, SIGKILL
);
62 signal_wake_up(child
, 1);
64 spin_unlock(&child
->sighand
->siglock
);
68 * unptrace a task: move it back to its original parent and
69 * remove it from the ptrace list.
71 * Must be called with the tasklist lock write-held.
73 void __ptrace_unlink(task_t
*child
)
75 BUG_ON(!child
->ptrace
);
78 if (!list_empty(&child
->ptrace_list
)) {
79 list_del_init(&child
->ptrace_list
);
81 child
->parent
= child
->real_parent
;
85 ptrace_untrace(child
);
89 * Check that we have indeed attached to the thing..
91 int ptrace_check_attach(struct task_struct
*child
, int kill
)
96 * We take the read lock around doing both checks to close a
97 * possible race where someone else was tracing our child and
98 * detached between these two checks. After this locked check,
99 * we are sure that this is our traced child and that can only
100 * be changed by us so it's not changing right after this.
102 read_lock(&tasklist_lock
);
103 if ((child
->ptrace
& PT_PTRACED
) && child
->parent
== current
&&
104 (!(child
->ptrace
& PT_ATTACHED
) || child
->real_parent
!= current
)
105 && child
->signal
!= NULL
) {
107 spin_lock_irq(&child
->sighand
->siglock
);
108 if (child
->state
== TASK_STOPPED
) {
109 child
->state
= TASK_TRACED
;
110 } else if (child
->state
!= TASK_TRACED
&& !kill
) {
113 spin_unlock_irq(&child
->sighand
->siglock
);
115 read_unlock(&tasklist_lock
);
118 wait_task_inactive(child
);
121 /* All systems go.. */
125 static int may_attach(struct task_struct
*task
)
129 if (((current
->uid
!= task
->euid
) ||
130 (current
->uid
!= task
->suid
) ||
131 (current
->uid
!= task
->uid
) ||
132 (current
->gid
!= task
->egid
) ||
133 (current
->gid
!= task
->sgid
) ||
134 (current
->gid
!= task
->gid
)) && !capable(CAP_SYS_PTRACE
))
137 if (!task
->mm
->dumpable
&& !capable(CAP_SYS_PTRACE
))
140 return security_ptrace(current
, task
);
143 int ptrace_may_attach(struct task_struct
*task
)
147 err
= may_attach(task
);
152 int ptrace_attach(struct task_struct
*task
)
159 if (task
->tgid
== current
->tgid
)
161 /* the same process cannot be attached many times */
162 if (task
->ptrace
& PT_PTRACED
)
164 retval
= may_attach(task
);
169 task
->ptrace
|= PT_PTRACED
| ((task
->real_parent
!= current
)
171 if (capable(CAP_SYS_PTRACE
))
172 task
->ptrace
|= PT_PTRACE_CAP
;
175 write_lock_irq(&tasklist_lock
);
176 __ptrace_link(task
, current
);
177 write_unlock_irq(&tasklist_lock
);
179 force_sig_specific(SIGSTOP
, task
);
187 void __ptrace_detach(struct task_struct
*child
, unsigned int data
)
189 child
->exit_code
= data
;
190 /* .. re-parent .. */
191 __ptrace_unlink(child
);
192 /* .. and wake it up. */
193 if (child
->exit_state
!= EXIT_ZOMBIE
)
194 wake_up_process(child
);
197 int ptrace_detach(struct task_struct
*child
, unsigned int data
)
199 if (!valid_signal(data
))
202 /* Architecture-specific hardware disable .. */
203 ptrace_disable(child
);
205 write_lock_irq(&tasklist_lock
);
207 __ptrace_detach(child
, data
);
208 write_unlock_irq(&tasklist_lock
);
214 * Access another process' address space.
215 * Source/target buffer must be kernel space,
216 * Do not walk the page table directly, use get_user_pages
219 int access_process_vm(struct task_struct
*tsk
, unsigned long addr
, void *buf
, int len
, int write
)
221 struct mm_struct
*mm
;
222 struct vm_area_struct
*vma
;
226 mm
= get_task_mm(tsk
);
230 down_read(&mm
->mmap_sem
);
231 /* ignore errors, just check how much was sucessfully transfered */
233 int bytes
, ret
, offset
;
236 ret
= get_user_pages(tsk
, mm
, addr
, 1,
237 write
, 1, &page
, &vma
);
242 offset
= addr
& (PAGE_SIZE
-1);
243 if (bytes
> PAGE_SIZE
-offset
)
244 bytes
= PAGE_SIZE
-offset
;
248 copy_to_user_page(vma
, page
, addr
,
249 maddr
+ offset
, buf
, bytes
);
250 set_page_dirty_lock(page
);
252 copy_from_user_page(vma
, page
, addr
,
253 buf
, maddr
+ offset
, bytes
);
256 page_cache_release(page
);
261 up_read(&mm
->mmap_sem
);
264 return buf
- old_buf
;
267 int ptrace_readdata(struct task_struct
*tsk
, unsigned long src
, char __user
*dst
, int len
)
273 int this_len
, retval
;
275 this_len
= (len
> sizeof(buf
)) ? sizeof(buf
) : len
;
276 retval
= access_process_vm(tsk
, src
, buf
, this_len
, 0);
282 if (copy_to_user(dst
, buf
, retval
))
292 int ptrace_writedata(struct task_struct
*tsk
, char __user
*src
, unsigned long dst
, int len
)
298 int this_len
, retval
;
300 this_len
= (len
> sizeof(buf
)) ? sizeof(buf
) : len
;
301 if (copy_from_user(buf
, src
, this_len
))
303 retval
= access_process_vm(tsk
, dst
, buf
, this_len
, 1);
317 static int ptrace_setoptions(struct task_struct
*child
, long data
)
319 child
->ptrace
&= ~PT_TRACE_MASK
;
321 if (data
& PTRACE_O_TRACESYSGOOD
)
322 child
->ptrace
|= PT_TRACESYSGOOD
;
324 if (data
& PTRACE_O_TRACEFORK
)
325 child
->ptrace
|= PT_TRACE_FORK
;
327 if (data
& PTRACE_O_TRACEVFORK
)
328 child
->ptrace
|= PT_TRACE_VFORK
;
330 if (data
& PTRACE_O_TRACECLONE
)
331 child
->ptrace
|= PT_TRACE_CLONE
;
333 if (data
& PTRACE_O_TRACEEXEC
)
334 child
->ptrace
|= PT_TRACE_EXEC
;
336 if (data
& PTRACE_O_TRACEVFORKDONE
)
337 child
->ptrace
|= PT_TRACE_VFORK_DONE
;
339 if (data
& PTRACE_O_TRACEEXIT
)
340 child
->ptrace
|= PT_TRACE_EXIT
;
342 return (data
& ~PTRACE_O_MASK
) ? -EINVAL
: 0;
345 static int ptrace_getsiginfo(struct task_struct
*child
, siginfo_t __user
* data
)
350 read_lock(&tasklist_lock
);
351 if (likely(child
->sighand
!= NULL
)) {
353 spin_lock_irq(&child
->sighand
->siglock
);
354 if (likely(child
->last_siginfo
!= NULL
)) {
355 lastinfo
= *child
->last_siginfo
;
358 spin_unlock_irq(&child
->sighand
->siglock
);
360 read_unlock(&tasklist_lock
);
362 return copy_siginfo_to_user(data
, &lastinfo
);
366 static int ptrace_setsiginfo(struct task_struct
*child
, siginfo_t __user
* data
)
371 if (copy_from_user(&newinfo
, data
, sizeof (siginfo_t
)))
374 read_lock(&tasklist_lock
);
375 if (likely(child
->sighand
!= NULL
)) {
377 spin_lock_irq(&child
->sighand
->siglock
);
378 if (likely(child
->last_siginfo
!= NULL
)) {
379 *child
->last_siginfo
= newinfo
;
382 spin_unlock_irq(&child
->sighand
->siglock
);
384 read_unlock(&tasklist_lock
);
388 int ptrace_request(struct task_struct
*child
, long request
,
389 long addr
, long data
)
394 #ifdef PTRACE_OLDSETOPTIONS
395 case PTRACE_OLDSETOPTIONS
:
397 case PTRACE_SETOPTIONS
:
398 ret
= ptrace_setoptions(child
, data
);
400 case PTRACE_GETEVENTMSG
:
401 ret
= put_user(child
->ptrace_message
, (unsigned long __user
*) data
);
403 case PTRACE_GETSIGINFO
:
404 ret
= ptrace_getsiginfo(child
, (siginfo_t __user
*) data
);
406 case PTRACE_SETSIGINFO
:
407 ret
= ptrace_setsiginfo(child
, (siginfo_t __user
*) data
);
417 * ptrace_traceme -- helper for PTRACE_TRACEME
419 * Performs checks and sets PT_PTRACED.
420 * Should be used by all ptrace implementations for PTRACE_TRACEME.
422 int ptrace_traceme(void)
427 * Are we already being traced?
429 if (current
->ptrace
& PT_PTRACED
)
431 ret
= security_ptrace(current
->parent
, current
);
435 * Set the ptrace bit in the process ptrace flags.
437 current
->ptrace
|= PT_PTRACED
;
442 * ptrace_get_task_struct -- grab a task struct reference for ptrace
443 * @pid: process id to grab a task_struct reference of
445 * This function is a helper for ptrace implementations. It checks
446 * permissions and then grabs a task struct for use of the actual
447 * ptrace implementation.
449 * Returns the task_struct for @pid or an ERR_PTR() on failure.
451 struct task_struct
*ptrace_get_task_struct(pid_t pid
)
453 struct task_struct
*child
;
456 * Tracing init is not allowed.
459 return ERR_PTR(-EPERM
);
461 read_lock(&tasklist_lock
);
462 child
= find_task_by_pid(pid
);
464 get_task_struct(child
);
465 read_unlock(&tasklist_lock
);
467 return ERR_PTR(-ESRCH
);
471 #ifndef __ARCH_SYS_PTRACE
472 asmlinkage
long sys_ptrace(long request
, long pid
, long addr
, long data
)
474 struct task_struct
*child
;
478 * This lock_kernel fixes a subtle race with suid exec
481 if (request
== PTRACE_TRACEME
) {
482 ret
= ptrace_traceme();
486 child
= ptrace_get_task_struct(pid
);
488 ret
= PTR_ERR(child
);
492 if (request
== PTRACE_ATTACH
) {
493 ret
= ptrace_attach(child
);
494 goto out_put_task_struct
;
497 ret
= ptrace_check_attach(child
, request
== PTRACE_KILL
);
499 goto out_put_task_struct
;
501 ret
= arch_ptrace(child
, request
, addr
, data
);
503 goto out_put_task_struct
;
506 put_task_struct(child
);
511 #endif /* __ARCH_SYS_PTRACE */