Merge branch 'master' into next
[linux-2.6.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 #include <linux/syscalls.h>
24
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  */
34 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
35 {
36         BUG_ON(!list_empty(&child->ptrace_entry));
37         list_add(&child->ptrace_entry, &new_parent->ptraced);
38         child->parent = new_parent;
39 }
40  
41 /*
42  * Turn a tracing stop into a normal stop now, since with no tracer there
43  * would be no way to wake it up with SIGCONT or SIGKILL.  If there was a
44  * signal sent that would resume the child, but didn't because it was in
45  * TASK_TRACED, resume it now.
46  * Requires that irqs be disabled.
47  */
48 static void ptrace_untrace(struct task_struct *child)
49 {
50         spin_lock(&child->sighand->siglock);
51         if (task_is_traced(child)) {
52                 if (child->signal->flags & SIGNAL_STOP_STOPPED) {
53                         __set_task_state(child, TASK_STOPPED);
54                 } else {
55                         signal_wake_up(child, 1);
56                 }
57         }
58         spin_unlock(&child->sighand->siglock);
59 }
60
61 /*
62  * unptrace a task: move it back to its original parent and
63  * remove it from the ptrace list.
64  *
65  * Must be called with the tasklist lock write-held.
66  */
67 void __ptrace_unlink(struct task_struct *child)
68 {
69         BUG_ON(!child->ptrace);
70
71         child->ptrace = 0;
72         child->parent = child->real_parent;
73         list_del_init(&child->ptrace_entry);
74
75         if (task_is_traced(child))
76                 ptrace_untrace(child);
77 }
78
79 /*
80  * Check that we have indeed attached to the thing..
81  */
82 int ptrace_check_attach(struct task_struct *child, int kill)
83 {
84         int ret = -ESRCH;
85
86         /*
87          * We take the read lock around doing both checks to close a
88          * possible race where someone else was tracing our child and
89          * detached between these two checks.  After this locked check,
90          * we are sure that this is our traced child and that can only
91          * be changed by us so it's not changing right after this.
92          */
93         read_lock(&tasklist_lock);
94         if ((child->ptrace & PT_PTRACED) && child->parent == current) {
95                 ret = 0;
96                 /*
97                  * child->sighand can't be NULL, release_task()
98                  * does ptrace_unlink() before __exit_signal().
99                  */
100                 spin_lock_irq(&child->sighand->siglock);
101                 if (task_is_stopped(child))
102                         child->state = TASK_TRACED;
103                 else if (!task_is_traced(child) && !kill)
104                         ret = -ESRCH;
105                 spin_unlock_irq(&child->sighand->siglock);
106         }
107         read_unlock(&tasklist_lock);
108
109         if (!ret && !kill)
110                 ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH;
111
112         /* All systems go.. */
113         return ret;
114 }
115
116 int __ptrace_may_access(struct task_struct *task, unsigned int mode)
117 {
118         const struct cred *cred = current_cred(), *tcred;
119
120         /* May we inspect the given task?
121          * This check is used both for attaching with ptrace
122          * and for allowing access to sensitive information in /proc.
123          *
124          * ptrace_attach denies several cases that /proc allows
125          * because setting up the necessary parent/child relationship
126          * or halting the specified task is impossible.
127          */
128         int dumpable = 0;
129         /* Don't let security modules deny introspection */
130         if (task == current)
131                 return 0;
132         rcu_read_lock();
133         tcred = __task_cred(task);
134         if ((cred->uid != tcred->euid ||
135              cred->uid != tcred->suid ||
136              cred->uid != tcred->uid  ||
137              cred->gid != tcred->egid ||
138              cred->gid != tcred->sgid ||
139              cred->gid != tcred->gid) &&
140             !capable(CAP_SYS_PTRACE)) {
141                 rcu_read_unlock();
142                 return -EPERM;
143         }
144         rcu_read_unlock();
145         smp_rmb();
146         if (task->mm)
147                 dumpable = get_dumpable(task->mm);
148         if (!dumpable && !capable(CAP_SYS_PTRACE))
149                 return -EPERM;
150
151         return security_ptrace_may_access(task, mode);
152 }
153
154 bool ptrace_may_access(struct task_struct *task, unsigned int mode)
155 {
156         int err;
157         task_lock(task);
158         err = __ptrace_may_access(task, mode);
159         task_unlock(task);
160         return (!err ? true : false);
161 }
162
163 int ptrace_attach(struct task_struct *task)
164 {
165         int retval;
166         unsigned long flags;
167
168         audit_ptrace(task);
169
170         retval = -EPERM;
171         if (same_thread_group(task, current))
172                 goto out;
173
174         /* Protect exec's credential calculations against our interference;
175          * SUID, SGID and LSM creds get determined differently under ptrace.
176          */
177         retval = mutex_lock_interruptible(&current->cred_exec_mutex);
178         if (retval  < 0)
179                 goto out;
180
181         retval = -EPERM;
182 repeat:
183         /*
184          * Nasty, nasty.
185          *
186          * We want to hold both the task-lock and the
187          * tasklist_lock for writing at the same time.
188          * But that's against the rules (tasklist_lock
189          * is taken for reading by interrupts on other
190          * cpu's that may have task_lock).
191          */
192         task_lock(task);
193         if (!write_trylock_irqsave(&tasklist_lock, flags)) {
194                 task_unlock(task);
195                 do {
196                         cpu_relax();
197                 } while (!write_can_lock(&tasklist_lock));
198                 goto repeat;
199         }
200
201         if (!task->mm)
202                 goto bad;
203         /* the same process cannot be attached many times */
204         if (task->ptrace & PT_PTRACED)
205                 goto bad;
206         retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH);
207         if (retval)
208                 goto bad;
209
210         /* Go */
211         task->ptrace |= PT_PTRACED;
212         if (capable(CAP_SYS_PTRACE))
213                 task->ptrace |= PT_PTRACE_CAP;
214
215         __ptrace_link(task, current);
216
217         send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
218 bad:
219         write_unlock_irqrestore(&tasklist_lock, flags);
220         task_unlock(task);
221         mutex_unlock(&current->cred_exec_mutex);
222 out:
223         return retval;
224 }
225
226 static inline void __ptrace_detach(struct task_struct *child, unsigned int data)
227 {
228         child->exit_code = data;
229         /* .. re-parent .. */
230         __ptrace_unlink(child);
231         /* .. and wake it up. */
232         if (child->exit_state != EXIT_ZOMBIE)
233                 wake_up_process(child);
234 }
235
236 int ptrace_detach(struct task_struct *child, unsigned int data)
237 {
238         if (!valid_signal(data))
239                 return -EIO;
240
241         /* Architecture-specific hardware disable .. */
242         ptrace_disable(child);
243         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
244
245         write_lock_irq(&tasklist_lock);
246         /* protect against de_thread()->release_task() */
247         if (child->ptrace)
248                 __ptrace_detach(child, data);
249         write_unlock_irq(&tasklist_lock);
250
251         return 0;
252 }
253
254 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
255 {
256         int copied = 0;
257
258         while (len > 0) {
259                 char buf[128];
260                 int this_len, retval;
261
262                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
263                 retval = access_process_vm(tsk, src, buf, this_len, 0);
264                 if (!retval) {
265                         if (copied)
266                                 break;
267                         return -EIO;
268                 }
269                 if (copy_to_user(dst, buf, retval))
270                         return -EFAULT;
271                 copied += retval;
272                 src += retval;
273                 dst += retval;
274                 len -= retval;                  
275         }
276         return copied;
277 }
278
279 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
280 {
281         int copied = 0;
282
283         while (len > 0) {
284                 char buf[128];
285                 int this_len, retval;
286
287                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
288                 if (copy_from_user(buf, src, this_len))
289                         return -EFAULT;
290                 retval = access_process_vm(tsk, dst, buf, this_len, 1);
291                 if (!retval) {
292                         if (copied)
293                                 break;
294                         return -EIO;
295                 }
296                 copied += retval;
297                 src += retval;
298                 dst += retval;
299                 len -= retval;                  
300         }
301         return copied;
302 }
303
304 static int ptrace_setoptions(struct task_struct *child, long data)
305 {
306         child->ptrace &= ~PT_TRACE_MASK;
307
308         if (data & PTRACE_O_TRACESYSGOOD)
309                 child->ptrace |= PT_TRACESYSGOOD;
310
311         if (data & PTRACE_O_TRACEFORK)
312                 child->ptrace |= PT_TRACE_FORK;
313
314         if (data & PTRACE_O_TRACEVFORK)
315                 child->ptrace |= PT_TRACE_VFORK;
316
317         if (data & PTRACE_O_TRACECLONE)
318                 child->ptrace |= PT_TRACE_CLONE;
319
320         if (data & PTRACE_O_TRACEEXEC)
321                 child->ptrace |= PT_TRACE_EXEC;
322
323         if (data & PTRACE_O_TRACEVFORKDONE)
324                 child->ptrace |= PT_TRACE_VFORK_DONE;
325
326         if (data & PTRACE_O_TRACEEXIT)
327                 child->ptrace |= PT_TRACE_EXIT;
328
329         return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
330 }
331
332 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info)
333 {
334         int error = -ESRCH;
335
336         read_lock(&tasklist_lock);
337         if (likely(child->sighand != NULL)) {
338                 error = -EINVAL;
339                 spin_lock_irq(&child->sighand->siglock);
340                 if (likely(child->last_siginfo != NULL)) {
341                         *info = *child->last_siginfo;
342                         error = 0;
343                 }
344                 spin_unlock_irq(&child->sighand->siglock);
345         }
346         read_unlock(&tasklist_lock);
347         return error;
348 }
349
350 static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
351 {
352         int error = -ESRCH;
353
354         read_lock(&tasklist_lock);
355         if (likely(child->sighand != NULL)) {
356                 error = -EINVAL;
357                 spin_lock_irq(&child->sighand->siglock);
358                 if (likely(child->last_siginfo != NULL)) {
359                         *child->last_siginfo = *info;
360                         error = 0;
361                 }
362                 spin_unlock_irq(&child->sighand->siglock);
363         }
364         read_unlock(&tasklist_lock);
365         return error;
366 }
367
368
369 #ifdef PTRACE_SINGLESTEP
370 #define is_singlestep(request)          ((request) == PTRACE_SINGLESTEP)
371 #else
372 #define is_singlestep(request)          0
373 #endif
374
375 #ifdef PTRACE_SINGLEBLOCK
376 #define is_singleblock(request)         ((request) == PTRACE_SINGLEBLOCK)
377 #else
378 #define is_singleblock(request)         0
379 #endif
380
381 #ifdef PTRACE_SYSEMU
382 #define is_sysemu_singlestep(request)   ((request) == PTRACE_SYSEMU_SINGLESTEP)
383 #else
384 #define is_sysemu_singlestep(request)   0
385 #endif
386
387 static int ptrace_resume(struct task_struct *child, long request, long data)
388 {
389         if (!valid_signal(data))
390                 return -EIO;
391
392         if (request == PTRACE_SYSCALL)
393                 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
394         else
395                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
396
397 #ifdef TIF_SYSCALL_EMU
398         if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
399                 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
400         else
401                 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
402 #endif
403
404         if (is_singleblock(request)) {
405                 if (unlikely(!arch_has_block_step()))
406                         return -EIO;
407                 user_enable_block_step(child);
408         } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
409                 if (unlikely(!arch_has_single_step()))
410                         return -EIO;
411                 user_enable_single_step(child);
412         }
413         else
414                 user_disable_single_step(child);
415
416         child->exit_code = data;
417         wake_up_process(child);
418
419         return 0;
420 }
421
422 int ptrace_request(struct task_struct *child, long request,
423                    long addr, long data)
424 {
425         int ret = -EIO;
426         siginfo_t siginfo;
427
428         switch (request) {
429         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
436 #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
446         case PTRACE_GETSIGINFO:
447                 ret = ptrace_getsiginfo(child, &siginfo);
448                 if (!ret)
449                         ret = copy_siginfo_to_user((siginfo_t __user *) data,
450                                                    &siginfo);
451                 break;
452
453         case PTRACE_SETSIGINFO:
454                 if (copy_from_user(&siginfo, (siginfo_t __user *) data,
455                                    sizeof siginfo))
456                         ret = -EFAULT;
457                 else
458                         ret = ptrace_setsiginfo(child, &siginfo);
459                 break;
460
461         case PTRACE_DETACH:      /* detach a process that was attached. */
462                 ret = ptrace_detach(child, data);
463                 break;
464
465 #ifdef PTRACE_SINGLESTEP
466         case PTRACE_SINGLESTEP:
467 #endif
468 #ifdef PTRACE_SINGLEBLOCK
469         case PTRACE_SINGLEBLOCK:
470 #endif
471 #ifdef PTRACE_SYSEMU
472         case PTRACE_SYSEMU:
473         case PTRACE_SYSEMU_SINGLESTEP:
474 #endif
475         case PTRACE_SYSCALL:
476         case PTRACE_CONT:
477                 return ptrace_resume(child, request, data);
478
479         case PTRACE_KILL:
480                 if (child->exit_state)  /* already dead */
481                         return 0;
482                 return ptrace_resume(child, request, SIGKILL);
483
484         default:
485                 break;
486         }
487
488         return ret;
489 }
490
491 /**
492  * ptrace_traceme  --  helper for PTRACE_TRACEME
493  *
494  * Performs checks and sets PT_PTRACED.
495  * Should be used by all ptrace implementations for PTRACE_TRACEME.
496  */
497 int ptrace_traceme(void)
498 {
499         int ret = -EPERM;
500
501         /*
502          * Are we already being traced?
503          */
504 repeat:
505         task_lock(current);
506         if (!(current->ptrace & PT_PTRACED)) {
507                 /*
508                  * See ptrace_attach() comments about the locking here.
509                  */
510                 unsigned long flags;
511                 if (!write_trylock_irqsave(&tasklist_lock, flags)) {
512                         task_unlock(current);
513                         do {
514                                 cpu_relax();
515                         } while (!write_can_lock(&tasklist_lock));
516                         goto repeat;
517                 }
518
519                 ret = security_ptrace_traceme(current->parent);
520
521                 /*
522                  * Set the ptrace bit in the process ptrace flags.
523                  * Then link us on our parent's ptraced list.
524                  */
525                 if (!ret) {
526                         current->ptrace |= PT_PTRACED;
527                         __ptrace_link(current, current->real_parent);
528                 }
529
530                 write_unlock_irqrestore(&tasklist_lock, flags);
531         }
532         task_unlock(current);
533         return ret;
534 }
535
536 /**
537  * ptrace_get_task_struct  --  grab a task struct reference for ptrace
538  * @pid:       process id to grab a task_struct reference of
539  *
540  * This function is a helper for ptrace implementations.  It checks
541  * permissions and then grabs a task struct for use of the actual
542  * ptrace implementation.
543  *
544  * Returns the task_struct for @pid or an ERR_PTR() on failure.
545  */
546 struct task_struct *ptrace_get_task_struct(pid_t pid)
547 {
548         struct task_struct *child;
549
550         read_lock(&tasklist_lock);
551         child = find_task_by_vpid(pid);
552         if (child)
553                 get_task_struct(child);
554
555         read_unlock(&tasklist_lock);
556         if (!child)
557                 return ERR_PTR(-ESRCH);
558         return child;
559 }
560
561 #ifndef arch_ptrace_attach
562 #define arch_ptrace_attach(child)       do { } while (0)
563 #endif
564
565 asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
566 {
567         struct task_struct *child;
568         long ret;
569
570         /*
571          * This lock_kernel fixes a subtle race with suid exec
572          */
573         lock_kernel();
574         if (request == PTRACE_TRACEME) {
575                 ret = ptrace_traceme();
576                 if (!ret)
577                         arch_ptrace_attach(current);
578                 goto out;
579         }
580
581         child = ptrace_get_task_struct(pid);
582         if (IS_ERR(child)) {
583                 ret = PTR_ERR(child);
584                 goto out;
585         }
586
587         if (request == PTRACE_ATTACH) {
588                 ret = ptrace_attach(child);
589                 /*
590                  * Some architectures need to do book-keeping after
591                  * a ptrace attach.
592                  */
593                 if (!ret)
594                         arch_ptrace_attach(child);
595                 goto out_put_task_struct;
596         }
597
598         ret = ptrace_check_attach(child, request == PTRACE_KILL);
599         if (ret < 0)
600                 goto out_put_task_struct;
601
602         ret = arch_ptrace(child, request, addr, data);
603         if (ret < 0)
604                 goto out_put_task_struct;
605
606  out_put_task_struct:
607         put_task_struct(child);
608  out:
609         unlock_kernel();
610         return ret;
611 }
612
613 int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
614 {
615         unsigned long tmp;
616         int copied;
617
618         copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
619         if (copied != sizeof(tmp))
620                 return -EIO;
621         return put_user(tmp, (unsigned long __user *)data);
622 }
623
624 int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
625 {
626         int copied;
627
628         copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
629         return (copied == sizeof(data)) ? 0 : -EIO;
630 }
631
632 #if defined CONFIG_COMPAT
633 #include <linux/compat.h>
634
635 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
636                           compat_ulong_t addr, compat_ulong_t data)
637 {
638         compat_ulong_t __user *datap = compat_ptr(data);
639         compat_ulong_t word;
640         siginfo_t siginfo;
641         int ret;
642
643         switch (request) {
644         case PTRACE_PEEKTEXT:
645         case PTRACE_PEEKDATA:
646                 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
647                 if (ret != sizeof(word))
648                         ret = -EIO;
649                 else
650                         ret = put_user(word, datap);
651                 break;
652
653         case PTRACE_POKETEXT:
654         case PTRACE_POKEDATA:
655                 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
656                 ret = (ret != sizeof(data) ? -EIO : 0);
657                 break;
658
659         case PTRACE_GETEVENTMSG:
660                 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
661                 break;
662
663         case PTRACE_GETSIGINFO:
664                 ret = ptrace_getsiginfo(child, &siginfo);
665                 if (!ret)
666                         ret = copy_siginfo_to_user32(
667                                 (struct compat_siginfo __user *) datap,
668                                 &siginfo);
669                 break;
670
671         case PTRACE_SETSIGINFO:
672                 memset(&siginfo, 0, sizeof siginfo);
673                 if (copy_siginfo_from_user32(
674                             &siginfo, (struct compat_siginfo __user *) datap))
675                         ret = -EFAULT;
676                 else
677                         ret = ptrace_setsiginfo(child, &siginfo);
678                 break;
679
680         default:
681                 ret = ptrace_request(child, request, addr, data);
682         }
683
684         return ret;
685 }
686
687 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
688                                   compat_long_t addr, compat_long_t data)
689 {
690         struct task_struct *child;
691         long ret;
692
693         /*
694          * This lock_kernel fixes a subtle race with suid exec
695          */
696         lock_kernel();
697         if (request == PTRACE_TRACEME) {
698                 ret = ptrace_traceme();
699                 goto out;
700         }
701
702         child = ptrace_get_task_struct(pid);
703         if (IS_ERR(child)) {
704                 ret = PTR_ERR(child);
705                 goto out;
706         }
707
708         if (request == PTRACE_ATTACH) {
709                 ret = ptrace_attach(child);
710                 /*
711                  * Some architectures need to do book-keeping after
712                  * a ptrace attach.
713                  */
714                 if (!ret)
715                         arch_ptrace_attach(child);
716                 goto out_put_task_struct;
717         }
718
719         ret = ptrace_check_attach(child, request == PTRACE_KILL);
720         if (!ret)
721                 ret = compat_arch_ptrace(child, request, addr, data);
722
723  out_put_task_struct:
724         put_task_struct(child);
725  out:
726         unlock_kernel();
727         return ret;
728 }
729 #endif  /* CONFIG_COMPAT */