Pull utrace into release branch (9224652c) · Commits · e / devices / android_kernel_fairphone_FP3

arch/ia64/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ config IA64
		select HAVE_KRETPROBES
		select HAVE_DMA_ATTRS
		select HAVE_KVM
		select HAVE_ARCH_TRACEHOOK
		default y
		help
		The Itanium Processor Family is Intel's 64-bit successor to

arch/ia64/ia32/ia32_entry.S

+6 −1

Original line number	Diff line number	Diff line
		@@ -108,6 +108,11 @@ GLOBAL_ENTRY(ia32_trace_syscall)
		;;
		st8 [r2]=r3 // initialize return code to -ENOSYS
		br.call.sptk.few rp=syscall_trace_enter // give parent a chance to catch syscall args
		cmp.lt p6,p0=r8,r0 // check tracehook
		adds r2=IA64_PT_REGS_R8_OFFSET+16,sp // r2 = &pt_regs.r8
		;;
		(p6) st8.spill [r2]=r8 // store return value in slot for r8
		(p6) br.spnt.few .ret4
		.ret2: // Need to reload arguments (they may be changed by the tracing process)
		adds r2=IA64_PT_REGS_R1_OFFSET+16,sp // r2 = &pt_regs.r1
		adds r3=IA64_PT_REGS_R13_OFFSET+16,sp // r3 = &pt_regs.r13
		@@ -199,7 +204,7 @@ ia32_syscall_table:
		data8 sys_setuid /* 16-bit version */
		data8 sys_getuid /* 16-bit version */
		data8 compat_sys_stime /* 25 */
		data8 sys32_ptrace
		data8 compat_sys_ptrace
		data8 sys32_alarm
		data8 sys_ni_syscall
		data8 sys_pause

arch/ia64/ia32/sys_ia32.c

+6 −77

Original line number	Diff line number	Diff line
		@@ -1194,25 +1194,6 @@ sys32_waitpid (int pid, unsigned int *stat_addr, int options)
		return compat_sys_wait4(pid, stat_addr, options, NULL);
		}

		static unsigned int
		ia32_peek (struct task_struct child, unsigned long addr, unsigned int val)
		{
		size_t copied;
		unsigned int ret;

		copied = access_process_vm(child, addr, val, sizeof(*val), 0);
		return (copied != sizeof(ret)) ? -EIO : 0;
		}

		static unsigned int
		ia32_poke (struct task_struct *child, unsigned long addr, unsigned int val)
		{

		if (access_process_vm(child, addr, &val, sizeof(val), 1) != sizeof(val))
		return -EIO;
		return 0;
		}

		/*
		* The order in which registers are stored in the ptrace regs structure
		*/
		@@ -1510,49 +1491,15 @@ restore_ia32_fpxstate (struct task_struct *tsk, struct ia32_user_fxsr_struct __u
		return 0;
		}

		asmlinkage long
		sys32_ptrace (int request, pid_t pid, unsigned int addr, unsigned int data)
		long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
		compat_ulong_t caddr, compat_ulong_t cdata)
		{
		struct task_struct *child;
		unsigned int value, tmp;
		unsigned long addr = caddr;
		unsigned long data = cdata;
		unsigned int tmp;
		long i, ret;

		lock_kernel();
		if (request == PTRACE_TRACEME) {
		ret = ptrace_traceme();
		goto out;
		}

		child = ptrace_get_task_struct(pid);
		if (IS_ERR(child)) {
		ret = PTR_ERR(child);
		goto out;
		}

		if (request == PTRACE_ATTACH) {
		ret = sys_ptrace(request, pid, addr, data);
		goto out_tsk;
		}

		ret = ptrace_check_attach(child, request == PTRACE_KILL);
		if (ret < 0)
		goto out_tsk;

		switch (request) {
		case PTRACE_PEEKTEXT:
		case PTRACE_PEEKDATA: /* read word at location addr */
		ret = ia32_peek(child, addr, &value);
		if (ret == 0)
		ret = put_user(value, (unsigned int __user *) compat_ptr(data));
		else
		ret = -EIO;
		goto out_tsk;

		case PTRACE_POKETEXT:
		case PTRACE_POKEDATA: /* write the word at location addr */
		ret = ia32_poke(child, addr, data);
		goto out_tsk;

		case PTRACE_PEEKUSR: /* read word at addr in USER area */
		ret = -EIO;
		if ((addr & 3) \|\| addr > 17*sizeof(int))
		@@ -1617,27 +1564,9 @@ sys32_ptrace (int request, pid_t pid, unsigned int addr, unsigned int data)
		compat_ptr(data));
		break;

		case PTRACE_GETEVENTMSG:
		ret = put_user(child->ptrace_message, (unsigned int __user *) compat_ptr(data));
		break;

		case PTRACE_SYSCALL: /* continue, stop after next syscall */
		case PTRACE_CONT: /* restart after signal. */
		case PTRACE_KILL:
		case PTRACE_SINGLESTEP: /* execute chile for one instruction */
		case PTRACE_DETACH: /* detach a process */
		ret = sys_ptrace(request, pid, addr, data);
		break;

		default:
		ret = ptrace_request(child, request, addr, data);
		break;

		return compat_ptrace_request(child, request, caddr, cdata);
		}
		out_tsk:
		put_task_struct(child);
		out:
		unlock_kernel();
		return ret;
		}

arch/ia64/include/asm/ptrace.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -240,6 +240,12 @@ struct switch_stack {
		*/
		# define instruction_pointer(regs) ((regs)->cr_iip + ia64_psr(regs)->ri)

		static inline unsigned long user_stack_pointer(struct pt_regs *regs)
		{
		/* FIXME: should this be bspstore + nr_dirty regs? */
		return regs->ar_bspstore;
		}

		#define regs_return_value(regs) ((regs)->r8)

		/* Conserve space in histogram by encoding slot bits in address
		@@ -319,6 +325,8 @@ struct switch_stack {
		#define arch_has_block_step() (1)
		extern void user_enable_block_step(struct task_struct *);

		#define __ARCH_WANT_COMPAT_SYS_PTRACE

		#endif /* !__KERNEL__ */

		/* pt_all_user_regs is used for PTRACE_GETREGS PTRACE_SETREGS */

arch/ia64/include/asm/syscall.h

0 → 100644

+163 −0

Original line number	Diff line number	Diff line
		/*
		* Access to user system call parameters and results
		*
		* Copyright (C) 2008 Intel Corp. Shaohua Li <shaohua.li@intel.com>
		*
		* This copyrighted material is made available to anyone wishing to use,
		* modify, copy, or redistribute it subject to the terms and conditions
		* of the GNU General Public License v.2.
		*
		* See asm-generic/syscall.h for descriptions of what we must do here.
		*/

		#ifndef _ASM_SYSCALL_H
		#define _ASM_SYSCALL_H 1

		#include <linux/sched.h>
		#include <linux/err.h>

		static inline long syscall_get_nr(struct task_struct *task,
		struct pt_regs *regs)
		{
		if ((long)regs->cr_ifs < 0) /* Not a syscall */
		return -1;

		#ifdef CONFIG_IA32_SUPPORT
		if (IS_IA32_PROCESS(regs))
		return regs->r1;
		#endif

		return regs->r15;
		}

		static inline void syscall_rollback(struct task_struct *task,
		struct pt_regs *regs)
		{
		#ifdef CONFIG_IA32_SUPPORT
		if (IS_IA32_PROCESS(regs))
		regs->r8 = regs->r1;
		#endif

		/* do nothing */
		}

		static inline long syscall_get_error(struct task_struct *task,
		struct pt_regs *regs)
		{
		#ifdef CONFIG_IA32_SUPPORT
		if (IS_IA32_PROCESS(regs))
		return regs->r8;
		#endif

		return regs->r10 == -1 ? regs->r8:0;
		}

		static inline long syscall_get_return_value(struct task_struct *task,
		struct pt_regs *regs)
		{
		return regs->r8;
		}

		static inline void syscall_set_return_value(struct task_struct *task,
		struct pt_regs *regs,
		int error, long val)
		{
		#ifdef CONFIG_IA32_SUPPORT
		if (IS_IA32_PROCESS(regs)) {
		regs->r8 = (long) error ? error : val;
		return;
		}
		#endif

		if (error) {
		/* error < 0, but ia64 uses > 0 return value */
		regs->r8 = -error;
		regs->r10 = -1;
		} else {
		regs->r8 = val;
		regs->r10 = 0;
		}
		}

		extern void ia64_syscall_get_set_arguments(struct task_struct *task,
		struct pt_regs *regs, unsigned int i, unsigned int n,
		unsigned long *args, int rw);
		static inline void syscall_get_arguments(struct task_struct *task,
		struct pt_regs *regs,
		unsigned int i, unsigned int n,
		unsigned long *args)
		{
		BUG_ON(i + n > 6);

		#ifdef CONFIG_IA32_SUPPORT
		if (IS_IA32_PROCESS(regs)) {
		switch (i + n) {
		case 6:
		if (!n--) break;
		*args++ = regs->r13;
		case 5:
		if (!n--) break;
		*args++ = regs->r15;
		case 4:
		if (!n--) break;
		*args++ = regs->r14;
		case 3:
		if (!n--) break;
		*args++ = regs->r10;
		case 2:
		if (!n--) break;
		*args++ = regs->r9;
		case 1:
		if (!n--) break;
		*args++ = regs->r11;
		case 0:
		if (!n--) break;
		default:
		BUG();
		break;
		}

		return;
		}
		#endif
		ia64_syscall_get_set_arguments(task, regs, i, n, args, 0);
		}

		static inline void syscall_set_arguments(struct task_struct *task,
		struct pt_regs *regs,
		unsigned int i, unsigned int n,
		unsigned long *args)
		{
		BUG_ON(i + n > 6);

		#ifdef CONFIG_IA32_SUPPORT
		if (IS_IA32_PROCESS(regs)) {
		switch (i + n) {
		case 6:
		if (!n--) break;
		regs->r13 = *args++;
		case 5:
		if (!n--) break;
		regs->r15 = *args++;
		case 4:
		if (!n--) break;
		regs->r14 = *args++;
		case 3:
		if (!n--) break;
		regs->r10 = *args++;
		case 2:
		if (!n--) break;
		regs->r9 = *args++;
		case 1:
		if (!n--) break;
		regs->r11 = *args++;
		case 0:
		if (!n--) break;
		}

		return;
		}
		#endif
		ia64_syscall_get_set_arguments(task, regs, i, n, args, 1);
		}
		#endif /* _ASM_SYSCALL_H */