use __set_task_state() for TRACED/STOPPED tasks
[linux-3.10.git] / kernel / ptrace.c
1 /*
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
10 #include <linux/capability.h>
11 #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>
20 #include <linux/signal.h>
21 #include <linux/audit.h>
22 #include <linux/pid_namespace.h>
23
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  */
33 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
34 {
35         BUG_ON(!list_empty(&child->ptrace_list));
36         if (child->parent == new_parent)
37                 return;
38         list_add(&child->ptrace_list, &child->parent->ptrace_children);
39         remove_parent(child);
40         child->parent = new_parent;
41         add_parent(child);
42 }
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  */
51 void ptrace_untrace(struct task_struct *child)
52 {
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);
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  */
70 void __ptrace_unlink(struct task_struct *child)
71 {
72         BUG_ON(!child->ptrace);
73
74         child->ptrace = 0;
75         if (!list_empty(&child->ptrace_list)) {
76                 list_del_init(&child->ptrace_list);
77                 remove_parent(child);
78                 child->parent = child->real_parent;
79                 add_parent(child);
80         }
81
82         if (task_is_traced(child))
83                 ptrace_untrace(child);
84 }
85
86 /*
87  * Check that we have indeed attached to the thing..
88  */
89 int 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 (task_is_stopped(child))
107                         child->state = TASK_TRACED;
108                 else if (!task_is_traced(child) && !kill)
109                         ret = -ESRCH;
110                 spin_unlock_irq(&child->sighand->siglock);
111         }
112         read_unlock(&tasklist_lock);
113
114         if (!ret && !kill)
115                 wait_task_inactive(child);
116
117         /* All systems go.. */
118         return ret;
119 }
120
121 int __ptrace_may_attach(struct task_struct *task)
122 {
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.
126          *
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.
130          */
131         int dumpable = 0;
132         /* Don't let security modules deny introspection */
133         if (task == current)
134                 return 0;
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))
141                 return -EPERM;
142         smp_rmb();
143         if (task->mm)
144                 dumpable = get_dumpable(task->mm);
145         if (!dumpable && !capable(CAP_SYS_PTRACE))
146                 return -EPERM;
147
148         return security_ptrace(current, task);
149 }
150
151 int ptrace_may_attach(struct task_struct *task)
152 {
153         int err;
154         task_lock(task);
155         err = __ptrace_may_attach(task);
156         task_unlock(task);
157         return !err;
158 }
159
160 int ptrace_attach(struct task_struct *task)
161 {
162         int retval;
163         unsigned long flags;
164
165         audit_ptrace(task);
166
167         retval = -EPERM;
168         if (task->pid <= 1)
169                 goto out;
170         if (same_thread_group(task, current))
171                 goto out;
172
173 repeat:
174         /*
175          * Nasty, nasty.
176          *
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).
182          */
183         task_lock(task);
184         if (!write_trylock_irqsave(&tasklist_lock, flags)) {
185                 task_unlock(task);
186                 do {
187                         cpu_relax();
188                 } while (!write_can_lock(&tasklist_lock));
189                 goto repeat;
190         }
191
192         if (!task->mm)
193                 goto bad;
194         /* the same process cannot be attached many times */
195         if (task->ptrace & PT_PTRACED)
196                 goto bad;
197         retval = __ptrace_may_attach(task);
198         if (retval)
199                 goto bad;
200
201         /* Go */
202         task->ptrace |= PT_PTRACED | ((task->real_parent != current)
203                                       ? PT_ATTACHED : 0);
204         if (capable(CAP_SYS_PTRACE))
205                 task->ptrace |= PT_PTRACE_CAP;
206
207         __ptrace_link(task, current);
208
209         force_sig_specific(SIGSTOP, task);
210
211 bad:
212         write_unlock_irqrestore(&tasklist_lock, flags);
213         task_unlock(task);
214 out:
215         return retval;
216 }
217
218 static inline void __ptrace_detach(struct task_struct *child, unsigned int data)
219 {
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);
226 }
227
228 int ptrace_detach(struct task_struct *child, unsigned int data)
229 {
230         if (!valid_signal(data))
231                 return -EIO;
232
233         /* Architecture-specific hardware disable .. */
234         ptrace_disable(child);
235         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
236
237         write_lock_irq(&tasklist_lock);
238         /* protect against de_thread()->release_task() */
239         if (child->ptrace)
240                 __ptrace_detach(child, data);
241         write_unlock_irq(&tasklist_lock);
242
243         return 0;
244 }
245
246 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
247 {
248         int copied = 0;
249
250         while (len > 0) {
251                 char buf[128];
252                 int this_len, retval;
253
254                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
255                 retval = access_process_vm(tsk, src, buf, this_len, 0);
256                 if (!retval) {
257                         if (copied)
258                                 break;
259                         return -EIO;
260                 }
261                 if (copy_to_user(dst, buf, retval))
262                         return -EFAULT;
263                 copied += retval;
264                 src += retval;
265                 dst += retval;
266                 len -= retval;                  
267         }
268         return copied;
269 }
270
271 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
272 {
273         int copied = 0;
274
275         while (len > 0) {
276                 char buf[128];
277                 int this_len, retval;
278
279                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
280                 if (copy_from_user(buf, src, this_len))
281                         return -EFAULT;
282                 retval = access_process_vm(tsk, dst, buf, this_len, 1);
283                 if (!retval) {
284                         if (copied)
285                                 break;
286                         return -EIO;
287                 }
288                 copied += retval;
289                 src += retval;
290                 dst += retval;
291                 len -= retval;                  
292         }
293         return copied;
294 }
295
296 static int ptrace_setoptions(struct task_struct *child, long data)
297 {
298         child->ptrace &= ~PT_TRACE_MASK;
299
300         if (data & PTRACE_O_TRACESYSGOOD)
301                 child->ptrace |= PT_TRACESYSGOOD;
302
303         if (data & PTRACE_O_TRACEFORK)
304                 child->ptrace |= PT_TRACE_FORK;
305
306         if (data & PTRACE_O_TRACEVFORK)
307                 child->ptrace |= PT_TRACE_VFORK;
308
309         if (data & PTRACE_O_TRACECLONE)
310                 child->ptrace |= PT_TRACE_CLONE;
311
312         if (data & PTRACE_O_TRACEEXEC)
313                 child->ptrace |= PT_TRACE_EXEC;
314
315         if (data & PTRACE_O_TRACEVFORKDONE)
316                 child->ptrace |= PT_TRACE_VFORK_DONE;
317
318         if (data & PTRACE_O_TRACEEXIT)
319                 child->ptrace |= PT_TRACE_EXIT;
320
321         return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
322 }
323
324 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t __user * data)
325 {
326         siginfo_t lastinfo;
327         int error = -ESRCH;
328
329         read_lock(&tasklist_lock);
330         if (likely(child->sighand != NULL)) {
331                 error = -EINVAL;
332                 spin_lock_irq(&child->sighand->siglock);
333                 if (likely(child->last_siginfo != NULL)) {
334                         lastinfo = *child->last_siginfo;
335                         error = 0;
336                 }
337                 spin_unlock_irq(&child->sighand->siglock);
338         }
339         read_unlock(&tasklist_lock);
340         if (!error)
341                 return copy_siginfo_to_user(data, &lastinfo);
342         return error;
343 }
344
345 static int ptrace_setsiginfo(struct task_struct *child, siginfo_t __user * data)
346 {
347         siginfo_t newinfo;
348         int error = -ESRCH;
349
350         if (copy_from_user(&newinfo, data, sizeof (siginfo_t)))
351                 return -EFAULT;
352
353         read_lock(&tasklist_lock);
354         if (likely(child->sighand != NULL)) {
355                 error = -EINVAL;
356                 spin_lock_irq(&child->sighand->siglock);
357                 if (likely(child->last_siginfo != NULL)) {
358                         *child->last_siginfo = newinfo;
359                         error = 0;
360                 }
361                 spin_unlock_irq(&child->sighand->siglock);
362         }
363         read_unlock(&tasklist_lock);
364         return error;
365 }
366
367
368 #ifdef PTRACE_SINGLESTEP
369 #define is_singlestep(request)          ((request) == PTRACE_SINGLESTEP)
370 #else
371 #define is_singlestep(request)          0
372 #endif
373
374 #ifdef PTRACE_SINGLEBLOCK
375 #define is_singleblock(request)         ((request) == PTRACE_SINGLEBLOCK)
376 #else
377 #define is_singleblock(request)         0
378 #endif
379
380 #ifdef PTRACE_SYSEMU
381 #define is_sysemu_singlestep(request)   ((request) == PTRACE_SYSEMU_SINGLESTEP)
382 #else
383 #define is_sysemu_singlestep(request)   0
384 #endif
385
386 static int ptrace_resume(struct task_struct *child, long request, long data)
387 {
388         if (!valid_signal(data))
389                 return -EIO;
390
391         if (request == PTRACE_SYSCALL)
392                 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
393         else
394                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
395
396 #ifdef TIF_SYSCALL_EMU
397         if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
398                 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
399         else
400                 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
401 #endif
402
403         if (is_singleblock(request)) {
404                 if (unlikely(!arch_has_block_step()))
405                         return -EIO;
406                 user_enable_block_step(child);
407         } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
408                 if (unlikely(!arch_has_single_step()))
409                         return -EIO;
410                 user_enable_single_step(child);
411         }
412         else
413                 user_disable_single_step(child);
414
415         child->exit_code = data;
416         wake_up_process(child);
417
418         return 0;
419 }
420
421 int ptrace_request(struct task_struct *child, long request,
422                    long addr, long data)
423 {
424         int ret = -EIO;
425
426         switch (request) {
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);
433
434 #ifdef PTRACE_OLDSETOPTIONS
435         case PTRACE_OLDSETOPTIONS:
436 #endif
437         case PTRACE_SETOPTIONS:
438                 ret = ptrace_setoptions(child, data);
439                 break;
440         case PTRACE_GETEVENTMSG:
441                 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
442                 break;
443         case PTRACE_GETSIGINFO:
444                 ret = ptrace_getsiginfo(child, (siginfo_t __user *) data);
445                 break;
446         case PTRACE_SETSIGINFO:
447                 ret = ptrace_setsiginfo(child, (siginfo_t __user *) data);
448                 break;
449         case PTRACE_DETACH:      /* detach a process that was attached. */
450                 ret = ptrace_detach(child, data);
451                 break;
452
453 #ifdef PTRACE_SINGLESTEP
454         case PTRACE_SINGLESTEP:
455 #endif
456 #ifdef PTRACE_SINGLEBLOCK
457         case PTRACE_SINGLEBLOCK:
458 #endif
459 #ifdef PTRACE_SYSEMU
460         case PTRACE_SYSEMU:
461         case PTRACE_SYSEMU_SINGLESTEP:
462 #endif
463         case PTRACE_SYSCALL:
464         case PTRACE_CONT:
465                 return ptrace_resume(child, request, data);
466
467         case PTRACE_KILL:
468                 if (child->exit_state)  /* already dead */
469                         return 0;
470                 return ptrace_resume(child, request, SIGKILL);
471
472         default:
473                 break;
474         }
475
476         return ret;
477 }
478
479 /**
480  * ptrace_traceme  --  helper for PTRACE_TRACEME
481  *
482  * Performs checks and sets PT_PTRACED.
483  * Should be used by all ptrace implementations for PTRACE_TRACEME.
484  */
485 int ptrace_traceme(void)
486 {
487         int ret = -EPERM;
488
489         /*
490          * Are we already being traced?
491          */
492         task_lock(current);
493         if (!(current->ptrace & PT_PTRACED)) {
494                 ret = security_ptrace(current->parent, current);
495                 /*
496                  * Set the ptrace bit in the process ptrace flags.
497                  */
498                 if (!ret)
499                         current->ptrace |= PT_PTRACED;
500         }
501         task_unlock(current);
502         return ret;
503 }
504
505 /**
506  * ptrace_get_task_struct  --  grab a task struct reference for ptrace
507  * @pid:       process id to grab a task_struct reference of
508  *
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.
512  *
513  * Returns the task_struct for @pid or an ERR_PTR() on failure.
514  */
515 struct task_struct *ptrace_get_task_struct(pid_t pid)
516 {
517         struct task_struct *child;
518
519         /*
520          * Tracing init is not allowed.
521          */
522         if (pid == 1)
523                 return ERR_PTR(-EPERM);
524
525         read_lock(&tasklist_lock);
526         child = find_task_by_vpid(pid);
527         if (child)
528                 get_task_struct(child);
529
530         read_unlock(&tasklist_lock);
531         if (!child)
532                 return ERR_PTR(-ESRCH);
533         return child;
534 }
535
536 #ifndef arch_ptrace_attach
537 #define arch_ptrace_attach(child)       do { } while (0)
538 #endif
539
540 #ifndef __ARCH_SYS_PTRACE
541 asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
542 {
543         struct task_struct *child;
544         long ret;
545
546         /*
547          * This lock_kernel fixes a subtle race with suid exec
548          */
549         lock_kernel();
550         if (request == PTRACE_TRACEME) {
551                 ret = ptrace_traceme();
552                 if (!ret)
553                         arch_ptrace_attach(current);
554                 goto out;
555         }
556
557         child = ptrace_get_task_struct(pid);
558         if (IS_ERR(child)) {
559                 ret = PTR_ERR(child);
560                 goto out;
561         }
562
563         if (request == PTRACE_ATTACH) {
564                 ret = ptrace_attach(child);
565                 /*
566                  * Some architectures need to do book-keeping after
567                  * a ptrace attach.
568                  */
569                 if (!ret)
570                         arch_ptrace_attach(child);
571                 goto out_put_task_struct;
572         }
573
574         ret = ptrace_check_attach(child, request == PTRACE_KILL);
575         if (ret < 0)
576                 goto out_put_task_struct;
577
578         ret = arch_ptrace(child, request, addr, data);
579         if (ret < 0)
580                 goto out_put_task_struct;
581
582  out_put_task_struct:
583         put_task_struct(child);
584  out:
585         unlock_kernel();
586         return ret;
587 }
588 #endif /* __ARCH_SYS_PTRACE */
589
590 int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
591 {
592         unsigned long tmp;
593         int copied;
594
595         copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
596         if (copied != sizeof(tmp))
597                 return -EIO;
598         return put_user(tmp, (unsigned long __user *)data);
599 }
600
601 int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
602 {
603         int copied;
604
605         copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
606         return (copied == sizeof(data)) ? 0 : -EIO;
607 }
608
609 #ifdef CONFIG_COMPAT
610 #include <linux/compat.h>
611
612 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
613                           compat_ulong_t addr, compat_ulong_t data)
614 {
615         compat_ulong_t __user *datap = compat_ptr(data);
616         compat_ulong_t word;
617         int ret;
618
619         switch (request) {
620         case PTRACE_PEEKTEXT:
621         case PTRACE_PEEKDATA:
622                 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
623                 if (ret != sizeof(word))
624                         ret = -EIO;
625                 else
626                         ret = put_user(word, datap);
627                 break;
628
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);
633                 break;
634
635         case PTRACE_GETEVENTMSG:
636                 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
637                 break;
638
639         default:
640                 ret = ptrace_request(child, request, addr, data);
641         }
642
643         return ret;
644 }
645
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)
649 {
650         struct task_struct *child;
651         long ret;
652
653         /*
654          * This lock_kernel fixes a subtle race with suid exec
655          */
656         lock_kernel();
657         if (request == PTRACE_TRACEME) {
658                 ret = ptrace_traceme();
659                 goto out;
660         }
661
662         child = ptrace_get_task_struct(pid);
663         if (IS_ERR(child)) {
664                 ret = PTR_ERR(child);
665                 goto out;
666         }
667
668         if (request == PTRACE_ATTACH) {
669                 ret = ptrace_attach(child);
670                 /*
671                  * Some architectures need to do book-keeping after
672                  * a ptrace attach.
673                  */
674                 if (!ret)
675                         arch_ptrace_attach(child);
676                 goto out_put_task_struct;
677         }
678
679         ret = ptrace_check_attach(child, request == PTRACE_KILL);
680         if (!ret)
681                 ret = compat_arch_ptrace(child, request, addr, data);
682
683  out_put_task_struct:
684         put_task_struct(child);
685  out:
686         unlock_kernel();
687         return ret;
688 }
689 #endif /* __ARCH_WANT_COMPAT_SYS_PTRACE */
690
691 #endif  /* CONFIG_COMPAT */