aboutsummaryrefslogtreecommitdiffstats
path: root/arch/sparc64
diff options
context:
space:
mode:
authorDavid S. Miller <davem@davemloft.net>2008-02-08 01:46:09 -0500
committerDavid S. Miller <davem@davemloft.net>2008-02-08 01:46:09 -0500
commit2ba85f3a58441dda35c62f0bc24e0dc3de432a88 (patch)
tree2f44da903627afd01badc01f0fed75fcb4c2a510 /arch/sparc64
parentdf922075f2a55b1ae71a6fe589c1cc1b91381f4f (diff)
[SPARC64]: Make use of compat_sys_ptrace()
Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'arch/sparc64')
-rw-r--r--arch/sparc64/kernel/ptrace.c266
-rw-r--r--arch/sparc64/kernel/systbls.S2
2 files changed, 109 insertions, 159 deletions
diff --git a/arch/sparc64/kernel/ptrace.c b/arch/sparc64/kernel/ptrace.c
index 51f012410f9d..9a1ba1fe859d 100644
--- a/arch/sparc64/kernel/ptrace.c
+++ b/arch/sparc64/kernel/ptrace.c
@@ -684,72 +684,39 @@ const struct user_regset_view *task_user_regset_view(struct task_struct *task)
684 return &user_sparc64_view; 684 return &user_sparc64_view;
685} 685}
686 686
687long arch_ptrace(struct task_struct *child, long request, long addr, long data) 687struct compat_fps {
688 unsigned int regs[32];
689 unsigned int fsr;
690 unsigned int flags;
691 unsigned int extra;
692 unsigned int fpqd;
693 struct compat_fq {
694 unsigned int insnaddr;
695 unsigned int insn;
696 } fpq[16];
697};
698
699long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
700 compat_ulong_t caddr, compat_ulong_t cdata)
688{ 701{
689 long addr2 = task_pt_regs(current)->u_regs[UREG_I4]; 702 const struct user_regset_view *view = task_user_regset_view(child);
690 const struct user_regset_view *view; 703 compat_ulong_t caddr2 = task_pt_regs(current)->u_regs[UREG_I4];
704 struct pt_regs32 __user *pregs;
705 struct compat_fps __user *fps;
706 unsigned long addr2 = caddr2;
707 unsigned long addr = caddr;
708 unsigned long data = cdata;
691 int ret; 709 int ret;
692 710
693 if (test_thread_flag(TIF_32BIT)) 711 pregs = (struct pt_regs32 __user *) addr;
694 addr2 &= 0xffffffffUL; 712 fps = (struct compat_fps __user *) addr;
695 713
696 view = task_user_regset_view(child); 714 switch (request) {
697
698 switch(request) {
699 case PTRACE_PEEKUSR: 715 case PTRACE_PEEKUSR:
700 ret = (addr != 0) ? -EIO : 0; 716 ret = (addr != 0) ? -EIO : 0;
701 break; 717 break;
702 718
703 case PTRACE_PEEKTEXT: /* read word at location addr. */ 719 case PTRACE_GETREGS:
704 case PTRACE_PEEKDATA: {
705 unsigned long tmp64;
706 unsigned int tmp32;
707 int copied;
708
709 ret = -EIO;
710 if (test_thread_flag(TIF_32BIT)) {
711 copied = access_process_vm(child, addr,
712 &tmp32, sizeof(tmp32), 0);
713 if (copied == sizeof(tmp32))
714 ret = put_user(tmp32,
715 (unsigned int __user *) data);
716 } else {
717 copied = access_process_vm(child, addr,
718 &tmp64, sizeof(tmp64), 0);
719 if (copied == sizeof(tmp64))
720 ret = put_user(tmp64,
721 (unsigned long __user *) data);
722 }
723 break;
724 }
725
726 case PTRACE_POKETEXT: /* write the word at location addr. */
727 case PTRACE_POKEDATA: {
728 unsigned long tmp64;
729 unsigned int tmp32;
730 int copied;
731
732 ret = -EIO;
733 if (test_thread_flag(TIF_32BIT)) {
734 tmp32 = data;
735 copied = access_process_vm(child, addr,
736 &tmp32, sizeof(tmp32), 1);
737 if (copied == sizeof(tmp32))
738 ret = 0;
739 } else {
740 tmp64 = data;
741 copied = access_process_vm(child, addr,
742 &tmp64, sizeof(tmp64), 1);
743 if (copied == sizeof(tmp64))
744 ret = 0;
745 }
746 break;
747 }
748
749 case PTRACE_GETREGS: {
750 struct pt_regs32 __user *pregs =
751 (struct pt_regs32 __user *) addr;
752
753 ret = copy_regset_to_user(child, view, REGSET_GENERAL, 720 ret = copy_regset_to_user(child, view, REGSET_GENERAL,
754 32 * sizeof(u32), 721 32 * sizeof(u32),
755 4 * sizeof(u32), 722 4 * sizeof(u32),
@@ -760,29 +727,8 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
760 15 * sizeof(u32), 727 15 * sizeof(u32),
761 &pregs->u_regs[0]); 728 &pregs->u_regs[0]);
762 break; 729 break;
763 }
764
765 case PTRACE_GETREGS64: {
766 struct pt_regs __user *pregs = (struct pt_regs __user *) addr;
767
768 ret = copy_regset_to_user(child, view, REGSET_GENERAL,
769 1 * sizeof(u64),
770 15 * sizeof(u64),
771 &pregs->u_regs[0]);
772 if (!ret) {
773 /* XXX doesn't handle 'y' register correctly XXX */
774 ret = copy_regset_to_user(child, view, REGSET_GENERAL,
775 32 * sizeof(u64),
776 4 * sizeof(u64),
777 &pregs->tstate);
778 }
779 break;
780 }
781
782 case PTRACE_SETREGS: {
783 struct pt_regs32 __user *pregs =
784 (struct pt_regs32 __user *) addr;
785 730
731 case PTRACE_SETREGS:
786 ret = copy_regset_from_user(child, view, REGSET_GENERAL, 732 ret = copy_regset_from_user(child, view, REGSET_GENERAL,
787 32 * sizeof(u32), 733 32 * sizeof(u32),
788 4 * sizeof(u32), 734 4 * sizeof(u32),
@@ -793,39 +739,8 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
793 15 * sizeof(u32), 739 15 * sizeof(u32),
794 &pregs->u_regs[0]); 740 &pregs->u_regs[0]);
795 break; 741 break;
796 }
797
798 case PTRACE_SETREGS64: {
799 struct pt_regs __user *pregs = (struct pt_regs __user *) addr;
800
801 ret = copy_regset_from_user(child, view, REGSET_GENERAL,
802 1 * sizeof(u64),
803 15 * sizeof(u64),
804 &pregs->u_regs[0]);
805 if (!ret) {
806 /* XXX doesn't handle 'y' register correctly XXX */
807 ret = copy_regset_from_user(child, view, REGSET_GENERAL,
808 32 * sizeof(u64),
809 4 * sizeof(u64),
810 &pregs->tstate);
811 }
812 break;
813 }
814
815 case PTRACE_GETFPREGS: {
816 struct fps {
817 unsigned int regs[32];
818 unsigned int fsr;
819 unsigned int flags;
820 unsigned int extra;
821 unsigned int fpqd;
822 struct fq {
823 unsigned int insnaddr;
824 unsigned int insn;
825 } fpq[16];
826 };
827 struct fps __user *fps = (struct fps __user *) addr;
828 742
743 case PTRACE_GETFPREGS:
829 ret = copy_regset_to_user(child, view, REGSET_FP, 744 ret = copy_regset_to_user(child, view, REGSET_FP,
830 0 * sizeof(u32), 745 0 * sizeof(u32),
831 32 * sizeof(u32), 746 32 * sizeof(u32),
@@ -843,36 +758,8 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
843 ret = -EFAULT; 758 ret = -EFAULT;
844 } 759 }
845 break; 760 break;
846 }
847
848 case PTRACE_GETFPREGS64: {
849 struct fps {
850 unsigned int regs[64];
851 unsigned long fsr;
852 };
853 struct fps __user *fps = (struct fps __user *) addr;
854
855 ret = copy_regset_to_user(child, view, REGSET_FP,
856 0 * sizeof(u64),
857 33 * sizeof(u64),
858 fps);
859 break;
860 }
861
862 case PTRACE_SETFPREGS: {
863 struct fps {
864 unsigned int regs[32];
865 unsigned int fsr;
866 unsigned int flags;
867 unsigned int extra;
868 unsigned int fpqd;
869 struct fq {
870 unsigned int insnaddr;
871 unsigned int insn;
872 } fpq[16];
873 };
874 struct fps __user *fps = (struct fps __user *) addr;
875 761
762 case PTRACE_SETFPREGS:
876 ret = copy_regset_from_user(child, view, REGSET_FP, 763 ret = copy_regset_from_user(child, view, REGSET_FP,
877 0 * sizeof(u32), 764 0 * sizeof(u32),
878 32 * sizeof(u32), 765 32 * sizeof(u32),
@@ -883,21 +770,94 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
883 1 * sizeof(u32), 770 1 * sizeof(u32),
884 &fps->fsr); 771 &fps->fsr);
885 break; 772 break;
773
774 case PTRACE_READTEXT:
775 case PTRACE_READDATA:
776 ret = ptrace_readdata(child, addr,
777 (char __user *)addr2, data);
778 if (ret == data)
779 ret = 0;
780 else if (ret >= 0)
781 ret = -EIO;
782 break;
783
784 case PTRACE_WRITETEXT:
785 case PTRACE_WRITEDATA:
786 ret = ptrace_writedata(child, (char __user *) addr2,
787 addr, data);
788 if (ret == data)
789 ret = 0;
790 else if (ret >= 0)
791 ret = -EIO;
792 break;
793
794 default:
795 ret = compat_ptrace_request(child, request, addr, data);
796 break;
886 } 797 }
887 798
888 case PTRACE_SETFPREGS64: { 799 return ret;
889 struct fps { 800}
890 unsigned int regs[64]; 801
891 unsigned long fsr; 802struct fps {
892 }; 803 unsigned int regs[64];
893 struct fps __user *fps = (struct fps __user *) addr; 804 unsigned long fsr;
805};
806
807long arch_ptrace(struct task_struct *child, long request, long addr, long data)
808{
809 const struct user_regset_view *view = task_user_regset_view(child);
810 struct pt_regs __user *pregs = (struct pt_regs __user *) addr;
811 unsigned long addr2 = task_pt_regs(current)->u_regs[UREG_I4];
812 struct fps __user *fps = (struct fps __user *) addr;
813 int ret;
814
815 switch (request) {
816 case PTRACE_PEEKUSR:
817 ret = (addr != 0) ? -EIO : 0;
818 break;
894 819
820 case PTRACE_GETREGS64:
821 ret = copy_regset_to_user(child, view, REGSET_GENERAL,
822 1 * sizeof(u64),
823 15 * sizeof(u64),
824 &pregs->u_regs[0]);
825 if (!ret) {
826 /* XXX doesn't handle 'y' register correctly XXX */
827 ret = copy_regset_to_user(child, view, REGSET_GENERAL,
828 32 * sizeof(u64),
829 4 * sizeof(u64),
830 &pregs->tstate);
831 }
832 break;
833
834 case PTRACE_SETREGS64:
835 ret = copy_regset_from_user(child, view, REGSET_GENERAL,
836 1 * sizeof(u64),
837 15 * sizeof(u64),
838 &pregs->u_regs[0]);
839 if (!ret) {
840 /* XXX doesn't handle 'y' register correctly XXX */
841 ret = copy_regset_from_user(child, view, REGSET_GENERAL,
842 32 * sizeof(u64),
843 4 * sizeof(u64),
844 &pregs->tstate);
845 }
846 break;
847
848 case PTRACE_GETFPREGS64:
849 ret = copy_regset_to_user(child, view, REGSET_FP,
850 0 * sizeof(u64),
851 33 * sizeof(u64),
852 fps);
853 break;
854
855 case PTRACE_SETFPREGS64:
895 ret = copy_regset_to_user(child, view, REGSET_FP, 856 ret = copy_regset_to_user(child, view, REGSET_FP,
896 0 * sizeof(u64), 857 0 * sizeof(u64),
897 33 * sizeof(u64), 858 33 * sizeof(u64),
898 fps); 859 fps);
899 break; 860 break;
900 }
901 861
902 case PTRACE_READTEXT: 862 case PTRACE_READTEXT:
903 case PTRACE_READDATA: 863 case PTRACE_READDATA:
@@ -919,16 +879,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
919 ret = -EIO; 879 ret = -EIO;
920 break; 880 break;
921 881
922 case PTRACE_GETEVENTMSG: {
923 if (test_thread_flag(TIF_32BIT))
924 ret = put_user(child->ptrace_message,
925 (unsigned int __user *) data);
926 else
927 ret = put_user(child->ptrace_message,
928 (unsigned long __user *) data);
929 break;
930 }
931
932 default: 882 default:
933 ret = ptrace_request(child, request, addr, data); 883 ret = ptrace_request(child, request, addr, data);
934 break; 884 break;
diff --git a/arch/sparc64/kernel/systbls.S b/arch/sparc64/kernel/systbls.S
index adc62f490f36..6b9b718e24af 100644
--- a/arch/sparc64/kernel/systbls.S
+++ b/arch/sparc64/kernel/systbls.S
@@ -23,7 +23,7 @@ sys_call_table32:
23/*10*/ .word sys_unlink, sunos_execv, sys_chdir, sys32_chown16, sys32_mknod 23/*10*/ .word sys_unlink, sunos_execv, sys_chdir, sys32_chown16, sys32_mknod
24/*15*/ .word sys_chmod, sys32_lchown16, sparc_brk, sys32_perfctr, sys32_lseek 24/*15*/ .word sys_chmod, sys32_lchown16, sparc_brk, sys32_perfctr, sys32_lseek
25/*20*/ .word sys_getpid, sys_capget, sys_capset, sys32_setuid16, sys32_getuid16 25/*20*/ .word sys_getpid, sys_capget, sys_capset, sys32_setuid16, sys32_getuid16
26/*25*/ .word sys32_vmsplice, sys_ptrace, sys_alarm, sys32_sigaltstack, sys32_pause 26/*25*/ .word sys32_vmsplice, compat_sys_ptrace, sys_alarm, sys32_sigaltstack, sys32_pause
27/*30*/ .word compat_sys_utime, sys_lchown, sys_fchown, sys32_access, sys32_nice 27/*30*/ .word compat_sys_utime, sys_lchown, sys_fchown, sys32_access, sys32_nice
28 .word sys_chown, sys_sync, sys32_kill, compat_sys_newstat, sys32_sendfile 28 .word sys_chown, sys_sync, sys32_kill, compat_sys_newstat, sys32_sendfile
29/*40*/ .word compat_sys_newlstat, sys_dup, sys_pipe, compat_sys_times, sys_getuid 29/*40*/ .word compat_sys_newlstat, sys_dup, sys_pipe, compat_sys_times, sys_getuid
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-23 19:25:43 -0400