ptrace.c (0ff555192a8d20385d49d1c420e2e8d409b3c0da) ptrace.c (bf53de907dfdaac178c92d774aae7370d7b97d20)
1/* By Ross Biro 1/23/92 */
2/*
3 * Pentium III FXSR, SSE support
4 * Gareth Hughes <gareth@valinux.com>, May 2000
5 *
6 * BTS tracing
7 * Markus Metzger <markus.t.metzger@intel.com>, Dec 2007
8 */

--- 567 unchanged lines hidden (view full) ---

576 return -ENXIO;
577
578 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
579 target->thread.io_bitmap_ptr,
580 0, IO_BITMAP_BYTES);
581}
582
583#ifdef CONFIG_X86_PTRACE_BTS
1/* By Ross Biro 1/23/92 */
2/*
3 * Pentium III FXSR, SSE support
4 * Gareth Hughes <gareth@valinux.com>, May 2000
5 *
6 * BTS tracing
7 * Markus Metzger <markus.t.metzger@intel.com>, Dec 2007
8 */

--- 567 unchanged lines hidden (view full) ---

576 return -ENXIO;
577
578 return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
579 target->thread.io_bitmap_ptr,
580 0, IO_BITMAP_BYTES);
581}
582
583#ifdef CONFIG_X86_PTRACE_BTS
584/*
585 * The configuration for a particular BTS hardware implementation.
586 */
587struct bts_configuration {
588 /* the size of a BTS record in bytes; at most BTS_MAX_RECORD_SIZE */
589 unsigned char sizeof_bts;
590 /* the size of a field in the BTS record in bytes */
591 unsigned char sizeof_field;
592 /* a bitmask to enable/disable BTS in DEBUGCTL MSR */
593 unsigned long debugctl_mask;
594};
595static struct bts_configuration bts_cfg;
596
597#define BTS_MAX_RECORD_SIZE (8 * 3)
598
599
600/*
601 * Branch Trace Store (BTS) uses the following format. Different
602 * architectures vary in the size of those fields.
603 * - source linear address
604 * - destination linear address
605 * - flags
606 *
607 * Later architectures use 64bit pointers throughout, whereas earlier
608 * architectures use 32bit pointers in 32bit mode.
609 *
610 * We compute the base address for the first 8 fields based on:
611 * - the field size stored in the DS configuration
612 * - the relative field position
613 *
614 * In order to store additional information in the BTS buffer, we use
615 * a special source address to indicate that the record requires
616 * special interpretation.
617 *
618 * Netburst indicated via a bit in the flags field whether the branch
619 * was predicted; this is ignored.
620 */
621
622enum bts_field {
623 bts_from = 0,
624 bts_to,
625 bts_flags,
626
627 bts_escape = (unsigned long)-1,
628 bts_qual = bts_to,
629 bts_jiffies = bts_flags
630};
631
632static inline unsigned long bts_get(const char *base, enum bts_field field)
633{
634 base += (bts_cfg.sizeof_field * field);
635 return *(unsigned long *)base;
636}
637
638static inline void bts_set(char *base, enum bts_field field, unsigned long val)
639{
640 base += (bts_cfg.sizeof_field * field);;
641 (*(unsigned long *)base) = val;
642}
643
644/*
645 * Translate a BTS record from the raw format into the bts_struct format
646 *
647 * out (out): bts_struct interpretation
648 * raw: raw BTS record
649 */
650static void ptrace_bts_translate_record(struct bts_struct *out, const void *raw)
651{
652 memset(out, 0, sizeof(*out));
653 if (bts_get(raw, bts_from) == bts_escape) {
654 out->qualifier = bts_get(raw, bts_qual);
655 out->variant.jiffies = bts_get(raw, bts_jiffies);
656 } else {
657 out->qualifier = BTS_BRANCH;
658 out->variant.lbr.from_ip = bts_get(raw, bts_from);
659 out->variant.lbr.to_ip = bts_get(raw, bts_to);
660 }
661}
662
663static int ptrace_bts_read_record(struct task_struct *child, size_t index,
664 struct bts_struct __user *out)
665{
584static int ptrace_bts_read_record(struct task_struct *child, size_t index,
585 struct bts_struct __user *out)
586{
666 struct bts_struct ret;
667 const void *bts_record;
668 size_t bts_index, bts_end;
587 const struct bts_trace *trace;
588 struct bts_struct bts;
589 const unsigned char *at;
669 int error;
670
590 int error;
591
671 error = ds_get_bts_end(child, &bts_end);
672 if (error < 0)
673 return error;
592 trace = ds_read_bts(child->bts);
593 if (!trace)
594 return -EPERM;
674
595
675 if (bts_end <= index)
676 return -EINVAL;
596 at = trace->ds.top - ((index + 1) * trace->ds.size);
597 if ((void *)at < trace->ds.begin)
598 at += (trace->ds.n * trace->ds.size);
677
599
678 error = ds_get_bts_index(child, &bts_index);
679 if (error < 0)
680 return error;
600 if (!trace->read)
601 return -EOPNOTSUPP;
681
602
682 /* translate the ptrace bts index into the ds bts index */
683 bts_index += bts_end - (index + 1);
684 if (bts_end <= bts_index)
685 bts_index -= bts_end;
686
687 error = ds_access_bts(child, bts_index, &bts_record);
603 error = trace->read(child->bts, at, &bts);
688 if (error < 0)
689 return error;
690
604 if (error < 0)
605 return error;
606
691 ptrace_bts_translate_record(&ret, bts_record);
692
693 if (copy_to_user(out, &ret, sizeof(ret)))
607 if (copy_to_user(out, &bts, sizeof(bts)))
694 return -EFAULT;
695
608 return -EFAULT;
609
696 return sizeof(ret);
610 return sizeof(bts);
697}
698
699static int ptrace_bts_drain(struct task_struct *child,
700 long size,
701 struct bts_struct __user *out)
702{
611}
612
613static int ptrace_bts_drain(struct task_struct *child,
614 long size,
615 struct bts_struct __user *out)
616{
703 struct bts_struct ret;
704 const unsigned char *raw;
705 size_t end, i;
706 int error;
617 const struct bts_trace *trace;
618 const unsigned char *at;
619 int error, drained = 0;
707
620
708 error = ds_get_bts_index(child, &end);
709 if (error < 0)
710 return error;
621 trace = ds_read_bts(child->bts);
622 if (!trace)
623 return -EPERM;
711
624
712 if (size < (end * sizeof(struct bts_struct)))
625 if (!trace->read)
626 return -EOPNOTSUPP;
627
628 if (size < (trace->ds.top - trace->ds.begin))
713 return -EIO;
714
629 return -EIO;
630
715 error = ds_access_bts(child, 0, (const void **)&raw);
716 if (error < 0)
717 return error;
631 for (at = trace->ds.begin; (void *)at < trace->ds.top;
632 out++, drained++, at += trace->ds.size) {
633 struct bts_struct bts;
634 int error;
718
635
719 for (i = 0; i < end; i++, out++, raw += bts_cfg.sizeof_bts) {
720 ptrace_bts_translate_record(&ret, raw);
636 error = trace->read(child->bts, at, &bts);
637 if (error < 0)
638 return error;
721
639
722 if (copy_to_user(out, &ret, sizeof(ret)))
640 if (copy_to_user(out, &bts, sizeof(bts)))
723 return -EFAULT;
724 }
725
641 return -EFAULT;
642 }
643
726 error = ds_clear_bts(child);
644 memset(trace->ds.begin, 0, trace->ds.n * trace->ds.size);
645
646 error = ds_reset_bts(child->bts);
727 if (error < 0)
728 return error;
729
647 if (error < 0)
648 return error;
649
730 return end;
650 return drained;
731}
732
651}
652
733static void ptrace_bts_ovfl(struct task_struct *child)
734{
735 send_sig(child->thread.bts_ovfl_signal, child, 0);
736}
737
738static int ptrace_bts_config(struct task_struct *child,
739 long cfg_size,
740 const struct ptrace_bts_config __user *ucfg)
741{
742 struct ptrace_bts_config cfg;
653static int ptrace_bts_config(struct task_struct *child,
654 long cfg_size,
655 const struct ptrace_bts_config __user *ucfg)
656{
657 struct ptrace_bts_config cfg;
743 int error = 0;
658 unsigned int flags = 0;
744
659
745 error = -EOPNOTSUPP;
746 if (!bts_cfg.sizeof_bts)
747 goto errout;
748
749 error = -EIO;
750 if (cfg_size < sizeof(cfg))
660 if (cfg_size < sizeof(cfg))
751 goto errout;
661 return -EIO;
752
662
753 error = -EFAULT;
754 if (copy_from_user(&cfg, ucfg, sizeof(cfg)))
663 if (copy_from_user(&cfg, ucfg, sizeof(cfg)))
755 goto errout;
664 return -EFAULT;
756
665
757 error = -EINVAL;
758 if ((cfg.flags & PTRACE_BTS_O_SIGNAL) &&
759 !(cfg.flags & PTRACE_BTS_O_ALLOC))
760 goto errout;
666 if (child->bts) {
667 ds_release_bts(child->bts);
668 child->bts = NULL;
669 }
761
670
762 if (cfg.flags & PTRACE_BTS_O_ALLOC) {
763 ds_ovfl_callback_t ovfl = NULL;
764 unsigned int sig = 0;
671 if (cfg.flags & PTRACE_BTS_O_SIGNAL) {
672 if (!cfg.signal)
673 return -EINVAL;
765
674
766 /* we ignore the error in case we were not tracing child */
767 (void)ds_release_bts(child);
675 return -EOPNOTSUPP;
768
676
769 if (cfg.flags & PTRACE_BTS_O_SIGNAL) {
770 if (!cfg.signal)
771 goto errout;
677 child->thread.bts_ovfl_signal = cfg.signal;
678 }
772
679
773 sig = cfg.signal;
774 ovfl = ptrace_bts_ovfl;
775 }
680 if ((cfg.flags & PTRACE_BTS_O_ALLOC) &&
681 (cfg.size != child->bts_size)) {
682 kfree(child->bts_buffer);
776
683
777 error = ds_request_bts(child, /* base = */ NULL, cfg.size, ovfl);
778 if (error < 0)
779 goto errout;
780
781 child->thread.bts_ovfl_signal = sig;
684 child->bts_size = cfg.size;
685 child->bts_buffer = kzalloc(cfg.size, GFP_KERNEL);
686 if (!child->bts_buffer) {
687 child->bts_size = 0;
688 return -ENOMEM;
689 }
782 }
783
690 }
691
784 error = -EINVAL;
785 if (!child->thread.ds_ctx && cfg.flags)
786 goto errout;
787
788 if (cfg.flags & PTRACE_BTS_O_TRACE)
692 if (cfg.flags & PTRACE_BTS_O_TRACE)
789 child->thread.debugctlmsr |= bts_cfg.debugctl_mask;
790 else
791 child->thread.debugctlmsr &= ~bts_cfg.debugctl_mask;
693 flags |= BTS_USER;
792
793 if (cfg.flags & PTRACE_BTS_O_SCHED)
694
695 if (cfg.flags & PTRACE_BTS_O_SCHED)
794 set_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
795 else
796 clear_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
696 flags |= BTS_TIMESTAMPS;
797
697
798 error = sizeof(cfg);
698 child->bts = ds_request_bts(child, child->bts_buffer, child->bts_size,
699 /* ovfl = */ NULL, /* th = */ (size_t)-1,
700 flags);
701 if (IS_ERR(child->bts)) {
702 int error = PTR_ERR(child->bts);
799
703
800out:
801 if (child->thread.debugctlmsr)
802 set_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
803 else
804 clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
704 kfree(child->bts_buffer);
705 child->bts = NULL;
706 child->bts_buffer = NULL;
707 child->bts_size = 0;
805
708
806 return error;
709 return error;
710 }
807
711
808errout:
809 child->thread.debugctlmsr &= ~bts_cfg.debugctl_mask;
810 clear_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
811 goto out;
712 return sizeof(cfg);
812}
813
814static int ptrace_bts_status(struct task_struct *child,
815 long cfg_size,
816 struct ptrace_bts_config __user *ucfg)
817{
713}
714
715static int ptrace_bts_status(struct task_struct *child,
716 long cfg_size,
717 struct ptrace_bts_config __user *ucfg)
718{
719 const struct bts_trace *trace;
818 struct ptrace_bts_config cfg;
720 struct ptrace_bts_config cfg;
819 size_t end;
820 const void *base, *max;
821 int error;
822
823 if (cfg_size < sizeof(cfg))
824 return -EIO;
825
721
722 if (cfg_size < sizeof(cfg))
723 return -EIO;
724
826 error = ds_get_bts_end(child, &end);
827 if (error < 0)
828 return error;
725 trace = ds_read_bts(child->bts);
726 if (!trace)
727 return -EPERM;
829
728
830 error = ds_access_bts(child, /* index = */ 0, &base);
831 if (error < 0)
832 return error;
833
834 error = ds_access_bts(child, /* index = */ end, &max);
835 if (error < 0)
836 return error;
837
838 memset(&cfg, 0, sizeof(cfg));
729 memset(&cfg, 0, sizeof(cfg));
839 cfg.size = (max - base);
730 cfg.size = trace->ds.end - trace->ds.begin;
840 cfg.signal = child->thread.bts_ovfl_signal;
841 cfg.bts_size = sizeof(struct bts_struct);
842
843 if (cfg.signal)
844 cfg.flags |= PTRACE_BTS_O_SIGNAL;
845
731 cfg.signal = child->thread.bts_ovfl_signal;
732 cfg.bts_size = sizeof(struct bts_struct);
733
734 if (cfg.signal)
735 cfg.flags |= PTRACE_BTS_O_SIGNAL;
736
846 if (test_tsk_thread_flag(child, TIF_DEBUGCTLMSR) &&
847 child->thread.debugctlmsr & bts_cfg.debugctl_mask)
737 if (trace->ds.flags & BTS_USER)
848 cfg.flags |= PTRACE_BTS_O_TRACE;
849
738 cfg.flags |= PTRACE_BTS_O_TRACE;
739
850 if (test_tsk_thread_flag(child, TIF_BTS_TRACE_TS))
740 if (trace->ds.flags & BTS_TIMESTAMPS)
851 cfg.flags |= PTRACE_BTS_O_SCHED;
852
853 if (copy_to_user(ucfg, &cfg, sizeof(cfg)))
854 return -EFAULT;
855
856 return sizeof(cfg);
857}
858
741 cfg.flags |= PTRACE_BTS_O_SCHED;
742
743 if (copy_to_user(ucfg, &cfg, sizeof(cfg)))
744 return -EFAULT;
745
746 return sizeof(cfg);
747}
748
859static int ptrace_bts_write_record(struct task_struct *child,
860 const struct bts_struct *in)
749static int ptrace_bts_clear(struct task_struct *child)
861{
750{
862 unsigned char bts_record[BTS_MAX_RECORD_SIZE];
751 const struct bts_trace *trace;
863
752
864 BUG_ON(BTS_MAX_RECORD_SIZE < bts_cfg.sizeof_bts);
753 trace = ds_read_bts(child->bts);
754 if (!trace)
755 return -EPERM;
865
756
866 memset(bts_record, 0, bts_cfg.sizeof_bts);
867 switch (in->qualifier) {
868 case BTS_INVALID:
869 break;
757 memset(trace->ds.begin, 0, trace->ds.n * trace->ds.size);
870
758
871 case BTS_BRANCH:
872 bts_set(bts_record, bts_from, in->variant.lbr.from_ip);
873 bts_set(bts_record, bts_to, in->variant.lbr.to_ip);
874 break;
759 return ds_reset_bts(child->bts);
760}
875
761
876 case BTS_TASK_ARRIVES:
877 case BTS_TASK_DEPARTS:
878 bts_set(bts_record, bts_from, bts_escape);
879 bts_set(bts_record, bts_qual, in->qualifier);
880 bts_set(bts_record, bts_jiffies, in->variant.jiffies);
881 break;
762static int ptrace_bts_size(struct task_struct *child)
763{
764 const struct bts_trace *trace;
882
765
883 default:
884 return -EINVAL;
885 }
766 trace = ds_read_bts(child->bts);
767 if (!trace)
768 return -EPERM;
886
769
887 /* The writing task will be the switched-to task on a context
888 * switch. It needs to write into the switched-from task's BTS
889 * buffer. */
890 return ds_unchecked_write_bts(child, bts_record, bts_cfg.sizeof_bts);
770 return (trace->ds.top - trace->ds.begin) / trace->ds.size;
891}
892
771}
772
893void ptrace_bts_take_timestamp(struct task_struct *tsk,
894 enum bts_qualifier qualifier)
773static void ptrace_bts_fork(struct task_struct *tsk)
895{
774{
896 struct bts_struct rec = {
897 .qualifier = qualifier,
898 .variant.jiffies = jiffies_64
899 };
900
901 ptrace_bts_write_record(tsk, &rec);
775 tsk->bts = NULL;
776 tsk->bts_buffer = NULL;
777 tsk->bts_size = 0;
778 tsk->thread.bts_ovfl_signal = 0;
902}
903
779}
780
904static const struct bts_configuration bts_cfg_netburst = {
905 .sizeof_bts = sizeof(long) * 3,
906 .sizeof_field = sizeof(long),
907 .debugctl_mask = (1<<2)|(1<<3)|(1<<5)
908};
781static void ptrace_bts_untrace(struct task_struct *child)
782{
783 if (unlikely(child->bts)) {
784 ds_release_bts(child->bts);
785 child->bts = NULL;
909
786
910static const struct bts_configuration bts_cfg_pentium_m = {
911 .sizeof_bts = sizeof(long) * 3,
912 .sizeof_field = sizeof(long),
913 .debugctl_mask = (1<<6)|(1<<7)
914};
787 kfree(child->bts_buffer);
788 child->bts_buffer = NULL;
789 child->bts_size = 0;
790 }
791}
915
792
916static const struct bts_configuration bts_cfg_core2 = {
917 .sizeof_bts = 8 * 3,
918 .sizeof_field = 8,
919 .debugctl_mask = (1<<6)|(1<<7)|(1<<9)
920};
793static void ptrace_bts_detach(struct task_struct *child)
794{
795 ptrace_bts_untrace(child);
796}
797#else
798static inline void ptrace_bts_fork(struct task_struct *tsk) {}
799static inline void ptrace_bts_detach(struct task_struct *child) {}
800static inline void ptrace_bts_untrace(struct task_struct *child) {}
801#endif /* CONFIG_X86_PTRACE_BTS */
921
802
922static inline void bts_configure(const struct bts_configuration *cfg)
803void x86_ptrace_fork(struct task_struct *child, unsigned long clone_flags)
923{
804{
924 bts_cfg = *cfg;
805 ptrace_bts_fork(child);
925}
926
806}
807
927void __cpuinit ptrace_bts_init_intel(struct cpuinfo_x86 *c)
808void x86_ptrace_untrace(struct task_struct *child)
928{
809{
929 switch (c->x86) {
930 case 0x6:
931 switch (c->x86_model) {
932 case 0xD:
933 case 0xE: /* Pentium M */
934 bts_configure(&bts_cfg_pentium_m);
935 break;
936 case 0xF: /* Core2 */
937 case 0x1C: /* Atom */
938 bts_configure(&bts_cfg_core2);
939 break;
940 default:
941 /* sorry, don't know about them */
942 break;
943 }
944 break;
945 case 0xF:
946 switch (c->x86_model) {
947 case 0x0:
948 case 0x1:
949 case 0x2: /* Netburst */
950 bts_configure(&bts_cfg_netburst);
951 break;
952 default:
953 /* sorry, don't know about them */
954 break;
955 }
956 break;
957 default:
958 /* sorry, don't know about them */
959 break;
960 }
810 ptrace_bts_untrace(child);
961}
811}
962#endif /* CONFIG_X86_PTRACE_BTS */
963
964/*
965 * Called by kernel/ptrace.c when detaching..
966 *
967 * Make sure the single step bit is not set.
968 */
969void ptrace_disable(struct task_struct *child)
970{
971 user_disable_single_step(child);
972#ifdef TIF_SYSCALL_EMU
973 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
974#endif
812
813/*
814 * Called by kernel/ptrace.c when detaching..
815 *
816 * Make sure the single step bit is not set.
817 */
818void ptrace_disable(struct task_struct *child)
819{
820 user_disable_single_step(child);
821#ifdef TIF_SYSCALL_EMU
822 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
823#endif
975#ifdef CONFIG_X86_PTRACE_BTS
976 (void)ds_release_bts(child);
977
978 child->thread.debugctlmsr &= ~bts_cfg.debugctl_mask;
979 if (!child->thread.debugctlmsr)
980 clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
981
982 clear_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
983#endif /* CONFIG_X86_PTRACE_BTS */
824 ptrace_bts_detach(child);
984}
985
986#if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
987static const struct user_regset_view user_x86_32_view; /* Initialized below. */
988#endif
989
990long arch_ptrace(struct task_struct *child, long request, long addr, long data)
991{

--- 115 unchanged lines hidden (view full) ---

1107 break;
1108
1109 case PTRACE_BTS_STATUS:
1110 ret = ptrace_bts_status
1111 (child, data, (struct ptrace_bts_config __user *)addr);
1112 break;
1113
1114 case PTRACE_BTS_SIZE:
825}
826
827#if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
828static const struct user_regset_view user_x86_32_view; /* Initialized below. */
829#endif
830
831long arch_ptrace(struct task_struct *child, long request, long addr, long data)
832{

--- 115 unchanged lines hidden (view full) ---

948 break;
949
950 case PTRACE_BTS_STATUS:
951 ret = ptrace_bts_status
952 (child, data, (struct ptrace_bts_config __user *)addr);
953 break;
954
955 case PTRACE_BTS_SIZE:
1115 ret = ds_get_bts_index(child, /* pos = */ NULL);
956 ret = ptrace_bts_size(child);
1116 break;
1117
1118 case PTRACE_BTS_GET:
1119 ret = ptrace_bts_read_record
1120 (child, data, (struct bts_struct __user *) addr);
1121 break;
1122
1123 case PTRACE_BTS_CLEAR:
957 break;
958
959 case PTRACE_BTS_GET:
960 ret = ptrace_bts_read_record
961 (child, data, (struct bts_struct __user *) addr);
962 break;
963
964 case PTRACE_BTS_CLEAR:
1124 ret = ds_clear_bts(child);
965 ret = ptrace_bts_clear(child);
1125 break;
1126
1127 case PTRACE_BTS_DRAIN:
1128 ret = ptrace_bts_drain
1129 (child, data, (struct bts_struct __user *) addr);
1130 break;
1131#endif /* CONFIG_X86_PTRACE_BTS */
1132

--- 246 unchanged lines hidden (view full) ---

1379 case PTRACE_SETFPXREGS: /* Set the child extended FPU state. */
1380 return copy_regset_from_user(child, &user_x86_32_view,
1381 REGSET_XFP, 0,
1382 sizeof(struct user32_fxsr_struct),
1383 datap);
1384
1385 case PTRACE_GET_THREAD_AREA:
1386 case PTRACE_SET_THREAD_AREA:
966 break;
967
968 case PTRACE_BTS_DRAIN:
969 ret = ptrace_bts_drain
970 (child, data, (struct bts_struct __user *) addr);
971 break;
972#endif /* CONFIG_X86_PTRACE_BTS */
973

--- 246 unchanged lines hidden (view full) ---

1220 case PTRACE_SETFPXREGS: /* Set the child extended FPU state. */
1221 return copy_regset_from_user(child, &user_x86_32_view,
1222 REGSET_XFP, 0,
1223 sizeof(struct user32_fxsr_struct),
1224 datap);
1225
1226 case PTRACE_GET_THREAD_AREA:
1227 case PTRACE_SET_THREAD_AREA:
1228#ifdef CONFIG_X86_PTRACE_BTS
1229 case PTRACE_BTS_CONFIG:
1230 case PTRACE_BTS_STATUS:
1231 case PTRACE_BTS_SIZE:
1232 case PTRACE_BTS_GET:
1233 case PTRACE_BTS_CLEAR:
1234 case PTRACE_BTS_DRAIN:
1235#endif /* CONFIG_X86_PTRACE_BTS */
1387 return arch_ptrace(child, request, addr, data);
1388
1389 default:
1390 return compat_ptrace_request(child, request, addr, data);
1391 }
1392
1393 return ret;
1394}

--- 196 unchanged lines hidden --- 		1236 return arch_ptrace(child, request, addr, data);
1237
1238 default:
1239 return compat_ptrace_request(child, request, addr, data);
1240 }
1241
1242 return ret;
1243}

--- 196 unchanged lines hidden ---