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