1
2
3
4
5
6
7
8
9
10#include <linux/capability.h>
11#include <linux/export.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/ptrace.h>
18#include <linux/security.h>
19#include <linux/signal.h>
20#include <linux/uio.h>
21#include <linux/audit.h>
22#include <linux/pid_namespace.h>
23#include <linux/syscalls.h>
24#include <linux/uaccess.h>
25#include <linux/regset.h>
26#include <linux/hw_breakpoint.h>
27#include <linux/cn_proc.h>
28#include <linux/compat.h>
29
30
31static int ptrace_trapping_sleep_fn(void *flags)
32{
33 schedule();
34 return 0;
35}
36
37
38
39
40
41
42
43void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
44{
45 BUG_ON(!list_empty(&child->ptrace_entry));
46 list_add(&child->ptrace_entry, &new_parent->ptraced);
47 child->parent = new_parent;
48}
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78void __ptrace_unlink(struct task_struct *child)
79{
80 BUG_ON(!child->ptrace);
81
82 child->ptrace = 0;
83 child->parent = child->real_parent;
84 list_del_init(&child->ptrace_entry);
85
86 spin_lock(&child->sighand->siglock);
87
88
89
90
91
92 task_clear_jobctl_pending(child, JOBCTL_TRAP_MASK);
93 task_clear_jobctl_trapping(child);
94
95
96
97
98
99 if (!(child->flags & PF_EXITING) &&
100 (child->signal->flags & SIGNAL_STOP_STOPPED ||
101 child->signal->group_stop_count)) {
102 child->jobctl |= JOBCTL_STOP_PENDING;
103
104
105
106
107
108
109
110
111 if (!(child->jobctl & JOBCTL_STOP_SIGMASK))
112 child->jobctl |= SIGSTOP;
113 }
114
115
116
117
118
119
120
121 if (child->jobctl & JOBCTL_STOP_PENDING || task_is_traced(child))
122 ptrace_signal_wake_up(child, true);
123
124 spin_unlock(&child->sighand->siglock);
125}
126
127
128static bool ptrace_freeze_traced(struct task_struct *task)
129{
130 bool ret = false;
131
132
133 if (task->jobctl & JOBCTL_LISTENING)
134 return ret;
135
136 spin_lock_irq(&task->sighand->siglock);
137 if (task_is_traced(task) && !__fatal_signal_pending(task)) {
138 task->state = __TASK_TRACED;
139 ret = true;
140 }
141 spin_unlock_irq(&task->sighand->siglock);
142
143 return ret;
144}
145
146static void ptrace_unfreeze_traced(struct task_struct *task)
147{
148 if (task->state != __TASK_TRACED)
149 return;
150
151 WARN_ON(!task->ptrace || task->parent != current);
152
153 spin_lock_irq(&task->sighand->siglock);
154 if (__fatal_signal_pending(task))
155 wake_up_state(task, __TASK_TRACED);
156 else
157 task->state = TASK_TRACED;
158 spin_unlock_irq(&task->sighand->siglock);
159}
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178static int ptrace_check_attach(struct task_struct *child, bool ignore_state)
179{
180 int ret = -ESRCH;
181
182
183
184
185
186
187
188
189 read_lock(&tasklist_lock);
190 if (child->ptrace && child->parent == current) {
191 WARN_ON(child->state == __TASK_TRACED);
192
193
194
195
196 if (ignore_state || ptrace_freeze_traced(child))
197 ret = 0;
198 }
199 read_unlock(&tasklist_lock);
200
201 if (!ret && !ignore_state) {
202 if (!wait_task_inactive(child, __TASK_TRACED)) {
203
204
205
206
207
208 WARN_ON(child->state == __TASK_TRACED);
209 ret = -ESRCH;
210 }
211 }
212
213 return ret;
214}
215
216static int ptrace_has_cap(struct user_namespace *ns, unsigned int mode)
217{
218 if (mode & PTRACE_MODE_NOAUDIT)
219 return has_ns_capability_noaudit(current, ns, CAP_SYS_PTRACE);
220 else
221 return has_ns_capability(current, ns, CAP_SYS_PTRACE);
222}
223
224
225static int __ptrace_may_access(struct task_struct *task, unsigned int mode)
226{
227 const struct cred *cred = current_cred(), *tcred;
228
229
230
231
232
233
234
235
236
237 int dumpable = 0;
238
239 if (task == current)
240 return 0;
241 rcu_read_lock();
242 tcred = __task_cred(task);
243 if (uid_eq(cred->uid, tcred->euid) &&
244 uid_eq(cred->uid, tcred->suid) &&
245 uid_eq(cred->uid, tcred->uid) &&
246 gid_eq(cred->gid, tcred->egid) &&
247 gid_eq(cred->gid, tcred->sgid) &&
248 gid_eq(cred->gid, tcred->gid))
249 goto ok;
250 if (ptrace_has_cap(tcred->user_ns, mode))
251 goto ok;
252 rcu_read_unlock();
253 return -EPERM;
254ok:
255 rcu_read_unlock();
256 smp_rmb();
257 if (task->mm)
258 dumpable = get_dumpable(task->mm);
259 rcu_read_lock();
260 if (!dumpable && !ptrace_has_cap(__task_cred(task)->user_ns, mode)) {
261 rcu_read_unlock();
262 return -EPERM;
263 }
264 rcu_read_unlock();
265
266 return security_ptrace_access_check(task, mode);
267}
268
269bool ptrace_may_access(struct task_struct *task, unsigned int mode)
270{
271 int err;
272 task_lock(task);
273 err = __ptrace_may_access(task, mode);
274 task_unlock(task);
275 return !err;
276}
277
278static int ptrace_attach(struct task_struct *task, long request,
279 unsigned long addr,
280 unsigned long flags)
281{
282 bool seize = (request == PTRACE_SEIZE);
283 int retval;
284
285 retval = -EIO;
286 if (seize) {
287 if (addr != 0)
288 goto out;
289 if (flags & ~(unsigned long)PTRACE_O_MASK)
290 goto out;
291 flags = PT_PTRACED | PT_SEIZED | (flags << PT_OPT_FLAG_SHIFT);
292 } else {
293 flags = PT_PTRACED;
294 }
295
296 audit_ptrace(task);
297
298 retval = -EPERM;
299 if (unlikely(task->flags & PF_KTHREAD))
300 goto out;
301 if (same_thread_group(task, current))
302 goto out;
303
304
305
306
307
308
309 retval = -ERESTARTNOINTR;
310 if (mutex_lock_interruptible(&task->signal->cred_guard_mutex))
311 goto out;
312
313 task_lock(task);
314 retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH);
315 task_unlock(task);
316 if (retval)
317 goto unlock_creds;
318
319 write_lock_irq(&tasklist_lock);
320 retval = -EPERM;
321 if (unlikely(task->exit_state))
322 goto unlock_tasklist;
323 if (task->ptrace)
324 goto unlock_tasklist;
325
326 if (seize)
327 flags |= PT_SEIZED;
328 rcu_read_lock();
329 if (ns_capable(__task_cred(task)->user_ns, CAP_SYS_PTRACE))
330 flags |= PT_PTRACE_CAP;
331 rcu_read_unlock();
332 task->ptrace = flags;
333
334 __ptrace_link(task, current);
335
336
337 if (!seize)
338 send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
339
340 spin_lock(&task->sighand->siglock);
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359 if (task_is_stopped(task) &&
360 task_set_jobctl_pending(task, JOBCTL_TRAP_STOP | JOBCTL_TRAPPING))
361 signal_wake_up_state(task, __TASK_STOPPED);
362
363 spin_unlock(&task->sighand->siglock);
364
365 retval = 0;
366unlock_tasklist:
367 write_unlock_irq(&tasklist_lock);
368unlock_creds:
369 mutex_unlock(&task->signal->cred_guard_mutex);
370out:
371 if (!retval) {
372 wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT,
373 ptrace_trapping_sleep_fn, TASK_UNINTERRUPTIBLE);
374 proc_ptrace_connector(task, PTRACE_ATTACH);
375 }
376
377 return retval;
378}
379
380
381
382
383
384
385
386static int ptrace_traceme(void)
387{
388 int ret = -EPERM;
389
390 write_lock_irq(&tasklist_lock);
391
392 if (!current->ptrace) {
393 ret = security_ptrace_traceme(current->parent);
394
395
396
397
398
399 if (!ret && !(current->real_parent->flags & PF_EXITING)) {
400 current->ptrace = PT_PTRACED;
401 __ptrace_link(current, current->real_parent);
402 }
403 }
404 write_unlock_irq(&tasklist_lock);
405
406 return ret;
407}
408
409
410
411
412static int ignoring_children(struct sighand_struct *sigh)
413{
414 int ret;
415 spin_lock(&sigh->siglock);
416 ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) ||
417 (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT);
418 spin_unlock(&sigh->siglock);
419 return ret;
420}
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p)
438{
439 bool dead;
440
441 __ptrace_unlink(p);
442
443 if (p->exit_state != EXIT_ZOMBIE)
444 return false;
445
446 dead = !thread_group_leader(p);
447
448 if (!dead && thread_group_empty(p)) {
449 if (!same_thread_group(p->real_parent, tracer))
450 dead = do_notify_parent(p, p->exit_signal);
451 else if (ignoring_children(tracer->sighand)) {
452 __wake_up_parent(p, tracer);
453 dead = true;
454 }
455 }
456
457 if (dead)
458 p->exit_state = EXIT_DEAD;
459 return dead;
460}
461
462static int ptrace_detach(struct task_struct *child, unsigned int data)
463{
464 bool dead = false;
465
466 if (!valid_signal(data))
467 return -EIO;
468
469
470 ptrace_disable(child);
471 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
472
473 write_lock_irq(&tasklist_lock);
474
475
476
477
478 if (child->ptrace) {
479 child->exit_code = data;
480 dead = __ptrace_detach(current, child);
481 }
482 write_unlock_irq(&tasklist_lock);
483
484 proc_ptrace_connector(child, PTRACE_DETACH);
485 if (unlikely(dead))
486 release_task(child);
487
488 return 0;
489}
490
491
492
493
494
495
496void exit_ptrace(struct task_struct *tracer)
497 __releases(&tasklist_lock)
498 __acquires(&tasklist_lock)
499{
500 struct task_struct *p, *n;
501 LIST_HEAD(ptrace_dead);
502
503 if (likely(list_empty(&tracer->ptraced)))
504 return;
505
506 list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) {
507 if (unlikely(p->ptrace & PT_EXITKILL))
508 send_sig_info(SIGKILL, SEND_SIG_FORCED, p);
509
510 if (__ptrace_detach(tracer, p))
511 list_add(&p->ptrace_entry, &ptrace_dead);
512 }
513
514 write_unlock_irq(&tasklist_lock);
515 BUG_ON(!list_empty(&tracer->ptraced));
516
517 list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) {
518 list_del_init(&p->ptrace_entry);
519 release_task(p);
520 }
521
522 write_lock_irq(&tasklist_lock);
523}
524
525int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
526{
527 int copied = 0;
528
529 while (len > 0) {
530 char buf[128];
531 int this_len, retval;
532
533 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
534 retval = access_process_vm(tsk, src, buf, this_len, 0);
535 if (!retval) {
536 if (copied)
537 break;
538 return -EIO;
539 }
540 if (copy_to_user(dst, buf, retval))
541 return -EFAULT;
542 copied += retval;
543 src += retval;
544 dst += retval;
545 len -= retval;
546 }
547 return copied;
548}
549
550int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
551{
552 int copied = 0;
553
554 while (len > 0) {
555 char buf[128];
556 int this_len, retval;
557
558 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
559 if (copy_from_user(buf, src, this_len))
560 return -EFAULT;
561 retval = access_process_vm(tsk, dst, buf, this_len, 1);
562 if (!retval) {
563 if (copied)
564 break;
565 return -EIO;
566 }
567 copied += retval;
568 src += retval;
569 dst += retval;
570 len -= retval;
571 }
572 return copied;
573}
574
575static int ptrace_setoptions(struct task_struct *child, unsigned long data)
576{
577 unsigned flags;
578
579 if (data & ~(unsigned long)PTRACE_O_MASK)
580 return -EINVAL;
581
582
583 flags = child->ptrace;
584 flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT);
585 flags |= (data << PT_OPT_FLAG_SHIFT);
586 child->ptrace = flags;
587
588 return 0;
589}
590
591static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info)
592{
593 unsigned long flags;
594 int error = -ESRCH;
595
596 if (lock_task_sighand(child, &flags)) {
597 error = -EINVAL;
598 if (likely(child->last_siginfo != NULL)) {
599 *info = *child->last_siginfo;
600 error = 0;
601 }
602 unlock_task_sighand(child, &flags);
603 }
604 return error;
605}
606
607static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
608{
609 unsigned long flags;
610 int error = -ESRCH;
611
612 if (lock_task_sighand(child, &flags)) {
613 error = -EINVAL;
614 if (likely(child->last_siginfo != NULL)) {
615 *child->last_siginfo = *info;
616 error = 0;
617 }
618 unlock_task_sighand(child, &flags);
619 }
620 return error;
621}
622
623static int ptrace_peek_siginfo(struct task_struct *child,
624 unsigned long addr,
625 unsigned long data)
626{
627 struct ptrace_peeksiginfo_args arg;
628 struct sigpending *pending;
629 struct sigqueue *q;
630 int ret, i;
631
632 ret = copy_from_user(&arg, (void __user *) addr,
633 sizeof(struct ptrace_peeksiginfo_args));
634 if (ret)
635 return -EFAULT;
636
637 if (arg.flags & ~PTRACE_PEEKSIGINFO_SHARED)
638 return -EINVAL;
639
640 if (arg.nr < 0)
641 return -EINVAL;
642
643 if (arg.flags & PTRACE_PEEKSIGINFO_SHARED)
644 pending = &child->signal->shared_pending;
645 else
646 pending = &child->pending;
647
648 for (i = 0; i < arg.nr; ) {
649 siginfo_t info;
650 s32 off = arg.off + i;
651
652 spin_lock_irq(&child->sighand->siglock);
653 list_for_each_entry(q, &pending->list, list) {
654 if (!off--) {
655 copy_siginfo(&info, &q->info);
656 break;
657 }
658 }
659 spin_unlock_irq(&child->sighand->siglock);
660
661 if (off >= 0)
662 break;
663
664#ifdef CONFIG_COMPAT
665 if (unlikely(is_compat_task())) {
666 compat_siginfo_t __user *uinfo = compat_ptr(data);
667
668 if (copy_siginfo_to_user32(uinfo, &info) ||
669 __put_user(info.si_code, &uinfo->si_code)) {
670 ret = -EFAULT;
671 break;
672 }
673
674 } else
675#endif
676 {
677 siginfo_t __user *uinfo = (siginfo_t __user *) data;
678
679 if (copy_siginfo_to_user(uinfo, &info) ||
680 __put_user(info.si_code, &uinfo->si_code)) {
681 ret = -EFAULT;
682 break;
683 }
684 }
685
686 data += sizeof(siginfo_t);
687 i++;
688
689 if (signal_pending(current))
690 break;
691
692 cond_resched();
693 }
694
695 if (i > 0)
696 return i;
697
698 return ret;
699}
700
701#ifdef PTRACE_SINGLESTEP
702#define is_singlestep(request) ((request) == PTRACE_SINGLESTEP)
703#else
704#define is_singlestep(request) 0
705#endif
706
707#ifdef PTRACE_SINGLEBLOCK
708#define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK)
709#else
710#define is_singleblock(request) 0
711#endif
712
713#ifdef PTRACE_SYSEMU
714#define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP)
715#else
716#define is_sysemu_singlestep(request) 0
717#endif
718
719static int ptrace_resume(struct task_struct *child, long request,
720 unsigned long data)
721{
722 if (!valid_signal(data))
723 return -EIO;
724
725 if (request == PTRACE_SYSCALL)
726 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
727 else
728 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
729
730#ifdef TIF_SYSCALL_EMU
731 if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
732 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
733 else
734 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
735#endif
736
737 if (is_singleblock(request)) {
738 if (unlikely(!arch_has_block_step()))
739 return -EIO;
740 user_enable_block_step(child);
741 } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
742 if (unlikely(!arch_has_single_step()))
743 return -EIO;
744 user_enable_single_step(child);
745 } else {
746 user_disable_single_step(child);
747 }
748
749 child->exit_code = data;
750 wake_up_state(child, __TASK_TRACED);
751
752 return 0;
753}
754
755#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
756
757static const struct user_regset *
758find_regset(const struct user_regset_view *view, unsigned int type)
759{
760 const struct user_regset *regset;
761 int n;
762
763 for (n = 0; n < view->n; ++n) {
764 regset = view->regsets + n;
765 if (regset->core_note_type == type)
766 return regset;
767 }
768
769 return NULL;
770}
771
772static int ptrace_regset(struct task_struct *task, int req, unsigned int type,
773 struct iovec *kiov)
774{
775 const struct user_regset_view *view = task_user_regset_view(task);
776 const struct user_regset *regset = find_regset(view, type);
777 int regset_no;
778
779 if (!regset || (kiov->iov_len % regset->size) != 0)
780 return -EINVAL;
781
782 regset_no = regset - view->regsets;
783 kiov->iov_len = min(kiov->iov_len,
784 (__kernel_size_t) (regset->n * regset->size));
785
786 if (req == PTRACE_GETREGSET)
787 return copy_regset_to_user(task, view, regset_no, 0,
788 kiov->iov_len, kiov->iov_base);
789 else
790 return copy_regset_from_user(task, view, regset_no, 0,
791 kiov->iov_len, kiov->iov_base);
792}
793
794
795
796
797
798
799EXPORT_SYMBOL_GPL(task_user_regset_view);
800#endif
801
802int ptrace_request(struct task_struct *child, long request,
803 unsigned long addr, unsigned long data)
804{
805 bool seized = child->ptrace & PT_SEIZED;
806 int ret = -EIO;
807 siginfo_t siginfo, *si;
808 void __user *datavp = (void __user *) data;
809 unsigned long __user *datalp = datavp;
810 unsigned long flags;
811
812 switch (request) {
813 case PTRACE_PEEKTEXT:
814 case PTRACE_PEEKDATA:
815 return generic_ptrace_peekdata(child, addr, data);
816 case PTRACE_POKETEXT:
817 case PTRACE_POKEDATA:
818 return generic_ptrace_pokedata(child, addr, data);
819
820#ifdef PTRACE_OLDSETOPTIONS
821 case PTRACE_OLDSETOPTIONS:
822#endif
823 case PTRACE_SETOPTIONS:
824 ret = ptrace_setoptions(child, data);
825 break;
826 case PTRACE_GETEVENTMSG:
827 ret = put_user(child->ptrace_message, datalp);
828 break;
829
830 case PTRACE_PEEKSIGINFO:
831 ret = ptrace_peek_siginfo(child, addr, data);
832 break;
833
834 case PTRACE_GETSIGINFO:
835 ret = ptrace_getsiginfo(child, &siginfo);
836 if (!ret)
837 ret = copy_siginfo_to_user(datavp, &siginfo);
838 break;
839
840 case PTRACE_SETSIGINFO:
841 if (copy_from_user(&siginfo, datavp, sizeof siginfo))
842 ret = -EFAULT;
843 else
844 ret = ptrace_setsiginfo(child, &siginfo);
845 break;
846
847 case PTRACE_GETSIGMASK:
848 if (addr != sizeof(sigset_t)) {
849 ret = -EINVAL;
850 break;
851 }
852
853 if (copy_to_user(datavp, &child->blocked, sizeof(sigset_t)))
854 ret = -EFAULT;
855 else
856 ret = 0;
857
858 break;
859
860 case PTRACE_SETSIGMASK: {
861 sigset_t new_set;
862
863 if (addr != sizeof(sigset_t)) {
864 ret = -EINVAL;
865 break;
866 }
867
868 if (copy_from_user(&new_set, datavp, sizeof(sigset_t))) {
869 ret = -EFAULT;
870 break;
871 }
872
873 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
874
875
876
877
878
879
880 spin_lock_irq(&child->sighand->siglock);
881 child->blocked = new_set;
882 spin_unlock_irq(&child->sighand->siglock);
883
884 ret = 0;
885 break;
886 }
887
888 case PTRACE_INTERRUPT:
889
890
891
892
893
894
895
896
897
898
899 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
900 break;
901
902
903
904
905
906
907
908 if (likely(task_set_jobctl_pending(child, JOBCTL_TRAP_STOP)))
909 ptrace_signal_wake_up(child, child->jobctl & JOBCTL_LISTENING);
910
911 unlock_task_sighand(child, &flags);
912 ret = 0;
913 break;
914
915 case PTRACE_LISTEN:
916
917
918
919
920
921
922
923
924 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
925 break;
926
927 si = child->last_siginfo;
928 if (likely(si && (si->si_code >> 8) == PTRACE_EVENT_STOP)) {
929 child->jobctl |= JOBCTL_LISTENING;
930
931
932
933
934 if (child->jobctl & JOBCTL_TRAP_NOTIFY)
935 ptrace_signal_wake_up(child, true);
936 ret = 0;
937 }
938 unlock_task_sighand(child, &flags);
939 break;
940
941 case PTRACE_DETACH:
942 ret = ptrace_detach(child, data);
943 break;
944
945#ifdef CONFIG_BINFMT_ELF_FDPIC
946 case PTRACE_GETFDPIC: {
947 struct mm_struct *mm = get_task_mm(child);
948 unsigned long tmp = 0;
949
950 ret = -ESRCH;
951 if (!mm)
952 break;
953
954 switch (addr) {
955 case PTRACE_GETFDPIC_EXEC:
956 tmp = mm->context.exec_fdpic_loadmap;
957 break;
958 case PTRACE_GETFDPIC_INTERP:
959 tmp = mm->context.interp_fdpic_loadmap;
960 break;
961 default:
962 break;
963 }
964 mmput(mm);
965
966 ret = put_user(tmp, datalp);
967 break;
968 }
969#endif
970
971#ifdef PTRACE_SINGLESTEP
972 case PTRACE_SINGLESTEP:
973#endif
974#ifdef PTRACE_SINGLEBLOCK
975 case PTRACE_SINGLEBLOCK:
976#endif
977#ifdef PTRACE_SYSEMU
978 case PTRACE_SYSEMU:
979 case PTRACE_SYSEMU_SINGLESTEP:
980#endif
981 case PTRACE_SYSCALL:
982 case PTRACE_CONT:
983 return ptrace_resume(child, request, data);
984
985 case PTRACE_KILL:
986 if (child->exit_state)
987 return 0;
988 return ptrace_resume(child, request, SIGKILL);
989
990#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
991 case PTRACE_GETREGSET:
992 case PTRACE_SETREGSET: {
993 struct iovec kiov;
994 struct iovec __user *uiov = datavp;
995
996 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov)))
997 return -EFAULT;
998
999 if (__get_user(kiov.iov_base, &uiov->iov_base) ||
1000 __get_user(kiov.iov_len, &uiov->iov_len))
1001 return -EFAULT;
1002
1003 ret = ptrace_regset(child, request, addr, &kiov);
1004 if (!ret)
1005 ret = __put_user(kiov.iov_len, &uiov->iov_len);
1006 break;
1007 }
1008#endif
1009 default:
1010 break;
1011 }
1012
1013 return ret;
1014}
1015
1016static struct task_struct *ptrace_get_task_struct(pid_t pid)
1017{
1018 struct task_struct *child;
1019
1020 rcu_read_lock();
1021 child = find_task_by_vpid(pid);
1022 if (child)
1023 get_task_struct(child);
1024 rcu_read_unlock();
1025
1026 if (!child)
1027 return ERR_PTR(-ESRCH);
1028 return child;
1029}
1030
1031#ifndef arch_ptrace_attach
1032#define arch_ptrace_attach(child) do { } while (0)
1033#endif
1034
1035SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,
1036 unsigned long, data)
1037{
1038 struct task_struct *child;
1039 long ret;
1040
1041 if (request == PTRACE_TRACEME) {
1042 ret = ptrace_traceme();
1043 if (!ret)
1044 arch_ptrace_attach(current);
1045 goto out;
1046 }
1047
1048 child = ptrace_get_task_struct(pid);
1049 if (IS_ERR(child)) {
1050 ret = PTR_ERR(child);
1051 goto out;
1052 }
1053
1054 if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
1055 ret = ptrace_attach(child, request, addr, data);
1056
1057
1058
1059
1060 if (!ret)
1061 arch_ptrace_attach(child);
1062 goto out_put_task_struct;
1063 }
1064
1065 ret = ptrace_check_attach(child, request == PTRACE_KILL ||
1066 request == PTRACE_INTERRUPT);
1067 if (ret < 0)
1068 goto out_put_task_struct;
1069
1070 ret = arch_ptrace(child, request, addr, data);
1071 if (ret || request != PTRACE_DETACH)
1072 ptrace_unfreeze_traced(child);
1073
1074 out_put_task_struct:
1075 put_task_struct(child);
1076 out:
1077 return ret;
1078}
1079
1080int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr,
1081 unsigned long data)
1082{
1083 unsigned long tmp;
1084 int copied;
1085
1086 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
1087 if (copied != sizeof(tmp))
1088 return -EIO;
1089 return put_user(tmp, (unsigned long __user *)data);
1090}
1091
1092int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
1093 unsigned long data)
1094{
1095 int copied;
1096
1097 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
1098 return (copied == sizeof(data)) ? 0 : -EIO;
1099}
1100
1101#if defined CONFIG_COMPAT
1102#include <linux/compat.h>
1103
1104int compat_ptrace_request(struct task_struct *child, compat_long_t request,
1105 compat_ulong_t addr, compat_ulong_t data)
1106{
1107 compat_ulong_t __user *datap = compat_ptr(data);
1108 compat_ulong_t word;
1109 siginfo_t siginfo;
1110 int ret;
1111
1112 switch (request) {
1113 case PTRACE_PEEKTEXT:
1114 case PTRACE_PEEKDATA:
1115 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
1116 if (ret != sizeof(word))
1117 ret = -EIO;
1118 else
1119 ret = put_user(word, datap);
1120 break;
1121
1122 case PTRACE_POKETEXT:
1123 case PTRACE_POKEDATA:
1124 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
1125 ret = (ret != sizeof(data) ? -EIO : 0);
1126 break;
1127
1128 case PTRACE_GETEVENTMSG:
1129 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
1130 break;
1131
1132 case PTRACE_GETSIGINFO:
1133 ret = ptrace_getsiginfo(child, &siginfo);
1134 if (!ret)
1135 ret = copy_siginfo_to_user32(
1136 (struct compat_siginfo __user *) datap,
1137 &siginfo);
1138 break;
1139
1140 case PTRACE_SETSIGINFO:
1141 memset(&siginfo, 0, sizeof siginfo);
1142 if (copy_siginfo_from_user32(
1143 &siginfo, (struct compat_siginfo __user *) datap))
1144 ret = -EFAULT;
1145 else
1146 ret = ptrace_setsiginfo(child, &siginfo);
1147 break;
1148#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
1149 case PTRACE_GETREGSET:
1150 case PTRACE_SETREGSET:
1151 {
1152 struct iovec kiov;
1153 struct compat_iovec __user *uiov =
1154 (struct compat_iovec __user *) datap;
1155 compat_uptr_t ptr;
1156 compat_size_t len;
1157
1158 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov)))
1159 return -EFAULT;
1160
1161 if (__get_user(ptr, &uiov->iov_base) ||
1162 __get_user(len, &uiov->iov_len))
1163 return -EFAULT;
1164
1165 kiov.iov_base = compat_ptr(ptr);
1166 kiov.iov_len = len;
1167
1168 ret = ptrace_regset(child, request, addr, &kiov);
1169 if (!ret)
1170 ret = __put_user(kiov.iov_len, &uiov->iov_len);
1171 break;
1172 }
1173#endif
1174
1175 default:
1176 ret = ptrace_request(child, request, addr, data);
1177 }
1178
1179 return ret;
1180}
1181
1182asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
1183 compat_long_t addr, compat_long_t data)
1184{
1185 struct task_struct *child;
1186 long ret;
1187
1188 if (request == PTRACE_TRACEME) {
1189 ret = ptrace_traceme();
1190 goto out;
1191 }
1192
1193 child = ptrace_get_task_struct(pid);
1194 if (IS_ERR(child)) {
1195 ret = PTR_ERR(child);
1196 goto out;
1197 }
1198
1199 if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
1200 ret = ptrace_attach(child, request, addr, data);
1201
1202
1203
1204
1205 if (!ret)
1206 arch_ptrace_attach(child);
1207 goto out_put_task_struct;
1208 }
1209
1210 ret = ptrace_check_attach(child, request == PTRACE_KILL ||
1211 request == PTRACE_INTERRUPT);
1212 if (!ret) {
1213 ret = compat_arch_ptrace(child, request, addr, data);
1214 if (ret || request != PTRACE_DETACH)
1215 ptrace_unfreeze_traced(child);
1216 }
1217
1218 out_put_task_struct:
1219 put_task_struct(child);
1220 out:
1221 return ret;
1222}
1223#endif
1224